/* 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/>.
 *
 */

/*
 * Based on the Reverse Engineering work of Christophe Fontanel,
 * maintainer of the Dungeon Master Encyclopaedia (http://dmweb.free.fr/)
 */

#include "common/file.h"
#include "common/memstream.h"

#include "dm/dungeonman.h"
#include "dm/timeline.h"
#include "dm/champion.h"
#include "dm/group.h"
#include "dm/movesens.h"
#include "dm/projexpl.h"

namespace DM {

void DungeonMan::mapCoordsAfterRelMovement(Direction dir, int16 stepsForward, int16 stepsRight, int16 &posX, int16 &posY) {
	posX += _vm->_dirIntoStepCountEast[dir] * stepsForward;
	posY += _vm->_dirIntoStepCountNorth[dir] * stepsForward;
	dir = _vm->turnDirRight(dir);
	posX += _vm->_dirIntoStepCountEast[dir] * stepsRight;
	posY += _vm->_dirIntoStepCountNorth[dir] * stepsRight;
}

void DungeonMan::setupConstants() {
	ObjectInfoIndex objectInfo[180] = { // @ G0237_as_Graphic559_ObjectInfo
		/* { Type, ObjectAspectIndex, ActionSetIndex, AllowedSlots } */
		ObjectInfoIndex(30,  1,  0, 0x0500),   /* COMPASS        Pouch/Chest */
		ObjectInfoIndex(144,  0,  0, 0x0200),  /* COMPASS        Hands */
		ObjectInfoIndex(148, 67,  0, 0x0500),  /* COMPASS        Pouch/Chest */
		ObjectInfoIndex(149, 67,  0, 0x0500),  /* COMPASS        Pouch/Chest */
		ObjectInfoIndex(150, 67,  0, 0x0500),  /* TORCH          Pouch/Chest */
		ObjectInfoIndex(151, 67, 42, 0x0500),  /* TORCH          Pouch/Chest */
		ObjectInfoIndex(152, 67,  0, 0x0500),  /* TORCH          Pouch/Chest */
		ObjectInfoIndex(153, 67,  0, 0x0500),  /* TORCH          Pouch/Chest */
		ObjectInfoIndex(154,  2,  0, 0x0501),  /* WATERSKIN      Mouth/Pouch/Chest */
		ObjectInfoIndex(155,  2,  0, 0x0501),  /* WATER          Mouth/Pouch/Chest */
		ObjectInfoIndex(156,  2,  0, 0x0501),  /* JEWEL SYMAL    Mouth/Pouch/Chest */
		ObjectInfoIndex(157,  2,  0, 0x0501),  /* JEWEL SYMAL    Mouth/Pouch/Chest */
		ObjectInfoIndex(158,  2,  0, 0x0501),  /* ILLUMULET      Mouth/Pouch/Chest */
		ObjectInfoIndex(159,  2,  0, 0x0501),  /* ILLUMULET      Mouth/Pouch/Chest */
		ObjectInfoIndex(160,  2,  0, 0x0501),  /* FLAMITT        Mouth/Pouch/Chest */
		ObjectInfoIndex(161,  2,  0, 0x0501),  /* FLAMITT        Mouth/Pouch/Chest */
		ObjectInfoIndex(162,  2,  0, 0x0501),  /* EYE OF TIME    Mouth/Pouch/Chest */
		ObjectInfoIndex(163,  2,  0, 0x0501),  /* EYE OF TIME    Mouth/Pouch/Chest */
		ObjectInfoIndex(164, 68,  0, 0x0500),  /* STORMRING      Pouch/Chest */
		ObjectInfoIndex(165, 68,  0, 0x0500),  /* STORMRING      Pouch/Chest */
		ObjectInfoIndex(166, 68,  0, 0x0500),  /* STAFF OF CLAWS Pouch/Chest */
		ObjectInfoIndex(167, 68, 42, 0x0500),  /* STAFF OF CLAWS Pouch/Chest */
		ObjectInfoIndex(195, 80,  0, 0x0500),  /* STAFF OF CLAWS Pouch/Chest */
		ObjectInfoIndex(16, 38, 43, 0x0500),   /* BOLT BLADE     Pouch/Chest */
		ObjectInfoIndex(18, 38,  7, 0x0500),   /* BOLT BLADE     Pouch/Chest */
		ObjectInfoIndex(4, 35,  5, 0x0400),    /* FURY           Chest */
		ObjectInfoIndex(14, 37,  6, 0x0400),   /* FURY           Chest */
		ObjectInfoIndex(20, 11,  8, 0x0040),   /* THE FIRESTAFF  Quiver 1 */
		ObjectInfoIndex(23, 12,  9, 0x0040),   /* THE FIRESTAFF  Quiver 1 */
		ObjectInfoIndex(25, 12, 10, 0x0040),   /* THE FIRESTAFF  Quiver 1 */
		ObjectInfoIndex(27, 39, 11, 0x0040),   /* OPEN SCROLL    Quiver 1 */
		ObjectInfoIndex(32, 17, 12, 0x05C0),   /* SCROLL         Quiver 1/Quiver 2/Pouch/Chest */
		ObjectInfoIndex(33, 12, 13, 0x0040),   /* DAGGER         Quiver 1 */
		ObjectInfoIndex(34, 12, 13, 0x0040),   /* FALCHION       Quiver 1 */
		ObjectInfoIndex(35, 12, 14, 0x0040),   /* SWORD          Quiver 1 */
		ObjectInfoIndex(36, 12, 15, 0x0040),   /* RAPIER         Quiver 1 */
		ObjectInfoIndex(37, 12, 15, 0x0040),   /* SABRE          Quiver 1 */
		ObjectInfoIndex(38, 12, 16, 0x0040),   /* SAMURAI SWORD  Quiver 1 */
		ObjectInfoIndex(39, 12, 17, 0x0040),   /* DELTA          Quiver 1 */
		ObjectInfoIndex(40, 42, 18, 0x0040),   /* DIAMOND EDGE   Quiver 1 */
		ObjectInfoIndex(41, 12, 19, 0x0040),   /* VORPAL BLADE   Quiver 1 */
		ObjectInfoIndex(42, 13, 20, 0x0040),   /* THE INQUISITOR Quiver 1 */
		ObjectInfoIndex(43, 13, 21, 0x0040),   /* AXE            Quiver 1 */
		ObjectInfoIndex(44, 21, 22, 0x0040),   /* HARDCLEAVE     Quiver 1 */
		ObjectInfoIndex(45, 21, 22, 0x0040),   /* MACE           Quiver 1 */
		ObjectInfoIndex(46, 33, 23, 0x0440),   /* MACE OF ORDER  Quiver 1/Chest */
		ObjectInfoIndex(47, 43, 24, 0x0040),   /* MORNINGSTAR    Quiver 1 */
		ObjectInfoIndex(48, 44, 24, 0x0040),   /* CLUB           Quiver 1 */
		ObjectInfoIndex(49, 14, 27, 0x0040),   /* STONE CLUB     Quiver 1 */
		ObjectInfoIndex(50, 45, 27, 0x0040),   /* BOW            Quiver 1 */
		ObjectInfoIndex(51, 16, 26, 0x05C0),   /* CROSSBOW       Quiver 1/Quiver 2/Pouch/Chest */
		ObjectInfoIndex(52, 46, 26, 0x05C0),   /* ARROW          Quiver 1/Quiver 2/Pouch/Chest */
		ObjectInfoIndex(53, 11, 27, 0x0440),   /* SLAYER         Quiver 1/Chest */
		ObjectInfoIndex(54, 47, 42, 0x05C0),   /* SLING          Quiver 1/Quiver 2/Pouch/Chest */
		ObjectInfoIndex(55, 48, 40, 0x05C0),   /* ROCK           Quiver 1/Quiver 2/Pouch/Chest */
		ObjectInfoIndex(56, 49, 42, 0x05C0),   /* POISON DART    Quiver 1/Quiver 2/Pouch/Chest */
		ObjectInfoIndex(57, 50,  5, 0x0040),   /* THROWING STAR  Quiver 1 */
		ObjectInfoIndex(58, 11,  5, 0x0040),   /* STICK          Quiver 1 */
		ObjectInfoIndex(59, 31, 28, 0x0540),   /* STAFF          Quiver 1/Pouch/Chest */
		ObjectInfoIndex(60, 31, 29, 0x0540),   /* WAND           Quiver 1/Pouch/Chest */
		ObjectInfoIndex(61, 11, 30, 0x0040),   /* TEOWAND        Quiver 1 */
		ObjectInfoIndex(62, 11, 31, 0x0040),   /* YEW STAFF      Quiver 1 */
		ObjectInfoIndex(63, 11, 32, 0x0040),   /* STAFF OF MANAR Quiver 1 Atari ST Version 1.0 1987-12-08: ObjectAspectIndex = 35 */
		ObjectInfoIndex(64, 51, 33, 0x0040),   /* SNAKE STAFF    Quiver 1 */
		ObjectInfoIndex(65, 32,  5, 0x0440),   /* THE CONDUIT    Quiver 1/Chest */
		ObjectInfoIndex(66, 30, 35, 0x0040),   /* DRAGON SPIT    Quiver 1 */
		ObjectInfoIndex(135, 65, 36, 0x0440),  /* SCEPTRE OF LYF Quiver 1/Chest */
		ObjectInfoIndex(143, 45, 27, 0x0040),  /* ROBE           Quiver 1 */
		ObjectInfoIndex(28, 82,  1, 0x0040),   /* FINE ROBE      Quiver 1 */
		ObjectInfoIndex(80, 23,  0, 0x040C),   /* KIRTLE         Neck/Torso/Chest */
		ObjectInfoIndex(81, 23,  0, 0x040C),   /* SILK SHIRT     Neck/Torso/Chest */
		ObjectInfoIndex(82, 23,  0, 0x0410),   /* ELVEN DOUBLET  Legs/Chest */
		ObjectInfoIndex(112, 55,  0, 0x0420),  /* LEATHER JERKIN Feet/Chest */
		ObjectInfoIndex(114,  8,  0, 0x0420),  /* TUNIC          Feet/Chest */
		ObjectInfoIndex(67, 24,  0, 0x0408),   /* GHI            Torso/Chest */
		ObjectInfoIndex(83, 24,  0, 0x0410),   /* MAIL AKETON    Legs/Chest */
		ObjectInfoIndex(68, 24,  0, 0x0408),   /* MITHRAL AKETON Torso/Chest */
		ObjectInfoIndex(84, 24,  0, 0x0410),   /* TORSO PLATE    Legs/Chest */
		ObjectInfoIndex(69, 69,  0, 0x0408),   /* PLATE OF LYTE  Torso/Chest */
		ObjectInfoIndex(70, 24,  0, 0x0408),   /* PLATE OF DARC  Torso/Chest */
		ObjectInfoIndex(85, 24,  0, 0x0410),   /* CAPE           Legs/Chest */
		ObjectInfoIndex(86, 69,  0, 0x0410),   /* CLOAK OF NIGHT Legs/Chest */
		ObjectInfoIndex(71,  7,  0, 0x0408),   /* BARBARIAN HIDE Torso/Chest */
		ObjectInfoIndex(87,  7,  0, 0x0410),   /* ROBE           Legs/Chest */
		ObjectInfoIndex(119, 57,  0, 0x0420),  /* FINE ROBE      Feet/Chest */
		ObjectInfoIndex(72, 23,  0, 0x0408),   /* TABARD         Torso/Chest */
		ObjectInfoIndex(88, 23,  0, 0x0410),   /* GUNNA          Legs/Chest */
		ObjectInfoIndex(113, 29,  0, 0x0420),  /* ELVEN HUKE     Feet/Chest */
		ObjectInfoIndex(89, 69,  0, 0x0410),   /* LEATHER PANTS  Legs/Chest */
		ObjectInfoIndex(73, 69,  0, 0x0408),   /* BLUE PANTS     Torso/Chest */
		ObjectInfoIndex(74, 24,  0, 0x0408),   /* GHI TROUSERS   Torso/Chest */
		ObjectInfoIndex(90, 24,  0, 0x0410),   /* LEG MAIL       Legs/Chest */
		ObjectInfoIndex(103, 53,  0, 0x0402),  /* MITHRAL MAIL   Head/Chest */
		ObjectInfoIndex(104, 53,  0, 0x0402),  /* LEG PLATE      Head/Chest */
		ObjectInfoIndex(96,  9,  0, 0x0402),   /* POLEYN OF LYTE Head/Chest */
		ObjectInfoIndex(97,  9,  0, 0x0402),   /* POLEYN OF DARC Head/Chest */
		ObjectInfoIndex(98,  9,  0, 0x0402),   /* BEZERKER HELM  Head/Chest */
		ObjectInfoIndex(105, 54, 41, 0x0400),  /* HELMET         Chest */
		ObjectInfoIndex(106, 54, 41, 0x0200),  /* BASINET        Hands */
		ObjectInfoIndex(108, 10, 41, 0x0200),  /* CASQUE 'N COIF Hands */
		ObjectInfoIndex(107, 54, 41, 0x0200),  /* ARMET          Hands */
		ObjectInfoIndex(75, 19,  0, 0x0408),   /* HELM OF LYTE   Torso/Chest */
		ObjectInfoIndex(91, 19,  0, 0x0410),   /* HELM OF DARC   Legs/Chest */
		ObjectInfoIndex(76, 19,  0, 0x0408),   /* CALISTA        Torso/Chest */
		ObjectInfoIndex(92, 19,  0, 0x0410),   /* CROWN OF NERRA Legs/Chest */
		ObjectInfoIndex(99,  9,  0, 0x0402),   /* BUCKLER        Head/Chest */
		ObjectInfoIndex(115, 19,  0, 0x0420),  /* HIDE SHIELD    Feet/Chest */
		ObjectInfoIndex(100, 52,  0, 0x0402),  /* SMALL SHIELD   Head/Chest */
		ObjectInfoIndex(77, 20,  0, 0x0008),   /* WOODEN SHIELD  Torso */
		ObjectInfoIndex(93, 22,  0, 0x0010),   /* LARGE SHIELD   Legs */
		ObjectInfoIndex(116, 56,  0, 0x0420),  /* SHIELD OF LYTE Feet/Chest */
		ObjectInfoIndex(109, 10, 41, 0x0200),  /* SHIELD OF DARC Hands */
		ObjectInfoIndex(101, 52,  0, 0x0402),  /* SANDALS        Head/Chest */
		ObjectInfoIndex(78, 20,  0, 0x0008),   /* SUEDE BOOTS    Torso */
		ObjectInfoIndex(94, 22,  0, 0x0010),   /* LEATHER BOOTS  Legs */
		ObjectInfoIndex(117, 56,  0, 0x0420),  /* HOSEN          Feet/Chest */
		ObjectInfoIndex(110, 10, 41, 0x0200),  /* FOOT PLATE     Hands */
		ObjectInfoIndex(102, 52,  0, 0x0402),  /* GREAVE OF LYTE Head/Chest */
		ObjectInfoIndex(79, 20,  0, 0x0008),   /* GREAVE OF DARC Torso */
		ObjectInfoIndex(95, 22,  0, 0x0010),   /* ELVEN BOOTS    Legs */
		ObjectInfoIndex(118, 56,  0, 0x0420),  /* GEM OF AGES    Feet/Chest */
		ObjectInfoIndex(111, 10, 41, 0x0200),  /* EKKHARD CROSS  Hands */
		ObjectInfoIndex(140, 52,  0, 0x0402),  /* MOONSTONE      Head/Chest */
		ObjectInfoIndex(141, 19,  0, 0x0408),  /* THE HELLION    Torso/Chest */
		ObjectInfoIndex(142, 22,  0, 0x0010),  /* PENDANT FERAL  Legs */
		ObjectInfoIndex(194, 81,  0, 0x0420),  /* COPPER COIN    Feet/Chest */
		ObjectInfoIndex(196, 84,  0, 0x0408),  /* SILVER COIN    Torso/Chest */
		ObjectInfoIndex(0, 34,  0, 0x0500),    /* GOLD COIN      Pouch/Chest */
		ObjectInfoIndex(8,  6,  0, 0x0501),    /* BOULDER        Mouth/Pouch/Chest */
		ObjectInfoIndex(10, 15,  0, 0x0504),   /* BLUE GEM       Neck/Pouch/Chest */
		ObjectInfoIndex(12, 15,  0, 0x0504),   /* ORANGE GEM     Neck/Pouch/Chest */
		ObjectInfoIndex(146, 40,  0, 0x0500),  /* GREEN GEM      Pouch/Chest */
		ObjectInfoIndex(147, 41,  0, 0x0400),  /* MAGICAL BOX    Chest */
		ObjectInfoIndex(125,  4, 37, 0x0500),  /* MAGICAL BOX    Pouch/Chest */
		ObjectInfoIndex(126, 83, 37, 0x0500),  /* MIRROR OF DAWN Pouch/Chest */
		ObjectInfoIndex(127,  4, 37, 0x0500),  /* HORN OF FEAR   Pouch/Chest */
		ObjectInfoIndex(176, 18,  0, 0x0500),  /* ROPE           Pouch/Chest */
		ObjectInfoIndex(177, 18,  0, 0x0500),  /* RABBIT'S FOOT  Pouch/Chest */
		ObjectInfoIndex(178, 18,  0, 0x0500),  /* CORBAMITE      Pouch/Chest */
		ObjectInfoIndex(179, 18,  0, 0x0500),  /* CHOKER         Pouch/Chest */
		ObjectInfoIndex(180, 18,  0, 0x0500),  /* DEXHELM        Pouch/Chest */
		ObjectInfoIndex(181, 18,  0, 0x0500),  /* FLAMEBAIN      Pouch/Chest */
		ObjectInfoIndex(182, 18,  0, 0x0500),  /* POWERTOWERS    Pouch/Chest */
		ObjectInfoIndex(183, 18,  0, 0x0500),  /* SPEEDBOW       Pouch/Chest */
		ObjectInfoIndex(184, 62,  0, 0x0500),  /* CHEST          Pouch/Chest */
		ObjectInfoIndex(185, 62,  0, 0x0500),  /* OPEN CHEST     Pouch/Chest */
		ObjectInfoIndex(186, 62,  0, 0x0500),  /* ASHES          Pouch/Chest */
		ObjectInfoIndex(187, 62,  0, 0x0500),  /* BONES          Pouch/Chest */
		ObjectInfoIndex(188, 62,  0, 0x0500),  /* MON POTION     Pouch/Chest */
		ObjectInfoIndex(189, 62,  0, 0x0500),  /* UM POTION      Pouch/Chest */
		ObjectInfoIndex(190, 62,  0, 0x0500),  /* DES POTION     Pouch/Chest */
		ObjectInfoIndex(191, 62,  0, 0x0500),  /* VEN POTION     Pouch/Chest */
		ObjectInfoIndex(128, 76,  0, 0x0200),  /* SAR POTION     Hands */
		ObjectInfoIndex(129,  3,  0, 0x0500),  /* ZO POTION      Pouch/Chest */
		ObjectInfoIndex(130, 60,  0, 0x0500),  /* ROS POTION     Pouch/Chest */
		ObjectInfoIndex(131, 61,  0, 0x0500),  /* KU POTION      Pouch/Chest */
		ObjectInfoIndex(168, 27,  0, 0x0501),  /* DANE POTION    Mouth/Pouch/Chest */
		ObjectInfoIndex(169, 28,  0, 0x0501),  /* NETA POTION    Mouth/Pouch/Chest */
		ObjectInfoIndex(170, 25,  0, 0x0501),  /* BRO POTION     Mouth/Pouch/Chest */
		ObjectInfoIndex(171, 26,  0, 0x0501),  /* MA POTION      Mouth/Pouch/Chest */
		ObjectInfoIndex(172, 71,  0, 0x0401),  /* YA POTION      Mouth/Chest */
		ObjectInfoIndex(173, 70,  0, 0x0401),  /* EE POTION      Mouth/Chest */
		ObjectInfoIndex(174,  5,  0, 0x0501),  /* VI POTION      Mouth/Pouch/Chest */
		ObjectInfoIndex(175, 66,  0, 0x0501),  /* WATER FLASK    Mouth/Pouch/Chest */
		ObjectInfoIndex(120, 15,  0, 0x0504),  /* KATH BOMB      Neck/Pouch/Chest */
		ObjectInfoIndex(121, 15,  0, 0x0504),  /* PEW BOMB       Neck/Pouch/Chest */
		ObjectInfoIndex(122, 58,  0, 0x0504),  /* RA BOMB        Neck/Pouch/Chest */
		ObjectInfoIndex(123, 59,  0, 0x0504),  /* FUL BOMB       Neck/Pouch/Chest */
		ObjectInfoIndex(124, 59,  0, 0x0504),  /* APPLE          Neck/Pouch/Chest */
		ObjectInfoIndex(132, 79, 38, 0x0500),  /* CORN           Pouch/Chest */
		ObjectInfoIndex(133, 63, 38, 0x0500),  /* BREAD          Pouch/Chest */
		ObjectInfoIndex(134, 64,  0, 0x0500),  /* CHEESE         Pouch/Chest */
		ObjectInfoIndex(136, 72, 39, 0x0400),  /* SCREAMER SLICE Chest */
		ObjectInfoIndex(137, 73,  0, 0x0500),  /* WORM ROUND     Pouch/Chest */
		ObjectInfoIndex(138, 74,  0, 0x0500),  /* DRUMSTICK      Pouch/Chest */
		ObjectInfoIndex(139, 75,  0, 0x0504),  /* DRAGON STEAK   Neck/Pouch/Chest */
		ObjectInfoIndex(192, 77,  0, 0x0500),  /* IRON KEY       Pouch/Chest */
		ObjectInfoIndex(193, 78,  0, 0x0500),  /* KEY OF B       Pouch/Chest */
		ObjectInfoIndex(197, 74,  0, 0x0000),  /* SOLID KEY */
		ObjectInfoIndex(198, 41,  0, 0x0400)   /* SQUARE KEY     Chest */
	};
	ArmourInfo armourInfo[58] = { // G0239_as_Graphic559_ArmourInfo
		/* { Weight, Defense, Attributes, Unreferenced } */
		ArmourInfo(3,   5, 0x01),   /* CAPE */
		ArmourInfo(4,  10, 0x01),   /* CLOAK OF NIGHT */
		ArmourInfo(3,   4, 0x01),   /* BARBARIAN HIDE */
		ArmourInfo(6,   5, 0x02),   /* SANDALS */
		ArmourInfo(16,  25, 0x04),  /* LEATHER BOOTS */
		ArmourInfo(4,   5, 0x00),   /* ROBE */
		ArmourInfo(4,   5, 0x00),   /* ROBE */
		ArmourInfo(3,   7, 0x01),   /* FINE ROBE */
		ArmourInfo(3,   7, 0x01),   /* FINE ROBE */
		ArmourInfo(4,   6, 0x01),   /* KIRTLE */
		ArmourInfo(2,   4, 0x00),   /* SILK SHIRT */
		ArmourInfo(4,   5, 0x01),   /* TABARD */
		ArmourInfo(5,   7, 0x01),   /* GUNNA */
		ArmourInfo(3,  11, 0x02),   /* ELVEN DOUBLET */
		ArmourInfo(3,  13, 0x02),   /* ELVEN HUKE */
		ArmourInfo(4,  13, 0x02),   /* ELVEN BOOTS */
		ArmourInfo(6,  17, 0x03),   /* LEATHER JERKIN */
		ArmourInfo(8,  20, 0x03),   /* LEATHER PANTS */
		ArmourInfo(14,  20, 0x03),  /* SUEDE BOOTS */
		ArmourInfo(6,  12, 0x02),   /* BLUE PANTS */
		ArmourInfo(5,   9, 0x01),   /* TUNIC */
		ArmourInfo(5,   8, 0x01),   /* GHI */
		ArmourInfo(5,   9, 0x01),   /* GHI TROUSERS */
		ArmourInfo(4,   1, 0x04),   /* CALISTA */
		ArmourInfo(6,   5, 0x04),   /* CROWN OF NERRA */
		ArmourInfo(11,  12, 0x05),  /* BEZERKER HELM */
		ArmourInfo(14,  17, 0x05),  /* HELMET */
		ArmourInfo(15,  20, 0x05),  /* BASINET */
		ArmourInfo(11,  22, 0x85),  /* BUCKLER */
		ArmourInfo(10,  16, 0x82),  /* HIDE SHIELD */
		ArmourInfo(14,  20, 0x83),  /* WOODEN SHIELD */
		ArmourInfo(21,  35, 0x84),  /* SMALL SHIELD */
		ArmourInfo(65,  35, 0x05),  /* MAIL AKETON */
		ArmourInfo(53,  35, 0x05),  /* LEG MAIL */
		ArmourInfo(52,  70, 0x07),  /* MITHRAL AKETON */
		ArmourInfo(41,  55, 0x07),  /* MITHRAL MAIL */
		ArmourInfo(16,  25, 0x06),  /* CASQUE 'N COIF */
		ArmourInfo(16,  30, 0x06),  /* HOSEN */
		ArmourInfo(19,  40, 0x07),  /* ARMET */
		ArmourInfo(120,  65, 0x04), /* TORSO PLATE */
		ArmourInfo(80,  56, 0x04),  /* LEG PLATE */
		ArmourInfo(28,  37, 0x05),  /* FOOT PLATE */
		ArmourInfo(34,  56, 0x84),  /* LARGE SHIELD */
		ArmourInfo(17,  62, 0x05),  /* HELM OF LYTE */
		ArmourInfo(108, 125, 0x04), /* PLATE OF LYTE */
		ArmourInfo(72,  90, 0x04),  /* POLEYN OF LYTE */
		ArmourInfo(24,  50, 0x05),  /* GREAVE OF LYTE */
		ArmourInfo(30,  85, 0x84),  /* SHIELD OF LYTE */
		ArmourInfo(35,  76, 0x04),  /* HELM OF DARC */
		ArmourInfo(141, 160, 0x04), /* PLATE OF DARC */
		ArmourInfo(90, 101, 0x04),  /* POLEYN OF DARC */
		ArmourInfo(31,  60, 0x05),  /* GREAVE OF DARC */
		ArmourInfo(40, 100, 0x84),  /* SHIELD OF DARC */
		ArmourInfo(14,  54, 0x06),  /* DEXHELM */
		ArmourInfo(57,  60, 0x07),  /* FLAMEBAIN */
		ArmourInfo(81,  88, 0x04),  /* POWERTOWERS */
		ArmourInfo(3,  16, 0x02),   /* BOOTS OF SPEED */
		ArmourInfo(2,   3, 0x03)    /* HALTER */
	};

	WeaponInfo weaponInfo[46] = { // @ G0238_as_Graphic559_WeaponInfo
		/* { Weight, Class, Strength, KineticEnergy, Attributes } */
		WeaponInfo(1, 130,   2,   0, 0x2000),  /* EYE OF TIME */
		WeaponInfo(1, 131,   2,   0, 0x2000),  /* STORMRING */
		WeaponInfo(11, 0,   8,   2, 0x2000),   /* TORCH */
		WeaponInfo(12, 112,  10,  80, 0x2028), /* FLAMITT */
		WeaponInfo(9, 129,  16,   7, 0x2000),  /* STAFF OF CLAWS */
		WeaponInfo(30, 113,  49, 110, 0x0942), /* BOLT BLADE */
		WeaponInfo(47, 0,  55,  20, 0x0900),   /* FURY */
		WeaponInfo(24, 255,  25,  10, 0x20FF), /* THE FIRESTAFF */
		WeaponInfo(5, 2,  10,  19, 0x0200),    /* DAGGER */
		WeaponInfo(33, 0,  30,   8, 0x0900),   /* FALCHION */
		WeaponInfo(32, 0,  34,  10, 0x0900),   /* SWORD */
		WeaponInfo(26, 0,  38,  10, 0x0900),   /* RAPIER */
		WeaponInfo(35, 0,  42,  11, 0x0900),   /* SABRE */
		WeaponInfo(36, 0,  46,  12, 0x0900),   /* SAMURAI SWORD */
		WeaponInfo(33, 0,  50,  14, 0x0900),   /* DELTA */
		WeaponInfo(37, 0,  62,  14, 0x0900),   /* DIAMOND EDGE */
		WeaponInfo(30, 0,  48,  13, 0x0000),   /* VORPAL BLADE */
		WeaponInfo(39, 0,  58,  15, 0x0900),   /* THE INQUISITOR */
		WeaponInfo(43, 2,  49,  33, 0x0300),   /* AXE */
		WeaponInfo(65, 2,  70,  44, 0x0300),   /* HARDCLEAVE */
		WeaponInfo(31, 0,  32,  10, 0x2000),   /* MACE */
		WeaponInfo(41, 0,  42,  13, 0x2000),   /* MACE OF ORDER */
		WeaponInfo(50, 0,  60,  15, 0x2000),   /* MORNINGSTAR */
		WeaponInfo(36, 0,  19,  10, 0x2700),   /* CLUB */
		WeaponInfo(110, 0,  44,  22, 0x2600),  /* STONE CLUB */
		WeaponInfo(10, 20,   1,  50, 0x2032),  /* BOW */
		WeaponInfo(28, 30,   1, 180, 0x2078),  /* CROSSBOW */
		WeaponInfo(2, 10,   2,  10, 0x0100),   /* ARROW */
		WeaponInfo(2, 10,   2,  28, 0x0500),   /* SLAYER */
		WeaponInfo(19, 39,   5,  20, 0x2032),  /* SLING */
		WeaponInfo(10, 11,   6,  18, 0x2000),  /* ROCK */
		WeaponInfo(3, 12,   7,  23, 0x0800),   /* POISON DART */
		WeaponInfo(1, 1,   3,  19, 0x0A00),    /* THROWING STAR */
		WeaponInfo(8, 0,   4,   4, 0x2000),    /* STICK */
		WeaponInfo(26, 129,  12,   4, 0x2000), /* STAFF */
		WeaponInfo(1, 130,   0,   0, 0x2000),  /* WAND */
		WeaponInfo(2, 140,   1,  20, 0x2000),  /* TEOWAND */
		WeaponInfo(35, 128,  18,   6, 0x2000), /* YEW STAFF */
		WeaponInfo(29, 159,   0,   4, 0x2000), /* STAFF OF MANAR */
		WeaponInfo(21, 131,   0,   3, 0x2000), /* SNAKE STAFF */
		WeaponInfo(33, 136,   0,   7, 0x2000), /* THE CONDUIT */
		WeaponInfo(8, 132,   3,   1, 0x2000),  /* DRAGON SPIT */
		WeaponInfo(18, 131,   9,   4, 0x2000), /* SCEPTRE OF LYF */
		WeaponInfo(8, 192,   1,   1, 0x2000),  /* HORN OF FEAR */
		WeaponInfo(30, 26,   1, 220, 0x207D),  /* SPEEDBOW */
		WeaponInfo(36, 255, 100,  50, 0x20FF)  /* THE FIRESTAFF */
	};

	CreatureInfo creatureInfo[k27_CreatureTypeCount] = { // @ G0243_as_Graphic559_CreatureInfo
	/* { CreatureAspectIndex, AttackSoundOrdinal, Attributes, GraphicInfo,
		MovementTicks, AttackTicks, Defense, BaseHealth, Attack, PoisonAttack,
		Dexterity, Ranges, Properties, Resistances, AnimationTicks, WoundProbabilities, AttackType } */
		{0,  4, 0x0482, 0x623D,   8, 20,  55, 150, 150, 240,  55, 0x1153, 0x299B, 0x0876, 0x0254, 0xFD40, 4},
		{1,  0, 0x0480, 0xA625,  15, 32,  20, 110,  80,  15,  20, 0x3132, 0x33A9, 0x0E42, 0x0384, 0xFC41, 3},
		{2,  6, 0x0510, 0x6198,   3,  5,  50,  10,  10,   0, 110, 0x1376, 0x710A, 0x0235, 0x0222, 0xFD20, 0},
		{3,  0, 0x04B4, 0xB225,  10, 21,  30,  40,  58,   0,  80, 0x320A, 0x96AA, 0x0B3C, 0x0113, 0xF910, 5},
		{4,  1, 0x0701, 0xA3B8,   9,  8,  45, 101,  90,   0,  65, 0x1554, 0x58FF, 0x0A34, 0x0143, 0xFE93, 4},
		{5,  0, 0x0581, 0x539D,  20, 18, 100,  60,  30,   0,  30, 0x1232, 0x4338, 0x0583, 0x0265, 0xFFD6, 3},
		{6,  3, 0x070C, 0x0020, 120, 10,   5, 165,   5,   0,   5, 0x1111, 0x10F1, 0x0764, 0x02F2, 0xFC84, 6},
		{7,  7, 0x0300, 0x0220, 185, 15, 170,  50,  40,   5,  10, 0x1463, 0x25C4, 0x06E3, 0x01F4, 0xFD93, 4}, /* Atari ST: AttackSoundOrdinal = 0 */
		{8,  2, 0x1864, 0x5225,  11, 16,  15,  30,  55,   0,  80, 0x1423, 0x4664, 0x0FC8, 0x0116, 0xFB30, 6},
		{9, 10, 0x0282, 0x71B8,  21, 14, 240, 120, 219,   0,  35, 0x1023, 0x3BFF, 0x0FF7, 0x04F3, 0xF920, 3}, /* Atari ST: AttackSoundOrdinal = 7 */
		{10,  2, 0x1480, 0x11B8,  17, 12,  25,  33,  20,   0,  40, 0x1224, 0x5497, 0x0F15, 0x0483, 0xFB20, 3},
		{11,  0, 0x18C6, 0x0225, 255,  8,  45,  80, 105,   0,  60, 0x1314, 0x55A5, 0x0FF9, 0x0114, 0xFD95, 1},
		{12, 11, 0x1280, 0x6038,   7,  7,  22,  20,  22,   0,  80, 0x1013, 0x6596, 0x0F63, 0x0132, 0xFA30, 4}, /* Atari ST: AttackSoundOrdinal = 8 */
		{13,  9, 0x14A2, 0xB23D,   5, 10,  42,  39,  90, 100,  88, 0x1343, 0x5734, 0x0638, 0x0112, 0xFA30, 4}, /* Atari ST: AttackSoundOrdinal = 0 */
		{14,  0, 0x05B8, 0x1638,  10, 20,  47,  44,  75,   0,  90, 0x4335, 0xD952, 0x035B, 0x0664, 0xFD60, 5},
		{15,  5, 0x0381, 0x523D,  18, 19,  72,  70,  45,  35,  35, 0x1AA1, 0x15AB, 0x0B93, 0x0253, 0xFFC5, 4},
		{16, 10, 0x0680, 0xA038,  13,  8,  28,  20,  25,   0,  41, 0x1343, 0x2148, 0x0321, 0x0332, 0xFC30, 3}, /* Atari ST: AttackSoundOrdinal = 7 */
		{17,  0, 0x04A0, 0xF23D,   1, 16, 180,   8,  28,  20, 150, 0x1432, 0x19FD, 0x0004, 0x0112, 0xF710, 4},
		{18, 11, 0x0280, 0xA3BD,  14,  6, 140,  60, 105,   0,  70, 0x1005, 0x7AFF, 0x0FFA, 0x0143, 0xFA30, 4}, /* Atari ST: AttackSoundOrdinal = 8 */
		{19,  0, 0x0060, 0xE23D,   5, 18,  15,  33,  61,   0,  65, 0x3258, 0xAC77, 0x0F56, 0x0117, 0xFC40, 5},
		{20,  8, 0x10DE, 0x0225,  25, 25,  75, 144,  66,   0,  50, 0x1381, 0x7679, 0x0EA7, 0x0345, 0xFD93, 3}, /* Atari ST: AttackSoundOrdinal = 0 */
		{21,  3, 0x0082, 0xA3BD,   7, 15,  33,  77, 130,   0,  60, 0x1592, 0x696A, 0x0859, 0x0224, 0xFC30, 4},
		{22,  0, 0x1480, 0x53BD,  10, 14,  68, 100, 100,   0,  75, 0x4344, 0xBDF9, 0x0A5D, 0x0124, 0xF920, 3},
		{23,  0, 0x38AA, 0x0038,  12, 22, 255, 180, 210,   0, 130, 0x6369, 0xFF37, 0x0FBF, 0x0564, 0xFB52, 5},
		{24,  1, 0x068A, 0x97BD,  13, 28, 110, 255, 255,   0,  70, 0x3645, 0xBF7C, 0x06CD, 0x0445, 0xFC30, 4}, /* Atari ST Version 1.0 1987-12-08 1987-12-11: Ranges = 0x2645 */
		{25,  0, 0x38AA, 0x0000,  12, 22, 255, 180, 210,   0, 130, 0x6369, 0xFF37, 0x0FBF, 0x0564, 0xFB52, 5},
		{26,  0, 0x38AA, 0x0000,  12, 22, 255, 180, 210,   0, 130, 0x6369, 0xFF37, 0x0FBF, 0x0564, 0xFB52, 5}
	};
	// this is the number of uint16s the data has to be stored, not the length of the data in dungeon.dat!
	byte thingDataWordCount[16] = { // @ G0235_auc_Graphic559_ThingDataByteCount
		2,   /* Door */
		3,   /* Teleporter */
		2,   /* Text String */
		4,   /* Sensor */
		9,   /* Group */
		2,   /* Weapon */
		2,   /* Armour */
		2,   /* Scroll */
		2,   /* Potion */
		4,   /* Container */
		2,   /* Junk */
		0,   /* Unused */
		0,   /* Unused */
		0,   /* Unused */
		5,   /* Projectile */
		2    /* Explosion */
	};

	for (int i = 0; i < 180; i++)
		_objectInfos[i] = objectInfo[i];

	for (int i = 0; i < 58; i++)
		_armourInfos[i] = armourInfo[i];

	for (int i = 0; i < 46; i++)
		_weaponInfos[i] = weaponInfo[i];

	for (int i = 0; i < k27_CreatureTypeCount; i++)
		_creatureInfos[i] = creatureInfo[i];

	for (int i = 0; i < 16; i++)
		_thingDataWordCount[i] = thingDataWordCount[i];

}

DungeonMan::DungeonMan(DMEngine *dmEngine) : _vm(dmEngine) {
	_rawDunFileDataSize = 0;
	_rawDunFileData = nullptr;
	_dungeonColumCount = 0;
	_dungeonMapsFirstColumnIndex = nullptr;

	_dungeonColumCount = 0;
	_dungeonColumnsCumulativeSquareThingCount = nullptr;
	_squareFirstThings = nullptr;
	_dungeonTextData = nullptr;
	for (uint16 i = 0; i < 16; ++i)
		_thingData[i] = nullptr;

	_dungeonMapData = nullptr;
	_partyDir = (Direction)0;
	_partyMapX = 0;
	_partyMapY = 0;
	_partyMapIndex = 0;
	_currMapIndex = kDMMapIndexNone;
	_currMapData = nullptr;
	_currMap = nullptr;
	_currMapWidth = 0;
	_currMapHeight = 0;
	_currMapColCumulativeSquareFirstThingCount = nullptr;
	_dungeonMaps = nullptr;
	_dungeonRawMapData = nullptr;
	_currMapInscriptionWallOrnIndex = 0;
	for (uint16 i = 0; i < 6; ++i)
		_dungeonViewClickableBoxes[i].setToZero();
	_isFacingAlcove = false;
	_isFacingViAltar = false;
	_isFacingFountain = false;
	_squareAheadElement = (ElementType)0;

	_dungeonFileHeader._ornamentRandomSeed = 0;
	_dungeonFileHeader._rawMapDataSize = 0;
	_dungeonFileHeader._mapCount = 0;
	_dungeonFileHeader._textDataWordCount = 0;
	_dungeonFileHeader._partyStartLocation = 0;
	_dungeonFileHeader._squareFirstThingCount = 0;

	for (uint16 i = 0; i < 5; ++i)
		_pileTopObject[i] = Thing(0);
	for (uint16 i = 0; i < 2; ++i)
		_currMapDoorInfo[i].resetToZero();
	for (uint16 i = 0; i < 16; i++)
		_dungeonFileHeader._thingCounts[i] = 0;

	setupConstants();
}

DungeonMan::~DungeonMan() {
	delete[] _rawDunFileData;
	delete[] _dungeonMaps;
	delete[] _dungeonMapsFirstColumnIndex;
	delete[] _dungeonColumnsCumulativeSquareThingCount;
	delete[] _squareFirstThings;
	delete[] _dungeonTextData;
	delete[] _dungeonMapData;
	for (uint16 i = 0; i < 16; ++i)
		delete[] _thingData[i];

	delete[] _dungeonRawMapData;
}

void DungeonMan::decompressDungeonFile() {
	Common::File f;
	if (_vm->isDemo())
		f.open("DemoDun.dat");
	else
		f.open("Dungeon.dat");

	if (!f.isOpen())
		error("Unable to open Dungeon.dat file");

	if (f.readUint16BE() == 0x8104) { // if dungeon is compressed
		_rawDunFileDataSize = f.readUint32BE();
		delete[] _rawDunFileData;
		_rawDunFileData = new byte[_rawDunFileDataSize];
		f.readUint16BE(); // discard
		byte common[4];
		for (uint16 i = 0; i < 4; ++i)
			common[i] = f.readByte();
		byte lessCommon[16];
		for (uint16 i = 0; i < 16; ++i)
			lessCommon[i] = f.readByte();

		// start unpacking
		uint32 uncompIndex = 0;
		uint8 bitsUsedInWord = 0;
		uint16 wordBuff = f.readUint16BE();
		uint8 bitsLeftInByte = 8;
		byte byteBuff = f.readByte();
		while (uncompIndex < _rawDunFileDataSize) {
			while (bitsUsedInWord != 0) {
				uint8 shiftVal;
				if (f.eos()) {
					shiftVal = bitsUsedInWord;
					wordBuff <<= shiftVal;
				} else {
					shiftVal = MIN(bitsLeftInByte, bitsUsedInWord);
					wordBuff <<= shiftVal;
					wordBuff |= (byteBuff >> (8 - shiftVal));
					byteBuff <<= shiftVal;
					bitsLeftInByte -= shiftVal;
					if (!bitsLeftInByte) {
						byteBuff = f.readByte();
						bitsLeftInByte = 8;
					}
				}
				bitsUsedInWord -= shiftVal;
			}
			if (((wordBuff >> 15) & 1) == 0) {
				_rawDunFileData[uncompIndex++] = common[(wordBuff >> 13) & 3];
				bitsUsedInWord += 3;
			} else if (((wordBuff >> 14) & 3) == 2) {
				_rawDunFileData[uncompIndex++] = lessCommon[(wordBuff >> 10) & 15];
				bitsUsedInWord += 6;
			} else if (((wordBuff >> 14) & 3) == 3) {
				_rawDunFileData[uncompIndex++] = (wordBuff >> 6) & 255;
				bitsUsedInWord += 10;
			}
		}
	} else { // read uncompressed Dungeon.dat
		f.seek(0);
		_rawDunFileDataSize = f.size();
		delete[] _rawDunFileData;
		_rawDunFileData = new byte[_rawDunFileDataSize];
		f.read(_rawDunFileData, _rawDunFileDataSize);
	}
	f.close();
}

void DungeonMan::loadDungeonFile(Common::InSaveFile *file) {
	static const byte additionalThingCounts[16] = { // @ G0236_auc_Graphic559_AdditionalThingCounts{
		0,    /* Door */
		0,    /* Teleporter */
		0,    /* Text String */
		0,    /* Sensor */
		75,   /* Group */
		100,  /* Weapon */
		120,  /* Armour */
		0,    /* Scroll */
		5,    /* Potion */
		0,    /* Container */
		140,  /* Junk */
		0,    /* Unused */
		0,    /* Unused */
		0,    /* Unused */
		60,   /* Projectile */
		50    /* Explosion */
	};

	Timeline &timeline = *_vm->_timeline;
	if (_vm->_gameMode != kDMModeLoadSavedGame)
		decompressDungeonFile();

	Common::ReadStream *dunDataStream = nullptr;
	if (file) {
		// if loading a save
		dunDataStream = file;
	} else {
		// else read dungeon.dat
		assert(_rawDunFileData && _rawDunFileDataSize);
		dunDataStream = new Common::MemoryReadStream(_rawDunFileData, _rawDunFileDataSize, DisposeAfterUse::NO);
	}

	// initialize _g278_dungeonFileHeader
	_dungeonFileHeader._ornamentRandomSeed = dunDataStream->readUint16BE();
	_dungeonFileHeader._rawMapDataSize = dunDataStream->readUint16BE();
	_dungeonFileHeader._mapCount = dunDataStream->readByte();
	dunDataStream->readByte(); // discard 1 byte
	_dungeonFileHeader._textDataWordCount = dunDataStream->readUint16BE();
	_dungeonFileHeader._partyStartLocation = dunDataStream->readUint16BE();
	_dungeonFileHeader._squareFirstThingCount = dunDataStream->readUint16BE();
	for (uint16 i = 0; i < kDMThingTypeTotal; ++i)
		_dungeonFileHeader._thingCounts[i] = dunDataStream->readUint16BE();

	// init party position and mapindex
	if (_vm->_gameMode != kDMModeLoadSavedGame) {
		uint16 startLoc = _dungeonFileHeader._partyStartLocation;
		_partyDir = (Direction)((startLoc >> 10) & 3);
		_partyMapX = startLoc & 0x1F;
		_partyMapY = (startLoc >> 5) & 0x1F;
		_partyMapIndex = 0;
	}

	// load map data
	if (!_vm->_restartGameRequest) {
		delete[] _dungeonMaps;
		_dungeonMaps = new Map[_dungeonFileHeader._mapCount];
	}

	for (uint16 i = 0; i < _dungeonFileHeader._mapCount; ++i) {
		_dungeonMaps[i]._rawDunDataOffset = dunDataStream->readUint16BE();
		dunDataStream->readUint32BE(); // discard 4 bytes
		_dungeonMaps[i]._offsetMapX = dunDataStream->readByte();
		_dungeonMaps[i]._offsetMapY = dunDataStream->readByte();

		uint16 tmp = dunDataStream->readUint16BE();
		_dungeonMaps[i]._height = tmp >> 11;
		_dungeonMaps[i]._width = (tmp >> 6) & 0x1F;
		_dungeonMaps[i]._level = tmp & 0x3F; // Only used in DMII

		tmp = dunDataStream->readUint16BE();
		_dungeonMaps[i]._randFloorOrnCount = tmp >> 12;
		_dungeonMaps[i]._floorOrnCount = (tmp >> 8) & 0xF;
		_dungeonMaps[i]._randWallOrnCount = (tmp >> 4) & 0xF;
		_dungeonMaps[i]._wallOrnCount = tmp & 0xF;

		tmp = dunDataStream->readUint16BE();
		_dungeonMaps[i]._difficulty = tmp >> 12;
		_dungeonMaps[i]._creatureTypeCount = (tmp >> 4) & 0xF;
		_dungeonMaps[i]._doorOrnCount = tmp & 0xF;

		tmp = dunDataStream->readUint16BE();
		_dungeonMaps[i]._doorSet1 = (tmp >> 12) & 0xF;
		_dungeonMaps[i]._doorSet0 = (tmp >> 8) & 0xF;
		_dungeonMaps[i]._wallSet = (WallSet)((tmp >> 4) & 0xF);
		_dungeonMaps[i]._floorSet = (FloorSet)(tmp & 0xF);

		//if (!file)
		//	delete dunDataStream;
	}

	// load column stuff thingy
	if (!_vm->_restartGameRequest) {
		delete[] _dungeonMapsFirstColumnIndex;
		_dungeonMapsFirstColumnIndex = new uint16[_dungeonFileHeader._mapCount];
	}
	uint16 columCount = 0;
	for (uint16 i = 0; i < _dungeonFileHeader._mapCount; ++i) {
		_dungeonMapsFirstColumnIndex[i] = columCount;
		columCount += _dungeonMaps[i]._width + 1;
	}
	_dungeonColumCount = columCount;

	uint32 actualSquareFirstThingCount = _dungeonFileHeader._squareFirstThingCount;
	if (_vm->_gameMode != kDMModeLoadSavedGame)
		_dungeonFileHeader._squareFirstThingCount += 300;

	if (!_vm->_restartGameRequest) {
		delete[] _dungeonColumnsCumulativeSquareThingCount;
		_dungeonColumnsCumulativeSquareThingCount = new uint16[columCount];
	}
	for (uint16 i = 0; i < columCount; ++i)
		_dungeonColumnsCumulativeSquareThingCount[i] = dunDataStream->readUint16BE();

	// load square first things
	if (!_vm->_restartGameRequest) {
		delete[] _squareFirstThings;
		_squareFirstThings = new Thing[_dungeonFileHeader._squareFirstThingCount];
	}

	for (uint16 i = 0; i < actualSquareFirstThingCount; ++i)
		_squareFirstThings[i].set(dunDataStream->readUint16BE());

	if (_vm->_gameMode != kDMModeLoadSavedGame) {
		for (uint16 i = 0; i < 300; ++i)
			_squareFirstThings[actualSquareFirstThingCount + i] = _vm->_thingNone;
	}

	// load text data
	if (!_vm->_restartGameRequest) {
		delete[] _dungeonTextData;
		_dungeonTextData = new uint16[_dungeonFileHeader._textDataWordCount];
	}

	for (uint16 i = 0; i < _dungeonFileHeader._textDataWordCount; ++i)
		_dungeonTextData[i] = dunDataStream->readUint16BE();

	if (_vm->_gameMode != kDMModeLoadSavedGame)
		timeline._eventMaxCount = 100;

	// load things
	for (uint16 thingType = kDMThingTypeDoor; thingType < kDMThingTypeTotal; ++thingType) {
		uint16 thingCount = _dungeonFileHeader._thingCounts[thingType];
		if (_vm->_gameMode != kDMModeLoadSavedGame)
			_dungeonFileHeader._thingCounts[thingType] = MIN((thingType == kDMThingTypeExplosion) ? 768 : 1024, thingCount + additionalThingCounts[thingType]);

		uint16 thingStoreWordCount = _thingDataWordCount[thingType];

		if (thingStoreWordCount == 0)
			continue;

		if (!_vm->_restartGameRequest) {
			delete[] _thingData[thingType];
			_thingData[thingType] = new uint16[_dungeonFileHeader._thingCounts[thingType] * thingStoreWordCount];
		}

		if ((thingType == kDMThingTypeGroup || thingType == kDMThingTypeProjectile) && !file) { // !file because save files have diff. structure than dungeon.dat
			for (uint16 i = 0; i < thingCount; ++i) {
				uint16 *nextSlot = _thingData[thingType] + i *thingStoreWordCount;
				for (uint16 j = 0; j < thingStoreWordCount; ++j) {
					if (j == 2 || j == 3)
						nextSlot[j] = dunDataStream->readByte();
					else
						nextSlot[j] = dunDataStream->readUint16BE();
				}
			}
		} else {
			for (uint16 i = 0; i < thingCount; ++i) {
				uint16 *nextSlot = _thingData[thingType] + i *thingStoreWordCount;
				for (uint16 j = 0; j < thingStoreWordCount; ++j)
					nextSlot[j] = dunDataStream->readUint16BE();
			}
		}

		if (_vm->_gameMode != kDMModeLoadSavedGame) {
			if ((thingType == kDMThingTypeGroup) || thingType >= kDMThingTypeProjectile)
				timeline._eventMaxCount += _dungeonFileHeader._thingCounts[thingType];

			for (uint16 i = 0; i < additionalThingCounts[thingType]; ++i)
				(_thingData[thingType] + (thingCount + i) * thingStoreWordCount)[0] = _vm->_thingNone.toUint16();
		}
	}

	// load map data
	if (!_vm->_restartGameRequest) {
		delete[] _dungeonRawMapData;
		_dungeonRawMapData = new byte[_dungeonFileHeader._rawMapDataSize];
	}

	for (uint32 i = 0; i < _dungeonFileHeader._rawMapDataSize; ++i)
		_dungeonRawMapData[i] = dunDataStream->readByte();

	if (!_vm->_restartGameRequest) {
		uint8 mapCount = _dungeonFileHeader._mapCount;
		delete[] _dungeonMapData;
		_dungeonMapData = new byte**[_dungeonColumCount + mapCount];
		byte **colFirstSquares = (byte **)_dungeonMapData + mapCount;
		for (uint8 i = 0; i < mapCount; ++i) {
			_dungeonMapData[i] = colFirstSquares;
			byte *square = _dungeonRawMapData + _dungeonMaps[i]._rawDunDataOffset;
			*colFirstSquares++ = square;
			for (uint16 w = 1; w <= _dungeonMaps[i]._width; ++w) {
				square += _dungeonMaps[i]._height + 1;
				*colFirstSquares++ = square;
			}
		}
	}

	if (!file) { // this means that we created a new MemoryReadStream
		delete dunDataStream;
	} // the deletion of the function parameter 'file' happens elsewhere
}

void DungeonMan::setCurrentMap(uint16 mapIndex) {
	static const DoorInfo doorInfo[4] = { // @ G0254_as_Graphic559_DoorInfo
		/* { Attributes, Defense } */
		DoorInfo(3, 110),   /* Door type 0 Portcullis */
		DoorInfo(0,  42),   /* Door type 1 Wooden door */
		DoorInfo(0, 230),   /* Door type 2 Iron door */
		DoorInfo(5, 255)    /* Door type 3 Ra door */
	};


	_currMapIndex = mapIndex;
	_currMapData = _dungeonMapData[mapIndex];
	_currMap = _dungeonMaps + mapIndex;
	_currMapWidth = _dungeonMaps[mapIndex]._width + 1;
	_currMapHeight = _dungeonMaps[mapIndex]._height + 1;
	_currMapDoorInfo[0] = doorInfo[_currMap->_doorSet0];
	_currMapDoorInfo[1] = doorInfo[_currMap->_doorSet1];
	_currMapColCumulativeSquareFirstThingCount = &_dungeonColumnsCumulativeSquareThingCount[_dungeonMapsFirstColumnIndex[mapIndex]];
}

void DungeonMan::setCurrentMapAndPartyMap(uint16 mapIndex) {
	DisplayMan &displMan = *_vm->_displayMan;

	setCurrentMap(_partyMapIndex = mapIndex);
	byte *metaMapData = _currMapData[_currMapWidth - 1] + _currMapHeight;

	displMan._currMapAllowedCreatureTypes = metaMapData;
	metaMapData += _currMap->_creatureTypeCount;

	memcpy(displMan._currMapWallOrnIndices, metaMapData, _currMap->_wallOrnCount);
	metaMapData += _currMap->_wallOrnCount;

	memcpy(displMan._currMapFloorOrnIndices, metaMapData, _currMap->_floorOrnCount);
	metaMapData += _currMap->_floorOrnCount;

	memcpy(displMan._currMapDoorOrnIndices, metaMapData, _currMap->_doorOrnCount);

	_currMapInscriptionWallOrnIndex = _currMap->_wallOrnCount;
	displMan._currMapWallOrnIndices[_currMapInscriptionWallOrnIndex] = k0_WallOrnInscription;
}


Square DungeonMan::getSquare(int16 mapX, int16 mapY) {
	bool isMapYInBounds = (mapY >= 0) && (mapY < _currMapHeight);
	bool isMapXInBounds = (mapX >= 0) && (mapX < _currMapWidth);

	if (isMapXInBounds && isMapYInBounds)
		return Square(_currMapData[mapX][mapY]);

	if (isMapYInBounds) {
		ElementType squareType = Square(_currMapData[0][mapY]).getType();
		if (((mapX == -1) && (squareType == kDMElementTypeCorridor)) || (squareType == kDMElementTypePit))
			return Square(kDMElementTypeWall, kDMSquareMaskWallEastRandOrnament);

		squareType = Square(_currMapData[_currMapWidth - 1][mapY]).getType();
		if (((mapX == _currMapWidth) && (squareType == kDMElementTypeCorridor)) || (squareType == kDMElementTypePit))
			return Square(kDMElementTypeWall, kDMSquareMaskWallWestRandOrnament);
	} else if (isMapXInBounds) {
		ElementType squareType = Square(_currMapData[mapX][0]).getType();
		if (((mapY == -1) && (squareType == kDMElementTypeCorridor)) || (squareType == kDMElementTypePit))
			return Square(kDMElementTypeWall, kDMSquareMaslWallSouthRandOrnament);

		squareType = Square(_currMapData[mapX][_currMapHeight - 1]).getType();
		if (((mapY == _currMapHeight) && (squareType == kDMElementTypeCorridor)) || (squareType == kDMElementTypePit))
			return Square(kDMElementTypeWall, kDMSquareMaskWallNorthRandOrnament);
	}
	return Square(kDMElementTypeWall, 0);
}

Square DungeonMan::getRelSquare(Direction dir, int16 stepsForward, int16 stepsRight, int16 posX, int16 posY) {
	mapCoordsAfterRelMovement(dir, stepsForward, stepsForward, posX, posY);
	return getSquare(posX, posY);
}

int16 DungeonMan::getSquareFirstThingIndex(int16 mapX, int16 mapY) {
	unsigned char *curSquare = _currMapData[mapX];
	if ((mapX < 0) || (mapX >= _currMapWidth) || (mapY < 0) || (mapY >= _currMapHeight) || !getFlag(curSquare[mapY], kDMSquareMaskThingListPresent))
		return -1;

	int16 curMapY = 0;
	uint16 thingIndex = _currMapColCumulativeSquareFirstThingCount[mapX];
	while (curMapY++ != mapY) {
		if (getFlag(*curSquare++, kDMSquareMaskThingListPresent))
			thingIndex++;
	}
	return thingIndex;
}

Thing DungeonMan::getSquareFirstThing(int16 mapX, int16 mapY) {
	int16 index = getSquareFirstThingIndex(mapX, mapY);
	if (index == -1)
		return _vm->_thingEndOfList;
	return _squareFirstThings[index];
}

void DungeonMan::setSquareAspect(uint16 *aspectArray, Direction dir, int16 mapX, int16 mapY) {
	unsigned char L0307_uc_Multiple;
#define AL0307_uc_Square            L0307_uc_Multiple
#define AL0307_uc_FootprintsAllowed L0307_uc_Multiple
#define AL0307_uc_ScentOrdinal      L0307_uc_Multiple

	DisplayMan &displMan = *_vm->_displayMan;
	ChampionMan &championMan = *_vm->_championMan;

	for (uint16 i = 0; i < 5; ++i)
		aspectArray[i] = 0;

	Thing curThing = getSquareFirstThing(mapX, mapY);
	AL0307_uc_Square = getSquare(mapX, mapY).toByte();
	bool leftRandomWallOrnamentAllowed = false;
	bool rightRandomWallOrnamentAllowed = false;
	bool frontRandomWallOrnamentAllowed = false;
	bool squareIsFakeWall;

	aspectArray[kDMSquareAspectElement] = Square(AL0307_uc_Square).getType();
	switch (aspectArray[kDMSquareAspectElement]) {
	case kDMElementTypeWall:
		switch (dir) {
		case kDMDirNorth:
			leftRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskWallEastRandOrnament);
			frontRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaslWallSouthRandOrnament);
			rightRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskWallWestRandOrnament);
			break;
		case kDMDirEast:
			leftRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaslWallSouthRandOrnament);
			frontRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskWallWestRandOrnament);
			rightRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskWallNorthRandOrnament);
			break;
		case kDMDirSouth:
			leftRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskWallWestRandOrnament);
			frontRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskWallNorthRandOrnament);
			rightRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskWallEastRandOrnament);
			break;
		case kDMDirWest:
			leftRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskWallNorthRandOrnament);
			frontRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskWallEastRandOrnament);
			rightRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaslWallSouthRandOrnament);
			break;
		default:
			assert(false);
		}
		displMan._championPortraitOrdinal = 0;
		squareIsFakeWall = false;
