Initial commit

engines/chewy/dialogs/inventory.cpp

@@ -0,0 +1,725 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "chewy/dialogs/inventory.h"
+#include "chewy/rooms/room44.h"
+#include "chewy/rooms/room58.h"
+#include "chewy/cursor.h"
+#include "chewy/events.h"
+#include "chewy/font.h"
+#include "chewy/globals.h"
+#include "chewy/menus.h"
+#include "chewy/sound.h"
+
+namespace Chewy {
+namespace Dialogs {
+
+int16 Inventory::inv_rand_x;
+int16 Inventory::inv_rand_y;
+
+
+void Inventory::plot_menu() {
+	_G(out)->setPointer(_G(workptr));
+	buildMenu(WIN_INVENTORY);
+
+	// Draw inventory slots grid
+	for (int16 j = 0; j < 3; j++) {
+		for (int16 i = 0; i < 5; i++) {
+			_G(out)->boxFill(
+				WIN_INF_X + 14 + i * 54,
+				WIN_INF_Y + 6 + 30 + j * 32,
+				WIN_INF_X + 14 + i * 54 + 40,
+				WIN_INF_Y + 6 + 30 + j * 32 + 24,
+				12
+			);
+		}
+	}
+
+	int16 y;
+	int16 hotspotId = _G(out)->findHotspot(_G(inventoryHotspots));
+
+	// Highlight hotspots
+	if (hotspotId != -1) {
+		if (hotspotId < 5) {
+			_G(out)->boxFill(
+				_G(inventoryHotspots)[hotspotId].left,
+				_G(inventoryHotspots)[hotspotId].top,
+				_G(inventoryHotspots)[hotspotId].right + 1,
+				_G(inventoryHotspots)[hotspotId].bottom + 5,
+				41
+			);
+		} else {
+			const int16 x = (g_events->_mousePos.x - (WIN_INF_X)) / 54;
+			y = (g_events->_mousePos.y - (WIN_INF_Y + 4 + 30)) / 30;
+			hotspotId = x + (y * 5);
+			hotspotId += _G(gameState).InventY * 5;
+			if (hotspotId < (_G(gameState).InventY + 3) * 5) {
+				_G(out)->boxFill(
+					WIN_INF_X + 14 + x * 54,
+					WIN_INF_Y + 6 + 30 + y * 32,
+					WIN_INF_X + 14 + x * 54 + 40,
+					WIN_INF_Y + 6 + 30 + y * 32 + 24,
+					41
+				);
+			}
+		}
+	}
+
+	if (inv_rand_x != -1) {
+		_G(out)->boxFill(
+			WIN_INF_X + 14 + inv_rand_x * 54,
+			WIN_INF_Y + 6 + 30 + inv_rand_y * 32,
+			WIN_INF_X + 14 + inv_rand_x * 54 + 40,
+			WIN_INF_Y + 6 + 30 + inv_rand_y * 32 + 24,
+			41
+		);
+		_G(out)->box(
+			WIN_INF_X + 14 + inv_rand_x * 54 - 1,
+			WIN_INF_Y + 6 + 30 + inv_rand_y * 32 - 1,
+			WIN_INF_X + 14 + inv_rand_x * 54 + 40 + 1,
+			WIN_INF_Y + 6 + 30 + inv_rand_y * 32 + 24 + 1,
+			14
+		);
+	}
+
+	const int16 ANI_INVENT_END[3] = {7, 16, 24};
+
+	// Draw inventory action icons (look and use, to the left of the dialog)
+	for (int16 i = 0; i < 2; i++) {
+		_G(ani_invent_delay)[i][0] -= 1;
+		if (_G(ani_invent_delay)[i][0] <= 0) {
+			_G(ani_invent_delay)[i][0] = _G(ani_invent_delay)[i][1];
+			++_G(ani_count)[i];
+			if (_G(ani_count)[i] > ANI_INVENT_END[i]) {
+				_G(ani_count)[i] = _G(ani_invent_anf)[i];
+				_G(ani_invent_delay)[i][0] = 30000;
+			}
+		}
+
+		y = (i == 2) ? 3 : 0;
+
+		_G(out)->spriteSet(
+			_G(cur)->getCursorSprite(_G(ani_count)[i]),
+			WIN_INF_X + 8 + i * 32,
+			WIN_INF_Y + 12 - y,
+			_G(scr_width),
+			_G(cur)->getCursorWidth(_G(ani_count)[i]),
+			_G(cur)->getCursorHeight(_G(ani_count)[i])
+		);
+	}
+
+	// Draw inventory arrows (up and down, to the right of the dialog)
+	for (int16 i = 0; i < 2; i++) {
+		_G(out)->spriteSet(
+			_G(menutaf)->image[ARROW_UP + i],
+			WIN_INF_X + 200 + i * 40,
+			WIN_INF_Y + 12,
+			_G(scr_width)
+		);
+	}
+
+	y = WIN_INF_Y + 6 + 30;
+
+	// Draw inventory items
+	for (int16 j = 0; j < 3; j++) {
+		for (int16 i = 0; i < 5; i++) {
+			const int slot = (_G(gameState).InventY + j) * 5 + i;
+			const int16 invSlot = _G(gameState).InventSlot[slot];
+			if (invSlot != -1) {
+				const int16 *xy = (const int16 *)_G(inv_spr)[invSlot];
+				const int16 x1 = (40 - xy[0]) / 2;
+				const int16 y1 = (24 - xy[1]) / 2;
+
+				_G(out)->spriteSet(
+					_G(inv_spr)[invSlot],
+					x1 + WIN_INF_X + 14 + i * 54,
+					y1 + y + 32 * j,
+					_G(scr_width)
+				);
+			}
+		}
+	}
+
+	// Show up arrow, if needed
+	if (_G(gameState).InventY) {
+		const char c[2] = { 24, 0 };
+		_G(out)->printxy(225, 32, 19, 300, _G(scr_width), c);
+	}
+
+	// Show down arrow, if needed
+	for (int i = 5 * (_G(gameState).InventY + 3); i < 140; ++i) {
+		if (_G(gameState).InventSlot[i] != -1) {
+			const char c[2] = { 25, 0 };
+			_G(out)->printxy(265, 29, 19, 300, _G(scr_width), c);
+			break;
+		}
+	}
+}
+
+bool checkInventorykey() {
+	return g_events->_kbInfo._scanCode == Common::KEYCODE_RETURN ||
+		   g_events->_kbInfo._scanCode == Common::KEYCODE_F1 ||
+		   g_events->_kbInfo._scanCode == Common::KEYCODE_F2;
+}
+
+void Inventory::menu() {
+	_G(flags).InventMenu = true;
+	const int16 oldDispFlag = _G(gameState).DispFlag;
+	_G(gameState).DispFlag = false;
+	const uint16 oldAutoAniPlay = _G(flags).AutoAniPlay;
+	_G(flags).AutoAniPlay = true;
+	_G(flags).StopAutoObj = true;
+	_G(menu_display) = 0;
+	_G(cur)->move(152, 92);
+	g_events->_mousePos.x = 152;
+	g_events->_mousePos.y = 92;
+
+	_G(invent_cur_mode) = CUR_USE;
+
+	if (!_G(cur)->usingInventoryCursor()) {
+		_G(invent_cur_mode) = CUR_USE;
+		cursorChoice(CUR_USE);
+	}
+
+	int16 menu_flag1 = MENU_DISPLAY;
+	int16 taste_flag = 28;
+
+	_G(minfo).button = 0;
+	g_events->_kbInfo._keyCode = '\0';
+	g_events->_kbInfo._scanCode = '\0';
+
+	for (int16 i = 0; i < 3; i++) {
+		_G(ani_invent_delay)[i][0] = 30000;
+		_G(ani_count)[i] = _G(ani_invent_anf)[i];
+	}
+
+	int16 ret_look = -1;
+	bool menuFirstFl = false;
+	_G(show_invent_menu) = 1;
+
+	while (_G(show_invent_menu) == 1 && !SHOULD_QUIT) {
+		if (_G(minfo).button == 1 || checkInventorykey()) {
+			int16 k = _G(out)->findHotspot(_G(inventoryHotspots));
+			if (g_events->_kbInfo._scanCode == Common::KEYCODE_F1)
+				k = 0;
+			else if (g_events->_kbInfo._scanCode == Common::KEYCODE_F2)
+				k = 1;
+			else if (g_events->_kbInfo._scanCode == Common::KEYCODE_RETURN)
+				k = 5;
+
+			_G(minfo).button = 0;
+			g_events->_kbInfo._keyCode = '\0';
+			g_events->_kbInfo._scanCode = '\0';
+
+			switch (k) {
+			case 0:
+				_G(invent_cur_mode) = CUR_USE;
+				_G(menu_item) = CUR_USE;
+				if (!_G(cur)->usingInventoryCursor()) {
+					cursorChoice(CUR_USE);
+				}
+				break;
+
+			case 1:
+				if (_G(cur)->usingInventoryCursor()) {
+					inv_rand_x = -1;
+					inv_rand_y = -1;
+					ret_look = look(_G(cur)->getInventoryCursor(), INV_ATS_MODE, -1);
+
+					taste_flag = Common::KEYCODE_ESCAPE;
+				} else {
+					_G(invent_cur_mode) = CUR_LOOK;
+					_G(menu_item) = CUR_LOOK;
+					cursorChoice(CUR_LOOK);
+				}
+				break;
+
+			case 3:
+				g_events->setHotKey(Common::KEYCODE_PAGEUP);
+				break;
+
+			case 4:
+				g_events->setHotKey(Common::KEYCODE_PAGEDOWN);
+				break;
+
+			case 5:
+				inv_rand_x = (g_events->_mousePos.x - (WIN_INF_X)) / 54;
+				inv_rand_y = (g_events->_mousePos.y - (WIN_INF_Y + 4 + 30)) / 30;
+				k = inv_rand_x + (inv_rand_y * 5);
+				k += _G(gameState).InventY * 5;
+				if (_G(invent_cur_mode) == CUR_USE) {
+					if (!_G(cur)->usingInventoryCursor()) {
+						if (_G(gameState).InventSlot[k] != -1 && calc_use_invent(_G(gameState).InventSlot[k]) == false) {
+							_G(menu_item) = CUR_USE;
+							_G(cur)->setInventoryCursor(_G(gameState).InventSlot[k]);
+							del_invent_slot(_G(gameState).InventSlot[k]);
+						}
+					} else if (_G(gameState).InventSlot[k] != -1)
+						evaluateObj(_G(gameState).InventSlot[k], INVENTORY_NORMAL);
+					else {
+						_G(gameState).InventSlot[k] = _G(cur)->getInventoryCursor();
+						_G(obj)->sort();
+						_G(cur)->setInventoryCursor(-1);
+						_G(menu_item) = _G(invent_cur_mode);
+						cursorChoice(_G(invent_cur_mode));
+					}
+				} else if (_G(invent_cur_mode) == CUR_LOOK && _G(gameState).InventSlot[k] != -1 && calc_use_invent(_G(gameState).InventSlot[k]) == false) {
+					ret_look = look(_G(gameState).InventSlot[k], INV_ATS_MODE, -1);
+					cursorChoice(_G(invent_cur_mode));
+					taste_flag = Common::KEYCODE_ESCAPE;
+				}
+				break;
+
+			default:
+				break;
+			}
+		} else if (_G(minfo).button == 2 || g_events->_kbInfo._keyCode == Common::KEYCODE_ESCAPE) {
+			// Set virtual key
+			g_events->setHotKey(Common::KEYCODE_ESCAPE);
+			_G(minfo).button = 0;
+			g_events->_kbInfo._keyCode = '\0';
+			g_events->_kbInfo._scanCode = '\0';
+		}
+
+		if (ret_look == 0) {
+			_G(invent_cur_mode) = CUR_USE;
+			_G(menu_item) = CUR_USE;
+			if (!_G(cur)->usingInventoryCursor())
+				cursorChoice(CUR_USE);
+		} else if (ret_look == 5) {
+			taste_flag = false;
+			_G(minfo).button = 1;
+		}
+
+		ret_look = -1;
+		int16 keyCode = g_events->getSwitchCode();
+		// The original hid the cursor here
+
+		if (taste_flag) {
+			if (keyCode != taste_flag)
+				taste_flag = 0;
+		} else {
+			switch (keyCode) {
+			case Common::KEYCODE_ESCAPE:
+				if (!menuFirstFl) {
+					_G(cur)->showCursor();
+					while (g_events->getSwitchCode() == Common::KEYCODE_ESCAPE) {
+						SHOULD_QUIT_RETURN;
+						setupScreen(NO_SETUP);
+						inv_rand_x = -1;
+						inv_rand_y = -1;
+						plot_menu();
+						_G(cur)->updateCursor();
+						_G(out)->copyToScreen();
+					}
+				} else {
+					if (menu_flag1 != MENU_DISPLAY) {
+						menu_flag1 = MENU_HIDE;
+						_G(show_invent_menu) = false;
+					}
+				}
+				break;
+
+			case Common::KEYCODE_RIGHT:
+				if (g_events->_mousePos.x < 320 - _G(cur)->getCursorWidth())
+					g_events->_mousePos.x += 3;
+				break;
+
+			case Common::KEYCODE_LEFT:
+				if (g_events->_mousePos.x > 2)
+					g_events->_mousePos.x -= 3;
+				break;
+
+			case Common::KEYCODE_UP:
+				if (g_events->_mousePos.y > 2)
+					g_events->_mousePos.y -= 3;
+				break;
+
+			case Common::KEYCODE_DOWN:
+				if (g_events->_mousePos.y < 197 - _G(cur)->getCursorHeight())
+					g_events->_mousePos.y += 3;
+				break;
+
+			case Common::KEYCODE_PAGEUP:
+				if (_G(gameState).InventY > 0)
+					--_G(gameState).InventY;
+				g_events->_kbInfo._keyCode = '\0';
+				g_events->_kbInfo._scanCode = '\0';
+				break;
+
+			case Common::KEYCODE_PAGEDOWN:
+				if (_G(gameState).InventY < (MAX_MOV_OBJ / 5) - 3)
+					++_G(gameState).InventY;
+				g_events->_kbInfo._keyCode = '\0';
+				g_events->_kbInfo._scanCode = '\0';
+				break;
+
+			default:
+				break;
+			}
+			menuFirstFl = true;
+		}
+
+		if (_G(show_invent_menu) != 2) {
+			setupScreen(NO_SETUP);
+			if (menu_flag1 != MENU_HIDE) {
+				inv_rand_x = -1;
+				inv_rand_y = -1;
+				plot_menu();
+			}
+			if (menu_flag1 == false)
+				_G(cur)->updateCursor();
+			_G(out)->setPointer(nullptr);
+			if (menu_flag1 == MENU_DISPLAY) {
+				_G(fx)->blende1(_G(workptr), nullptr, 0, 300);
+			} else if (menu_flag1 == MENU_HIDE)
+				_G(fx)->blende1(_G(workptr), nullptr, 1, 300);
+			menu_flag1 = false;
+			_G(out)->copyToScreen();
+		} else {
+			showCur();
+		}
+	}
+
+	_G(cur)->move(_G(maus_old_x), _G(maus_old_y));
+	g_events->_mousePos.x = _G(maus_old_x);
+	g_events->_mousePos.y = _G(maus_old_y);
+	_G(minfo).button = 0;
+
+	while (g_events->getSwitchCode() == Common::KEYCODE_ESCAPE && !SHOULD_QUIT) {
+		setupScreen(NO_SETUP);
+		_G(cur)->updateCursor();
+		_G(out)->copyToScreen();
+	}
+
+	_G(flags).InventMenu = false;
+	_G(flags).AutoAniPlay = oldAutoAniPlay;
+	_G(gameState).DispFlag = oldDispFlag;
+	_G(menu_display) = _G(tmp_menu);
+	_G(flags).StopAutoObj = false;
+}
+
+int16 Inventory::look(int16 invent_nr, int16 mode, int16 ats_nr) {
+	int16 lineCount = 0;
+	int16 xoff = 0;
+	int16 yoff = 0;
+	int16 visibleCount = 0;
+	Common::String itemName;
+	Common::StringArray itemDesc;
+	char c[2] = { 0 };
+	int16 ret = -1;
+	bool endLoop = false;
+	int16 startLine = 0;
+	bool mouseFl = true;
+	bool firstTime = true;
+
+	if (mode == INV_ATS_MODE) {
+		itemName = _G(atds)->getTextEntry(invent_nr, TXT_MARK_NAME, INV_ATS_DATA);
+		itemDesc = _G(atds)->getTextArray(invent_nr, TXT_MARK_LOOK, INV_ATS_DATA);
+		lineCount = itemDesc.size();
+		xoff = itemName.size();
+		xoff *= _G(font8)->getDataWidth();
+		xoff = (254 - xoff) / 2;
+		visibleCount = 2;
+		yoff = 10;
+	} else if (mode == INV_USE_ATS_MODE) {
+		visibleCount = 3;
+		yoff = 0;
+
+		if (ats_nr >= 15000)
+			itemDesc = _G(atds)->getTextArray(0, ats_nr - 15000, INV_USE_DEF, -1);
+		else
+			itemDesc = _G(atds)->getTextArray(0, ats_nr, INV_USE_DATA, -1);
+
+		lineCount = itemDesc.size();
+		if (itemDesc.size() == 0)
+			endLoop = true;
+	} else {
+		endLoop = true;
+	}
+
+	const int16 speechId = _G(atds)->getLastSpeechId();
+
+	while (!endLoop) {
+		int16 rect = _G(out)->findHotspot(_G(inventoryHotspots));
+
+		if (_G(minfo).button) {
+			if (_G(minfo).button == 2) {
+				if (!mouseFl)
+					g_events->_kbInfo._scanCode = Common::KEYCODE_ESCAPE;
+			} else if (_G(minfo).button == 1) {
+				if (!mouseFl) {
+					switch (rect) {
+					case 0:
+						endLoop = true;
+						ret = 0;
+						break;
+
+					case 1:
+						endLoop = true;
+						ret = 1;
+						break;
+
+					case 3:
+					case 6:
+						g_events->_kbInfo._scanCode = Common::KEYCODE_UP;
+						break;
+
+					case 4:
+					case 7:
+						g_events->_kbInfo._scanCode = Common::KEYCODE_DOWN;
+						break;
+
+					case 5:
+						ret = 5;
+						endLoop = true;
+						break;
+
+					default:
+						break;
+					}
+				}
+			}
+
+			mouseFl = true;
+		} else {
+			mouseFl = false;
+		}
+
+		switch (g_events->_kbInfo._scanCode) {
+		case Common::KEYCODE_F1:
+			g_events->setHotKey(Common::KEYCODE_F1);
+			break;
+
+		case Common::KEYCODE_F2:
+			g_events->setHotKey(Common::KEYCODE_F2);
+			break;
+
+		case Common::KEYCODE_ESCAPE:
+			endLoop = true;
+			break;
+
+		case Common::KEYCODE_UP:
+			if (startLine > 0)
+				--startLine;
+			break;
+
+		case Common::KEYCODE_DOWN:
+			if (startLine < lineCount - visibleCount)
+				++startLine;
+			break;
+
+		default:
+			break;
+		}
+
+		g_events->_kbInfo._scanCode = Common::KEYCODE_INVALID;
+		setupScreen(NO_SETUP);
+		plot_menu();
+
+		if (mode == INV_ATS_MODE) {
+			_G(fontMgr)->setFont(_G(font8));
+			_G(out)->printxy(WIN_LOOK_X + xoff, WIN_LOOK_Y, 255, 300,
+							 _G(scr_width), itemName.c_str());
+		}
+
+		_G(fontMgr)->setFont(_G(font6));
+
+		if (lineCount > visibleCount) {
+			if (startLine > 0) {
+				if (rect == 6)
+					_G(out)->boxFill(WIN_INF_X + 262, WIN_INF_Y + 136, WIN_INF_X + 272,
+						WIN_INF_Y + 136 + 14, 41);
+				c[0] = 24;
+				_G(out)->printxy(WIN_LOOK_X + 250, WIN_LOOK_Y + 4, 14, 300,
+					_G(scr_width), c);
+			}
+
+			if (startLine < lineCount - visibleCount) {
+				if (rect == 7)
+					_G(out)->boxFill(WIN_INF_X + 262, WIN_INF_Y + 156, WIN_INF_X + 272,
+						WIN_INF_Y + 156 + 14, 41);
+				c[0] = 25;
+				_G(out)->printxy(WIN_LOOK_X + 250, WIN_LOOK_Y + 24, 14, 300, _G(scr_width), c);
+			}
+		}
+
+		int16 k = 0;
+
+		if (itemDesc.size() > 0) {
+			for (int16 i = startLine; i < lineCount && i < startLine + visibleCount; i++) {
+				_G(out)->printxy(WIN_LOOK_X, WIN_LOOK_Y + yoff + k * 10, 14, 300,
+								 _G(scr_width), itemDesc[i].c_str());
+				++k;
+			}
+
+			if (g_engine->_sound->speechEnabled() && speechId >= 0 && firstTime) {
+				g_engine->_sound->playSpeech(speechId, false);
+				firstTime = false;
+			}
+		}
+
+		_G(cur)->updateCursor();
+		_G(out)->copyToScreen();
+		SHOULD_QUIT_RETURN0;
+	}
+
+	while (g_events->getSwitchCode() == Common::KEYCODE_ESCAPE) {
+		setupScreen(NO_SETUP);
+		plot_menu();
+		_G(cur)->updateCursor();
+		_G(out)->copyToScreen();
+		SHOULD_QUIT_RETURN0;
+	}
+
+	return ret;
+}
+
+void Inventory::look_screen(int16 txt_mode, int16 txt_nr) {
+	int16 ok;
+	int16 m_mode = 0;
+
+	if (!_G(flags).AtsAction) {
+		if (txt_nr != -1) {
+			switch (txt_mode) {
+			case INVENTORY_NORMAL:
+			case INVENTORY_STATIC:
+				ok = true;
+				switch (_G(menu_item)) {
+				case CUR_LOOK:
+					m_mode = TXT_MARK_LOOK;
+					break;
+
+				case CUR_USE:
+				case CUR_USER:
+				case CUR_HOWARD:
+				case CUR_NICHELLE:
+					m_mode = TXT_MARK_USE;
+					if (_G(cur)->usingInventoryCursor())
+						ok = false;
+					break;
+
+				case CUR_WALK:
+					m_mode = TXT_MARK_WALK;
+					break;
+
+				case CUR_TALK:
+					m_mode = TXT_MARK_TALK;
+					break;
+
+				default:
+					break;
+				}
+
+				if (_G(atds)->getControlBit(txt_nr, ATS_ACTION_BIT)) {
+					atsAction(txt_nr, m_mode, ATS_ACTION_VOR);
+				}
+				if (ok) {
+					startAtsWait(txt_nr, m_mode, 14, ATS_DATA);
+				}
+
+				if (_G(atds)->getControlBit(txt_nr, ATS_ACTION_BIT))
+					atsAction(txt_nr, m_mode, ATS_ACTION_NACH);
+				if (_G(menu_item) == CUR_USE)
+					_G(flags).StaticUseTxt = true;
+				break;
+
+			default:
+				break;
+			}
+		}
+	}
+}
+
+bool Inventory::calc_use_invent(int16 invNr) {
+	bool retVal = false;
+
+	if (_G(menu_item) == CUR_LOOK) {
+		switch (invNr) {
+		case ZEITUNG_INV:
+			Rooms::Room44::look_news();
+			break;
+
+		case CUTMAG_INV:
+			_G(show_invent_menu) = 2;
+			retVal = true;
+			Rooms::Room58::look_cut_mag(58);
+			break;
+
+		case SPARK_INV:
+			_G(show_invent_menu) = 2;
+			retVal = true;
+			save_person_rnr();
+			Rooms::Room58::look_cut_mag(60);
+			break;
+
+		case DIARY_INV:
+			showDiary();
+			retVal = true;
+			break;
+
+		default:
+			break;
+		}
+	} else if (_G(menu_item) == CUR_USE && invNr == NOTEBOOK_INV) {
+		int16 id = del_invent_slot(NOTEBOOK_INV);
+		_G(gameState).InventSlot[id] = NOTEBOOK_OPEN_INV;
+		_G(obj)->changeInventory(NOTEBOOK_INV, NOTEBOOK_OPEN_INV, &_G(room_blk));
+		retVal = true;
+	}
+
+	return retVal;
+}
+
+// Shows the Hermit's diary
+void Inventory::showDiary() {
+	int16 scrollx = _G(gameState).scrollx,
+		scrolly = _G(gameState).scrolly;
+	_G(gameState).scrollx = 0;
+	_G(gameState).scrolly = 0;
+
+	_G(cur)->hideCursor();
+	_G(room)->load_tgp(DIARY_START, &_G(room_blk), GBOOK_TGP, false, GBOOK);
+	_G(out)->setPointer(_G(workptr));
+	_G(out)->map_spr2screen(_G(ablage)[_G(room_blk).AkAblage], _G(gameState).scrollx, _G(gameState).scrolly);
+	_G(out)->copyToScreen();
+	_G(room)->set_ak_pal(&_G(room_blk));
+	_G(out)->setPointer(nullptr);
+	_G(fx)->blende1(_G(workptr), _G(pal), 0, 0);
+
+	while (g_events->getSwitchCode() != Common::KEYCODE_ESCAPE) {
+		g_events->update();
+		SHOULD_QUIT_RETURN;
+	}
+
+	_G(room)->load_tgp(_G(gameState)._personRoomNr[P_CHEWY], &_G(room_blk), EPISODE1_TGP, true, EPISODE1);
+	_G(gameState).scrollx = scrollx;
+	_G(gameState).scrolly = scrolly;
+	setupScreen(NO_SETUP);
+	plot_menu();
+	_G(out)->setPointer(nullptr);
+	_G(room)->set_ak_pal(&_G(room_blk));
+	_G(fx)->blende1(_G(workptr), _G(pal), 0, 0);
+	_G(cur)->showCursor();
+}
+
+} // namespace Dialogs
+} // namespace Chewy