T0172010_ClosedFakeWall:
		setSquareAspectOrnOrdinals(aspectArray, leftRandomWallOrnamentAllowed, frontRandomWallOrnamentAllowed, rightRandomWallOrnamentAllowed, dir, mapX, mapY, squareIsFakeWall);
		while ((curThing != _vm->_thingEndOfList) && (curThing.getType() <= kDMThingTypeSensor)) {
			ThingType curThingType = curThing.getType();
			int16 AL0310_i_SideIndex = _vm->normalizeModulo4(curThing.getCell() - dir);
			if (AL0310_i_SideIndex) { /* Invisible on the back wall if 0 */
				Sensor *curSensor = (Sensor *)getThingData(curThing);
				if (curThingType == kDMstringTypeText) {
					if (((TextString *)curSensor)->isVisible()) {
						aspectArray[AL0310_i_SideIndex + 1] = _currMapInscriptionWallOrnIndex + 1;
						displMan._inscriptionThing = curThing; /* BUG0_76 The same text is drawn on multiple sides of a wall square. The engine stores only a single text to draw on a wall in a global variable. Even if different texts are placed on different sides of the wall, the same text is drawn on each affected side */
					}
				} else {
					aspectArray[AL0310_i_SideIndex + 1] = curSensor->getAttrOrnOrdinal();
					if (curSensor->getType() == kDMSensorWallChampionPortrait) {
						displMan._championPortraitOrdinal = _vm->indexToOrdinal(curSensor->getData());
					}
				}
			}
			curThing = getNextThing(curThing);
		}
		if (squareIsFakeWall && (_partyMapX != mapX) && (_partyMapY != mapY)) {
			aspectArray[kDMSquareAspectFirstGroupOrObject] = _vm->_thingEndOfList.toUint16();
			return;
		}
		break;
	case kDMElementTypeFakeWall:
		if (!getFlag(AL0307_uc_Square, kDMSquareMaskFakeWallOpen)) {
			aspectArray[kDMSquareAspectElement] = kDMElementTypeWall;
			leftRandomWallOrnamentAllowed = rightRandomWallOrnamentAllowed = frontRandomWallOrnamentAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskFakeWallRandOrnamentOrFootprintsAllowed);
			squareIsFakeWall = true;
			goto T0172010_ClosedFakeWall;
		}
		aspectArray[kDMSquareAspectElement] = kDMElementTypeCorridor;
		AL0307_uc_FootprintsAllowed = getFlag(AL0307_uc_Square, kDMSquareMaskFakeWallRandOrnamentOrFootprintsAllowed) ? 8 : 0;
		// fall through
	case kDMElementTypeCorridor:
	case kDMElementTypePit:
	case kDMElementTypeTeleporter:
		if (aspectArray[kDMSquareAspectElement] == kDMElementTypeCorridor) {
			aspectArray[kDMSquareAspectFloorOrn] = getRandomOrnOrdinal(getFlag(AL0307_uc_Square, kDMSquareMaskCorridorRandOrnament), _currMap->_randFloorOrnCount, mapX, mapY, 30);
			AL0307_uc_FootprintsAllowed = true;
		} else if (aspectArray[kDMSquareAspectElement] == kDMElementTypePit) {
			if (getFlag(AL0307_uc_Square, kDMSquareMaskPitOpen)) {
				aspectArray[kDMSquareAspectPitInvisible] = getFlag(AL0307_uc_Square, kDMSquareMaskPitInvisible);
				AL0307_uc_FootprintsAllowed &= 0x0001;
			} else {
				aspectArray[kDMSquareAspectElement] = kDMElementTypeCorridor;
				AL0307_uc_FootprintsAllowed = true;
			}
		} else { // k5_ElementTypeTeleporter
			aspectArray[kDMSquareAspectTeleporterVisible] = getFlag(AL0307_uc_Square, kDMSquareMaskTeleporterOpen) && getFlag(AL0307_uc_Square, kDMSquareMaskTeleporterVisible);
			AL0307_uc_FootprintsAllowed = true;
		}

		while ((curThing != _vm->_thingEndOfList) && (curThing.getType() <= kDMThingTypeSensor)) {
			if (curThing.getType() == kDMThingTypeSensor) {
				Sensor *curSensor = (Sensor *)getThingData(curThing);
				aspectArray[kDMSquareAspectFloorOrn] = curSensor->getAttrOrnOrdinal();
			}
			curThing = getNextThing(curThing);
		}

		AL0307_uc_ScentOrdinal = championMan.getScentOrdinal(mapX, mapY);
		if (AL0307_uc_FootprintsAllowed && (AL0307_uc_ScentOrdinal) && (--AL0307_uc_ScentOrdinal >= championMan._party._firstScentIndex) && (AL0307_uc_ScentOrdinal < championMan._party._lastScentIndex))
			setFlag(aspectArray[kDMSquareAspectFloorOrn], kDMMaskFootprints);

		break;
	case kDMElementTypeStairs:
		aspectArray[kDMSquareAspectElement] = (bool((getFlag(AL0307_uc_Square, kDMSquareMaskStairsNorthSouth) >> 3)) == _vm->isOrientedWestEast(dir)) ? kDMElementTypeStairsSide : kDMElementTypeStairsFront;
		aspectArray[kDMSquareAspectStairsUp] = getFlag(AL0307_uc_Square, kDMSquareMaskStairsUp);
		AL0307_uc_FootprintsAllowed = false;
		while ((curThing != _vm->_thingEndOfList) && (curThing.getType() <= kDMThingTypeSensor))
			curThing = getNextThing(curThing);
		break;
	case kDMElementTypeDoor:
		if (bool((getFlag(AL0307_uc_Square, (byte) kDMSquareMaskDoorNorthSouth) >> 3)) == _vm->isOrientedWestEast(dir)) {
			aspectArray[kDMSquareAspectElement] = kDMElementTypeDoorSide;
		} else {
			aspectArray[kDMSquareAspectElement] = kDMElementTypeDoorFront;
			aspectArray[kDMSquareAspectDoorState] = Square(AL0307_uc_Square).getDoorState();
			aspectArray[kDMSquareAspectDoorThingIndex] = getSquareFirstThing(mapX, mapY).getIndex();
		}
		AL0307_uc_FootprintsAllowed = true;

		while ((curThing != _vm->_thingEndOfList) && (curThing.getType() <= kDMThingTypeSensor))
			curThing = getNextThing(curThing);

		AL0307_uc_ScentOrdinal = championMan.getScentOrdinal(mapX, mapY);
		if (AL0307_uc_FootprintsAllowed && (AL0307_uc_ScentOrdinal) && (--AL0307_uc_ScentOrdinal >= championMan._party._firstScentIndex) && (AL0307_uc_ScentOrdinal < championMan._party._lastScentIndex))
			setFlag(aspectArray[kDMSquareAspectFloorOrn], kDMMaskFootprints);
		break;
	default:
		break;
	}
	aspectArray[kDMSquareAspectFirstGroupOrObject] = curThing.toUint16();
}

void DungeonMan::setSquareAspectOrnOrdinals(uint16 *aspectArray, bool leftAllowed, bool frontAllowed, bool rightAllowed, int16 dir,
												 int16 mapX, int16 mapY, bool isFakeWall) {

	int16 randomWallOrnamentCount = _currMap->_randWallOrnCount;
	aspectArray[kDMSquareAspectRightWallOrnOrd] = getRandomOrnOrdinal(leftAllowed, randomWallOrnamentCount, mapX, ++mapY * (_vm->normalizeModulo4(++dir) + 1), 30);
	aspectArray[kDMSquareFrontWallOrnOrd] = getRandomOrnOrdinal(frontAllowed, randomWallOrnamentCount, mapX, mapY * (_vm->normalizeModulo4(++dir) + 1), 30);
	aspectArray[kDMSquareAspectLeftWallOrnOrd] = getRandomOrnOrdinal(rightAllowed, randomWallOrnamentCount, mapX, mapY-- * (_vm->normalizeModulo4(++dir) + 1), 30);
	if (isFakeWall || (mapX < 0) || (mapX >= _currMapWidth) || (mapY < 0) || (mapY >= _currMapHeight)) { /* If square is a fake wall or is out of map bounds */
		for (int16 sideIndex = kDMSquareAspectRightWallOrnOrd; sideIndex <= kDMSquareAspectLeftWallOrnOrd; sideIndex++) { /* Loop to remove any random ornament that is an alcove */
			if (isWallOrnAnAlcove(_vm->ordinalToIndex(aspectArray[sideIndex])))
				aspectArray[sideIndex] = 0;
		}
	}
}

int16 DungeonMan::getRandomOrnOrdinal(bool allowed, int16 count, int16 mapX, int16 mapY, int16 modulo) {
	int16 randomOrnamentIndex = getRandomOrnamentIndex((int16)2000 + (mapX << 5) + mapY, (int16)3000 + (_currMapIndex << (int16)6) + _currMapWidth + _currMapHeight, modulo);

	if (allowed && (randomOrnamentIndex < count))
		return _vm->indexToOrdinal(randomOrnamentIndex);

	return 0;
}


bool DungeonMan::isWallOrnAnAlcove(int16 wallOrnIndex) {
	if (wallOrnIndex >= 0) {
		DisplayMan &displMan = *_vm->_displayMan;
		for (uint16 i = 0; i < k3_AlcoveOrnCount; ++i) {
			if (displMan._currMapAlcoveOrnIndices[i] == wallOrnIndex)
				return true;
		}
	}

	return false;
}

uint16 *DungeonMan::getThingData(Thing thing) {
	return _thingData[thing.getType()] + thing.getIndex() * _thingDataWordCount[thing.getType()];
}

uint16 *DungeonMan::getSquareFirstThingData(int16 mapX, int16 mapY) {
	return getThingData(getSquareFirstThing(mapX, mapY));
}

Thing DungeonMan::getNextThing(Thing thing) {
	return Thing(getThingData(thing)[0]);
}

void DungeonMan::decodeText(char *destString, Thing thing, TextType type) {
	static char messageAndScrollEscReplacementStrings[32][8] = { // @ G0255_aac_Graphic559_MessageAndScrollEscapeReplacementStrings
		{'x',   0,   0,   0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { '?',  0,  0,  0, 0, 0, 0, 0 }, */
		{'y',   0,   0,   0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { '!',  0,  0,  0, 0, 0, 0, 0 }, */
		{'T', 'H', 'E', ' ', 0, 0, 0, 0},
		{'Y', 'O', 'U', ' ', 0, 0, 0, 0},
		{'z',   0,   0,   0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{'{',   0,   0,   0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{'|',   0,   0,   0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{'}',   0,   0,   0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{'~',   0,   0,   0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{'',   0,   0,   0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0},
		{0,     0,   0,   0, 0, 0, 0, 0}
	};

	static char escReplacementCharacters[32][2] = { // @ G0256_aac_Graphic559_EscapeReplacementCharacters
		{'a', 0}, {'b', 0}, {'c', 0}, {'d', 0},
		{'e', 0}, {'f', 0}, {'g', 0}, {'h', 0},
		{'i', 0}, {'j', 0}, {'k', 0}, {'l', 0},
		{'m', 0}, {'n', 0}, {'o', 0}, {'p', 0},
		{'q', 0}, {'r', 0}, {'s', 0}, {'t', 0},
		{'u', 0}, {'v', 0}, {'w', 0}, {'x', 0},
		{'0', 0}, {'1', 0}, {'2', 0}, {'3', 0},
		{'4', 0}, {'5', 0}, {'6', 0}, {'7', 0}
	};

	static char inscriptionEscReplacementStrings[32][8] = { // @ G0257_aac_Graphic559_InscriptionEscapeReplacementStrings
		{28,  0,  0,  0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{29,  0,  0,  0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{19,  7,  4, 26, 0, 0, 0, 0},
		{24, 14, 20, 26, 0, 0, 0, 0},
		{30,  0,  0,  0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{31,  0,  0,  0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{32,  0,  0,  0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{33,  0,  0,  0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{34,  0,  0,  0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{35,  0,  0,  0, 0, 0, 0, 0}, /* Atari ST Version 1.0 1987-12-08 1987-12-11 1.1 1.2EN 1.2GE: { 0,  0,  0,  0, 0, 0, 0, 0 }, */
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0},
		{0,   0,  0,  0, 0, 0, 0, 0}
	};

	TextString textString(_thingData[kDMstringTypeText] + thing.getIndex() * _thingDataWordCount[kDMstringTypeText]);
	if ((textString.isVisible()) || (type & kDMMaskDecodeEvenIfInvisible)) {
		type = (TextType)(type & ~kDMMaskDecodeEvenIfInvisible);
		char sepChar;
		if (type == kDMTextTypeMessage) {
			*destString++ = '\n';
			sepChar = ' ';
		} else if (type == kDMTextTypeInscription) {
			sepChar = (char)0x80;
		} else {
			sepChar = '\n';
		}
		uint16 codeCounter = 0;
		int16 escChar = 0;
		uint16 *codeWord = _dungeonTextData + textString.getWordOffset();
		uint16 code = 0, codes = 0;
		char *escReplString = nullptr;
		for (;;) { /*infinite loop*/
			if (!codeCounter) {
				codes = *codeWord++;
				code = (codes >> 10) & 0x1F;
			} else if (codeCounter == 1) {
				code = (codes >> 5) & 0x1F;
			} else {
				code = codes & 0x1F;
			}
			++codeCounter;
			codeCounter %= 3;

			if (escChar) {
				*destString = '\0';
				if (escChar == 30) {
					if (type != kDMTextTypeInscription)
						escReplString = messageAndScrollEscReplacementStrings[code];
					else
						escReplString = inscriptionEscReplacementStrings[code];
				} else
					escReplString = escReplacementCharacters[code];

				strcat(destString, escReplString);
				destString += strlen(escReplString);
				escChar = 0;
			} else if (code < 28) {
				if (type != kDMTextTypeInscription) {
					if (code == 26)
						code = ' ';
					else if (code == 27)
						code = '.';
					else
						code += 'A';
				}
				*destString++ = code;
			} else if (code == 28)
				*destString++ = sepChar;
			else if (code <= 30)
				escChar = code;
			else
				break;
		}
	}
	*destString = ((type == kDMTextTypeInscription) ? 0x81 : '\0');
}

Thing DungeonMan::getUnusedThing(uint16 thingType) {
	int16 thingCount = _dungeonFileHeader._thingCounts[getFlag(thingType, kDMMaskThingType)];
	if (thingType == (kDMMaskChampionBones | kDMThingTypeJunk)) {
		thingType = kDMThingTypeJunk;
	} else if (thingType == kDMThingTypeJunk)
		thingCount -= 3; /* Always keep 3 unused JUNK things for the bones of dead champions */

	int16 thingIdx = thingCount;
	int16 thingDataByteCount = _thingDataWordCount[thingType] >> 1;
	Thing *thingPtr = (Thing *)_thingData[thingType];

	Thing curThing;
	for (;;) { /*_Infinite loop_*/
		if (*thingPtr == _vm->_thingNone) { /* If thing data is unused */
			curThing = Thing((thingType << 10) | (thingCount - thingIdx));
			break;
		}
		if (--thingIdx) { /* If there are thing data left to process */
			thingPtr += thingDataByteCount; /* Proceed to the next thing data */
		} else {
			curThing = getDiscardThing(thingType);
			if (curThing == _vm->_thingNone)
				return _vm->_thingNone;

			thingPtr = (Thing *)getThingData(curThing);
			break;
		}
	}
	for (uint16 i = 0; i < thingDataByteCount; i++) {
		thingPtr[i].set(0);
	}

	*thingPtr = _vm->_thingEndOfList;
	return curThing;
}

uint16 DungeonMan::getObjectWeight(Thing thing) {
	static const uint16 junkInfo[] = { // @ G0241_auc_Graphic559_JunkInfo
		// COMPASS - WATERSKIN - JEWEL SYMAL - ILLUMULET - ASHES
		1, 3, 2, 2, 4,
		// BONES - COPPER COIN - SILVER COIN - GOLD COIN - IRON KEY
		15, 1, 1, 1, 2,
		// KEY OF B - SOLID KEY - SQUARE KEY - TOURQUOISE KEY - CROSS KEY
		1, 1, 1, 1, 1,
		// ONYX KEY - SKELETON KEY - GOLD KEY - WINGED KEY - TOPAZ KEY
		1, 1, 1, 1, 1,
		// SAPPHIRE KEY - EMERALD KEY - RUBY KEY - RA KEY - MASTER KEY
		1, 1, 1, 1, 1,
		// BOULDER - BLUE GEM - ORANGE GEM - GREEN GEM - APPLE
		81, 2, 3, 2, 4,
		// CORN - BREAD - CHEESE - SCREAMER SLICE - WORM ROUND
		4, 3, 8, 5, 11,
		// DRUMSTICK - DRAGON STEAK - GEM OF AGES - EKKHARD CROSS - MOONSTONE
		4, 6, 2, 3, 2,
		// THE HELLION - PENDANT FERAL - MAGICAL BOX - MAGICAL BOX - MIRROR OF DAWN
		2, 2, 6, 9, 3,
		// ROPE - RABBIT'S FOOT - CORBAMITE - CHOKER - LOCK PICKS
		10, 1, 0, 1, 1,
		// MAGNIFIER - ZOKATHRA SPELL - BONES
		2, 0, 8
	};

	if (thing == _vm->_thingNone)
		return 0;

	// Initialization is not present in original
	// Set to 0 by default as it's the default value used for _vm->_none
	uint16 weight = 0;
	Junk *junk = (Junk *)getThingData(thing);

	switch (thing.getType()) {
	case kDMThingTypeWeapon:
		weight = _weaponInfos[((Weapon *)junk)->getType()]._weight;
		break;
	case kDMThingTypeArmour:
		weight = _armourInfos[((Armour *)junk)->getType()]._weight;
		break;
	case kDMThingTypeJunk:
		weight = junkInfo[junk->getType()];
		if (junk->getType() == kDMJunkTypeWaterskin)
			weight += junk->getChargeCount() << 1;

		break;
	case kDMThingTypeContainer:
		weight = 50;
		thing = ((Container *)junk)->getSlot();
		while (thing != _vm->_thingEndOfList) {
			weight += getObjectWeight(thing);
			thing = getNextThing(thing);
		}
		break;
	case kDMThingTypePotion:
		if (((Potion *)junk)->getType() == kDMPotionTypeEmptyFlask)
			weight = 1;
		else
			weight = 3;
		break;
	case kDMThingTypeScroll:
		weight = 1;
		break;
	default:
		break;
	}

	return weight; // this is garbage if none of the branches were taken
}

int16 DungeonMan::getObjectInfoIndex(Thing thing) {
	uint16 *rawType = getThingData(thing);
	switch (thing.getType()) {
	case kDMThingTypeScroll:
		return kDMObjectInfoIndexFirstScroll;
	case kDMThingTypeContainer:
		return kDMObjectInfoIndexFirstContainer + Container(rawType).getType();
	case kDMThingTypeJunk:
		return kDMObjectInfoIndexFirstJunk + Junk(rawType).getType();
	case kDMThingTypeWeapon:
		return kDMObjectInfoIndexFirstWeapon + Weapon(rawType).getType();
	case kDMThingTypeArmour:
		return kDMObjectInfoIndexFirstArmour + Armour(rawType).getType();
	case kDMThingTypePotion:
		return kDMObjectInfoIndexFirstPotion + Potion(rawType).getType();
	default:
		return -1;
	}
}

void DungeonMan::linkThingToList(Thing thingToLink, Thing thingInList, int16 mapX, int16 mapY) {
	if (thingToLink == _vm->_thingEndOfList)
		return;

	Thing *thingPtr = (Thing *)getThingData(thingToLink);
	*thingPtr = _vm->_thingEndOfList;
	/* If mapX >= 0 then the thing is linked to the list of things on the specified square else it is linked at the end of the specified thing list */
	if (mapX >= 0) {
		byte *currSquare = &_currMapData[mapX][mapY];
		if (getFlag(*currSquare, kDMSquareMaskThingListPresent)) {
			thingInList = getSquareFirstThing(mapX, mapY);
		} else {
			setFlag(*currSquare, kDMSquareMaskThingListPresent);
			uint16 *tmp = _currMapColCumulativeSquareFirstThingCount + mapX + 1;
			uint16 currColumn = _dungeonColumCount - (_dungeonMapsFirstColumnIndex[_currMapIndex] + mapX) - 1;
			while (currColumn--) { /* For each column starting from and after the column containing the square where the thing is added */
				(*tmp++)++; /* Increment the cumulative first thing count */
			}
			uint16 currMapY = 0;
			currSquare -= mapY;
			uint16 currSquareFirstThingIndex = _currMapColCumulativeSquareFirstThingCount[mapX];
			while (currMapY++ != mapY) {
				if (getFlag(*currSquare++, kDMSquareMaskThingListPresent))
					currSquareFirstThingIndex++;
			}
			Thing *currThing = &_squareFirstThings[currSquareFirstThingIndex];
			// the second '- 1' is for the loop initialization, > 0 is because we are copying from one behind
			for (int16 i = _dungeonFileHeader._squareFirstThingCount - currSquareFirstThingIndex - 1 - 1; i > 0; --i)
				currThing[i] = currThing[i - 1];

			*currThing = thingToLink;
			return;
		}
	}
	Thing nextThing = getNextThing(thingInList);
	while (nextThing != _vm->_thingEndOfList)
		nextThing = getNextThing(thingInList = nextThing);

	thingPtr = (Thing *)getThingData(thingInList);
	*thingPtr = thingToLink;
}

WeaponInfo *DungeonMan::getWeaponInfo(Thing thing) {
	Weapon *weapon = (Weapon *)getThingData(thing);
	return &_weaponInfos[weapon->getType()];
}

int16 DungeonMan::getProjectileAspect(Thing thing) {
	ThingType thingType = thing.getType();
	if (thingType == kDMThingTypeExplosion) {
		if (thing == _vm->_thingExplFireBall)
			return -_vm->indexToOrdinal(k10_ProjectileAspectExplosionFireBall);
		if (thing == _vm->_thingExplSlime)
			return -_vm->indexToOrdinal(k12_ProjectileAspectExplosionSlime);
		if (thing == _vm->_thingExplLightningBolt)
			return -_vm->indexToOrdinal(k3_ProjectileAspectExplosionLightningBolt);
		if ((thing == _vm->_thingExplPoisonBolt) || (thing == _vm->_thingExplPoisonCloud))
			return -_vm->indexToOrdinal(k13_ProjectileAspectExplosionPoisonBoltCloud);

		return -_vm->indexToOrdinal(k11_ProjectileAspectExplosionDefault);
	} else if (thingType == kDMThingTypeWeapon) {
		WeaponInfo *weaponInfo = getWeaponInfo(thing);
		int16 projAspOrd = weaponInfo->getProjectileAspectOrdinal();
		if (projAspOrd)
			return -projAspOrd;
	}

	return _objectInfos[getObjectInfoIndex(thing)]._objectAspectIndex;
}

int16 DungeonMan::getLocationAfterLevelChange(int16 mapIndex, int16 levelDelta, int16 *mapX, int16 *mapY) {
	if (_partyMapIndex == kDMMapIndexEntrance)
		return kDMMapIndexNone;

	Map *map = _dungeonMaps + mapIndex;
	int16 newMapX = map->_offsetMapX + *mapX;
	int16 newMapY = map->_offsetMapY + *mapY;
	int16 newLevel = map->_level + levelDelta;
	map = _dungeonMaps;

	for (int16 targetMapIndex = 0; targetMapIndex < _dungeonFileHeader._mapCount; targetMapIndex++) {
		if ((map->_level == newLevel)
		&& (newMapX >= map->_offsetMapX) && (newMapX <= map->_offsetMapX + map->_width)
		&& (newMapY >= map->_offsetMapY) && (newMapY <= map->_offsetMapY + map->_height)) {
			*mapY = newMapY - map->_offsetMapY;
			*mapX = newMapX - map->_offsetMapX;
			return targetMapIndex;
		}
		map++;
	}
	return kDMMapIndexNone;
}

Thing DungeonMan::getSquareFirstObject(int16 mapX, int16 mapY) {
	Thing thing = getSquareFirstThing(mapX, mapY);
	while ((thing != _vm->_thingEndOfList) && (thing.getType() < kDMThingTypeGroup))
		thing = getNextThing(thing);

	return thing;
}

uint16 DungeonMan::getArmourDefense(ArmourInfo *armourInfo, bool useSharpDefense) {
	uint16 defense = armourInfo->_defense;
	if (useSharpDefense)
		defense = _vm->getScaledProduct(defense, 3, getFlag(armourInfo->_attributes, kDMArmourAttributeSharpDefense) + 4);

	return defense;
}

Thing DungeonMan::getDiscardThing(uint16 thingType) {
	// CHECKME: Shouldn't it be saved in the savegames?
	static unsigned char lastDiscardedThingMapIndex[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

	if (thingType == kDMThingTypeExplosion)
		return _vm->_thingNone;

	GroupMan &groupMan = *_vm->_groupMan;
	ProjExpl &projExpl = *_vm->_projexpl;

	int16 currentMapIdx = _currMapIndex;
	uint16 mapIndex = lastDiscardedThingMapIndex[thingType];
	if ((mapIndex == _partyMapIndex) && (++mapIndex >= _dungeonFileHeader._mapCount))
		mapIndex = 0;

	uint16 discardThingMapIndex = mapIndex;
	for (;;) { /*_Infinite loop_*/
		uint16 mapWidth = _dungeonMaps[mapIndex]._width;
		uint16 mapHeight = _dungeonMaps[mapIndex]._height;
		byte *currSquare = _dungeonMapData[mapIndex][0];
		Thing *squareFirstThing = &_squareFirstThings[_dungeonColumnsCumulativeSquareThingCount[_dungeonMapsFirstColumnIndex[mapIndex]]];

		for (int16 currMapX = 0; currMapX <= mapWidth; currMapX++) {
			for (int16 currMapY = 0; currMapY <= mapHeight; currMapY++) {
				if (getFlag(*currSquare++, kDMSquareMaskThingListPresent)) {
					Thing squareThing = *squareFirstThing++;
					if ((mapIndex == _partyMapIndex) && ((currMapX - _partyMapX + 5) <= 10) && ((currMapY - _partyMapY + 5) <= 10)) /* If square is too close to the party */
						continue;

					do {
						ThingType squareThingType = squareThing.getType();
						if (squareThingType == kDMThingTypeSensor) {
							Thing *squareThingData = (Thing *)getThingData(squareThing);
							if (((Sensor *)squareThingData)->getType()) /* If sensor is not disabled */
								break;
						} else if (squareThingType == thingType) {
							Thing *squareThingData = (Thing *)getThingData(squareThing);
							switch (thingType) {
							case kDMThingTypeGroup:
								if (((Group *)squareThingData)->getDoNotDiscard())
									continue;
								// fall through
							case kDMThingTypeProjectile:
								setCurrentMap(mapIndex);
								if (thingType == kDMThingTypeGroup) {
									groupMan.dropGroupPossessions(currMapX, currMapY, squareThing, kDMSoundModeDoNotPlaySound);
									groupMan.groupDelete(currMapX, currMapY);
								} else {
									projExpl.projectileDeleteEvent(squareThing);
									unlinkThingFromList(squareThing, Thing(0), currMapX, currMapY);
									projExpl.projectileDelete(squareThing, nullptr, currMapX, currMapY);
								}
								break;
							case kDMThingTypeArmour:
								if (((Armour *)squareThingData)->getDoNotDiscard())
									continue;

								setCurrentMap(mapIndex);
								_vm->_moveSens->getMoveResult(squareThing, currMapX, currMapY, kDMMapXNotOnASquare, 0);
								break;
							case kDMThingTypeWeapon:
								if (((Weapon *)squareThingData)->getDoNotDiscard())
									continue;

								setCurrentMap(mapIndex);
								_vm->_moveSens->getMoveResult(squareThing, currMapX, currMapY, kDMMapXNotOnASquare, 0);
								break;
							case kDMThingTypeJunk:
								if (((Junk *)squareThingData)->getDoNotDiscard())
									continue;

								setCurrentMap(mapIndex);
								_vm->_moveSens->getMoveResult(squareThing, currMapX, currMapY, kDMMapXNotOnASquare, 0);
								break;
							case kDMThingTypePotion:
								if (((Potion *)squareThingData)->getDoNotDiscard())
									continue;

								setCurrentMap(mapIndex);
								_vm->_moveSens->getMoveResult(squareThing, currMapX, currMapY, kDMMapXNotOnASquare, 0);
								break;
							default:
								break;
							}
							setCurrentMap(currentMapIdx);
							lastDiscardedThingMapIndex[thingType] = mapIndex;
							return Thing(squareThing.getTypeAndIndex());
						}
					} while ((squareThing = getNextThing(squareThing)) != _vm->_thingEndOfList);
				}
			}
		}
		if ((mapIndex == _partyMapIndex) || (_dungeonFileHeader._mapCount <= 1)) {
			lastDiscardedThingMapIndex[thingType] = mapIndex;
			return _vm->_thingNone;
		}

		do {
			if (++mapIndex >= _dungeonFileHeader._mapCount)
				mapIndex = 0;
		} while (mapIndex == _partyMapIndex);

		if (mapIndex == discardThingMapIndex)
			mapIndex = _partyMapIndex;
	}
}

uint16 DungeonMan::getCreatureAttributes(Thing thing) {
	Group *currGroup = (Group *)getThingData(thing);
	return _creatureInfos[currGroup->_type]._attributes;
}

void DungeonMan::setGroupCells(Group *group, uint16 cells, uint16 mapIndex) {
	if (mapIndex == _partyMapIndex)
		_vm->_groupMan->_activeGroups[group->getActiveGroupIndex()]._cells = cells;
	else
		group->_cells = cells;
}

void DungeonMan::setGroupDirections(Group *group, int16 dir, uint16 mapIndex) {
	if (mapIndex == _partyMapIndex)
		_vm->_groupMan->_activeGroups[group->getActiveGroupIndex()]._directions = (Direction)dir;
	else
		group->setDir(_vm->normalizeModulo4(dir));
}

bool DungeonMan::isCreatureAllowedOnMap(Thing thing, uint16 mapIndex) {
	CreatureType creatureType = ((Group *)getThingData(thing))->_type;
	Map *map = &_dungeonMaps[mapIndex];
	byte *allowedCreatureType = _dungeonMapData[mapIndex][map->_width] + map->_height + 1;
	for (int16 L0234_i_Counter = map->_creatureTypeCount; L0234_i_Counter > 0; L0234_i_Counter--) {
		if (*allowedCreatureType++ == creatureType)
			return true;
	}
	return false;
}

void DungeonMan::unlinkThingFromList(Thing thingToUnlink, Thing thingInList, int16 mapX, int16 mapY) {
	if (thingToUnlink == _vm->_thingEndOfList)
		return;

	uint16 tmp = thingToUnlink.toUint16();
	clearFlag(tmp, 0xC000);
	thingToUnlink = Thing(tmp);

	Thing *thingPtr = nullptr;
	if (mapX >= 0) {
		thingPtr = (Thing *)getThingData(thingToUnlink);
		uint16 firstThingIndex = getSquareFirstThingIndex(mapX, mapY);
		Thing *currThing = &_squareFirstThings[firstThingIndex]; /* BUG0_01 Coding error without consequence. The engine does not check that there are things at the specified square coordinates. f160_getSquareFirstThingIndex would return -1 for an empty square. No consequence as the function is never called with the coordinates of an empty square (except in the case of BUG0_59) */
		if ((*thingPtr == _vm->_thingEndOfList) && (((Thing *)currThing)->getTypeAndIndex() == thingToUnlink.toUint16())) { /* If the thing to unlink is the last thing on the square */
			clearFlag(_currMapData[mapX][mapY], kDMSquareMaskThingListPresent);
			uint16 squareFirstThingIdx = _dungeonFileHeader._squareFirstThingCount - 1;
			for (uint16 i = 0; i < squareFirstThingIdx - firstThingIndex; ++i)
				currThing[i] = currThing[i + 1];

			_squareFirstThings[squareFirstThingIdx] = _vm->_thingNone;
			uint16 *cumulativeFirstThingCount = _currMapColCumulativeSquareFirstThingCount + mapX + 1;
			uint16 currColumn = _dungeonColumCount - (_dungeonMapsFirstColumnIndex[_currMapIndex] + mapX) - 1;
			while (currColumn--) { /* For each column starting from and after the column containing the square where the thing is unlinked */
				(*cumulativeFirstThingCount++)--; /* Decrement the cumulative first thing count */
			}
			*thingPtr = _vm->_thingEndOfList;
			return;
		}
		if (((Thing *)currThing)->getTypeAndIndex() == thingToUnlink.toUint16()) {
			*currThing = *thingPtr;
			*thingPtr = _vm->_thingEndOfList;
			return;
		}
		thingInList = *currThing;
	}

	Thing currThing = getNextThing(thingInList);
	while (currThing.getTypeAndIndex() != thingToUnlink.toUint16()) {
		if ((currThing == _vm->_thingEndOfList) || (currThing == _vm->_thingNone)) {
			if (thingPtr)
				*thingPtr = _vm->_thingEndOfList;
			return;
		}
		currThing = getNextThing(thingInList = currThing);
	}
	thingPtr = (Thing *)getThingData(thingInList);
	*thingPtr = getNextThing(currThing);
	thingPtr = (Thing *)getThingData(thingToUnlink);
	*thingPtr = _vm->_thingEndOfList;
}

int16 DungeonMan::getStairsExitDirection(int16 mapX, int16 mapY) {
	bool northSouthOrientedStairs = !getFlag(getSquare(mapX, mapY).toByte(), kDMSquareMaskStairsNorthSouth);

	if (northSouthOrientedStairs) {
		mapX = mapX + _vm->_dirIntoStepCountEast[kDMDirEast];
		mapY = mapY + _vm->_dirIntoStepCountNorth[kDMDirEast];
	} else {
		mapX = mapX + _vm->_dirIntoStepCountEast[kDMDirNorth];
		mapY = mapY + _vm->_dirIntoStepCountNorth[kDMDirNorth];
	}
	int16 squareType = Square(getSquare(mapX, mapY)).getType();

	int16 retval = ((squareType == kDMElementTypeWall) || (squareType == kDMElementTypeStairs)) ? 1 : 0;
	retval <<= 1;
	retval += (northSouthOrientedStairs ? 1 : 0);

	return retval;
}

Thing DungeonMan::getObjForProjectileLaucherOrObjGen(uint16 iconIndex) {
	int16 thingType = kDMThingTypeWeapon;
	if ((iconIndex >= kDMIconIndiceWeaponTorchUnlit) && (iconIndex <= kDMIconIndiceWeaponTorchLit))
		iconIndex = kDMIconIndiceWeaponTorchUnlit;

	int16 junkType;

	switch (iconIndex) {
	case kDMIconIndiceWeaponRock:
		junkType = kDMWeaponRock;
		break;
	case kDMIconIndiceJunkBoulder:
		junkType = kDMJunkTypeBoulder;
		thingType = kDMThingTypeJunk;
		break;
	case kDMIconIndiceWeaponArrow:
		junkType = kDMWeaponArrow;
		break;
	case kDMIconIndiceWeaponSlayer:
		junkType = kDMWeaponSlayer;
		break;
	case kDMIconIndiceWeaponPoisonDart:
		junkType = kDMWeaponPoisonDart;
		break;
	case kDMIconIndiceWeaponThrowingStar:
		junkType = kDMWeaponThrowingStar;
		break;
	case kDMIconIndiceWeaponDagger:
		junkType = kDMWeaponDagger;
		break;
	case kDMIconIndiceWeaponTorchUnlit:
		junkType = kDMWeaponTorch;
		break;
	default:
		return _vm->_thingNone;
	}

	Thing unusedThing = getUnusedThing(thingType);
	if (unusedThing == _vm->_thingNone)
		return _vm->_thingNone;

	Junk *junkPtr = (Junk *)getThingData(unusedThing);
	junkPtr->setType(junkType); /* Also works for WEAPON in cases other than Boulder */
	if ((iconIndex == kDMIconIndiceWeaponTorchUnlit) && ((Weapon *)junkPtr)->isLit()) /* BUG0_65 Torches created by object generator or projectile launcher sensors have no charges. Charges are only defined if the Torch is lit which is not possible at the time it is created */
		((Weapon *)junkPtr)->setChargeCount(15);

	return unusedThing;
}

int16 DungeonMan::getRandomOrnamentIndex(uint16 val1, uint16 val2, int16 modulo) {
	// TODO: Use ScummVM random number generator
	return ((((((val1 * 31417) & 0xFFFF) >> 1) + ((val2 * 11) & 0xFFFF)
			  + _dungeonFileHeader._ornamentRandomSeed) & 0xFFFF) >> 2) % modulo; /* Pseudorandom number generator */
}

}
