2020-02-11 07:29:55 +00:00
|
|
|
package com.bytezone.diskbrowser.wizardry;
|
|
|
|
|
|
|
|
import java.awt.Dimension;
|
|
|
|
import java.awt.Graphics2D;
|
|
|
|
import java.awt.RenderingHints;
|
|
|
|
import java.awt.image.BufferedImage;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.List;
|
|
|
|
|
|
|
|
import com.bytezone.diskbrowser.applefile.AbstractFile;
|
|
|
|
import com.bytezone.diskbrowser.utilities.HexFormatter;
|
2020-06-26 03:29:46 +00:00
|
|
|
import com.bytezone.diskbrowser.utilities.Utility;
|
2020-02-11 07:29:55 +00:00
|
|
|
|
|
|
|
// -----------------------------------------------------------------------------------//
|
|
|
|
class MazeLevel extends AbstractFile
|
|
|
|
// -----------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
public final int level;
|
|
|
|
private List<Message> messages;
|
|
|
|
private List<Monster> monsters;
|
|
|
|
private List<Item> items;
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public MazeLevel (byte[] buffer, int level)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
super ("Level " + level, buffer);
|
|
|
|
this.level = level;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public String getHexDump ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
StringBuilder text = new StringBuilder ();
|
|
|
|
|
|
|
|
text.append ("West walls/doors\n\n");
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append (HexFormatter.format (buffer, 0, 120, true, 0));
|
2020-02-11 07:29:55 +00:00
|
|
|
addWalls (text, 0);
|
|
|
|
|
|
|
|
text.append ("\nSouth walls/doors\n\n");
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append (HexFormatter.format (buffer, 120, 120, true, 120));
|
2020-02-11 07:29:55 +00:00
|
|
|
addWalls (text, 120);
|
|
|
|
|
|
|
|
text.append ("\nEast walls/doors\n\n");
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append (HexFormatter.format (buffer, 240, 120, true, 240));
|
2020-02-11 07:29:55 +00:00
|
|
|
addWalls (text, 240);
|
|
|
|
|
|
|
|
text.append ("\nNorth walls/doors\n\n");
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append (HexFormatter.format (buffer, 360, 120, true, 360));
|
2020-02-11 07:29:55 +00:00
|
|
|
addWalls (text, 360);
|
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append ("\nEncounters (FIGHTS)\n\n");
|
|
|
|
text.append (HexFormatter.format (buffer, 480, 80, true, 480));
|
2020-02-11 07:29:55 +00:00
|
|
|
addEncounters (text, 480);
|
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append ("\nExtras (SQREXTRA)\n\n");
|
|
|
|
text.append (HexFormatter.format (buffer, 560, 200, true, 560));
|
2020-02-11 07:29:55 +00:00
|
|
|
addExtras (text, 560);
|
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append ("\nIndex (SQRTYPE)\n\n");
|
|
|
|
text.append (String.format ("%04X: %s%n", 760, HexFormatter.getHexString (buffer, 760, 8)));
|
2020-02-11 07:29:55 +00:00
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append ("\nAUX0\n\n");
|
|
|
|
text.append (HexFormatter.format (buffer, 768, 32, true, 768));
|
|
|
|
text.append ("\n");
|
|
|
|
|
|
|
|
text.append ("\nAUX1\n\n");
|
|
|
|
text.append (HexFormatter.format (buffer, 800, 32, true, 800));
|
|
|
|
text.append ("\n");
|
|
|
|
|
|
|
|
text.append ("\nAUX2\n\n");
|
|
|
|
text.append (HexFormatter.format (buffer, 832, 32, true, 832));
|
|
|
|
text.append ("\n");
|
2020-02-11 07:29:55 +00:00
|
|
|
|
|
|
|
text.append ("\n\n 0 1 2 3 4 5 6 7 8 9 A B C D E F\n");
|
|
|
|
text.append (String.format ("%04X: ", 760));
|
|
|
|
for (int i = 0; i < 8; i++)
|
|
|
|
{
|
|
|
|
int val = buffer[760 + i] & 0xFF;
|
|
|
|
text.append (String.format ("%X:%X ", val % 16, val / 16));
|
|
|
|
}
|
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
String[] squareType = { "Normal", "Stairs", "Pit", "Chute", "Spinner", "Darkness", "Teleport",
|
|
|
|
"Ouch", "Elevator", "Rock/Water", "Fizzle", "Message/Item", "Monster" };
|
2020-02-11 07:29:55 +00:00
|
|
|
|
|
|
|
List<MazeAddress> messageList = new ArrayList<> ();
|
|
|
|
List<MazeAddress> monsterList = new ArrayList<> ();
|
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append ("\n\nSQREXTRA SQRTYPE TSQUARE AUX0 AUX1 AUX2\n");
|
2020-02-11 07:29:55 +00:00
|
|
|
for (int j = 0; j < 16; j++)
|
|
|
|
{
|
|
|
|
String extraText = "";
|
|
|
|
int val = buffer[760 + j / 2] & 0xFF;
|
2022-03-10 06:21:18 +00:00
|
|
|
String extra = (j % 2) == 0 ? squareType[val % 16] : squareType[val / 16];
|
|
|
|
|
2020-02-11 07:29:55 +00:00
|
|
|
MazeAddress address = getAddress (j);
|
|
|
|
int cellFlag = (j % 2) == 0 ? val % 16 : val / 16;
|
|
|
|
if (cellFlag == 11)
|
|
|
|
{
|
|
|
|
extraText = "Msg:" + String.format ("%04X ", address.row);
|
|
|
|
messageList.add (address); // to print at the end
|
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
int messageType = address.column; // AUX3
|
2020-02-11 07:29:55 +00:00
|
|
|
if (messageType == 2)
|
|
|
|
{
|
|
|
|
extraText += "Obtained: ";
|
|
|
|
if (items != null)
|
|
|
|
extraText += items.get (address.level).getName ();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (messageType == 5)
|
|
|
|
{
|
|
|
|
extraText += "Requires: ";
|
|
|
|
if (items != null)
|
|
|
|
extraText += items.get (address.level).getName ();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (messageType == 4)
|
|
|
|
{
|
2022-03-10 06:21:18 +00:00
|
|
|
if (address.level < monsters.size ())
|
|
|
|
extraText += monsters.get (address.level).realName;
|
|
|
|
else
|
|
|
|
extraText += "Obtained: " + items.get ((address.level - 64536) * -1).getName ();
|
2020-02-11 07:29:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cellFlag == 12)
|
|
|
|
{
|
|
|
|
monsterList.add (address);
|
|
|
|
extraText = "Encounter: ";
|
|
|
|
if (monsters != null)
|
|
|
|
extraText += monsters.get (address.column).realName;
|
|
|
|
}
|
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append (String.format (" %X --> %X %-15s %04X %04X %04X %s%n", j,
|
2020-02-11 07:29:55 +00:00
|
|
|
cellFlag, extra, address.level, address.row, address.column, extraText));
|
|
|
|
}
|
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append ("\n\nRest (ENMYCALC)\n\n");
|
|
|
|
text.append (HexFormatter.format (buffer, 864, buffer.length - 864, true, 864));
|
|
|
|
addEnmyCalc (text, 864);
|
2020-02-11 07:29:55 +00:00
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append ("\n\n");
|
2020-02-11 07:29:55 +00:00
|
|
|
for (MazeAddress address : messageList)
|
|
|
|
{
|
|
|
|
Message message = getMessage (address.row);
|
|
|
|
if (message != null)
|
|
|
|
{
|
|
|
|
text.append (String.format ("%nMessage: %04X (%d)%n", address.row, address.row));
|
|
|
|
text.append (message.getText ());
|
|
|
|
text.append ("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (MazeAddress address : monsterList)
|
|
|
|
{
|
|
|
|
Monster monster = getMonster (address.column);
|
|
|
|
if (monster != null)
|
|
|
|
{
|
|
|
|
text.append (String.format ("%nMonster: %04X%n", address.column));
|
|
|
|
text.append (monster.getText ());
|
|
|
|
text.append ("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return text.toString ();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
private void addWalls (StringBuilder text, int ptr)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
text.append ("\n\n");
|
2022-03-10 06:21:18 +00:00
|
|
|
|
|
|
|
for (int col = 0; col < 20; col++)
|
|
|
|
{
|
|
|
|
text.append (String.format ("Col %2d : %s : ", col,
|
|
|
|
HexFormatter.getHexString (buffer, ptr + col * 6, 6)));
|
|
|
|
|
|
|
|
for (int i = 0; i < 5; i++)
|
|
|
|
{
|
|
|
|
int val = buffer[ptr++] & 0xFF;
|
|
|
|
for (int j = 0; j < 4; j++)
|
|
|
|
{
|
|
|
|
int wall = (val & 0x03); // right to left ordering
|
|
|
|
text.append (String.format ("%d ", wall));
|
|
|
|
val >>>= 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert buffer[ptr] == 0;
|
|
|
|
ptr++; // skip last byte
|
|
|
|
text.append ("\n");
|
|
|
|
}
|
2020-02-11 07:29:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
private void addEncounters (StringBuilder text, int ptr)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
text.append ("\n\n");
|
|
|
|
for (int i = 0; i < 20; i++)
|
|
|
|
{
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append (
|
|
|
|
String.format (" Col %2d: %s ", i, HexFormatter.getHexString (buffer, ptr + i * 4, 4)));
|
|
|
|
int val = Utility.readTriple (buffer, ptr + i * 4);
|
|
|
|
for (int j = 0; j < 20; j++)
|
2020-02-11 07:29:55 +00:00
|
|
|
{
|
2022-03-10 06:21:18 +00:00
|
|
|
text.append ((val & 0x01) == 0 ? " " : " 1");
|
|
|
|
val >>>= 1;
|
2020-02-11 07:29:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
text.append ("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
private void addExtras (StringBuilder text, int ptr)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
text.append ("\n\n");
|
|
|
|
for (int i = 0; i < 20; i++)
|
|
|
|
{
|
|
|
|
text.append (String.format (" Col %2d: ", i));
|
|
|
|
for (int j = 0; j < 10; j++)
|
|
|
|
{
|
2022-03-10 06:21:18 +00:00
|
|
|
int val = buffer[ptr++] & 0xFF;
|
|
|
|
text.append (String.format ("%X %X ", (val & 0x0F), (val & 0xF0) >> 4));
|
2020-02-11 07:29:55 +00:00
|
|
|
}
|
|
|
|
text.append ("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-10 06:21:18 +00:00
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
private void addEnmyCalc (StringBuilder text, int ptr)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
text.append ("\n\n");
|
|
|
|
|
|
|
|
text.append (String.format ("MINENEMY %04X %04X %04X%n", Utility.getShort (buffer, ptr),
|
|
|
|
Utility.getShort (buffer, ptr + 10), Utility.getShort (buffer, ptr + 20)));
|
|
|
|
ptr += 2;
|
|
|
|
text.append (String.format ("MULTWORS %04X %04X %04X%n", Utility.getShort (buffer, ptr),
|
|
|
|
Utility.getShort (buffer, ptr + 10), Utility.getShort (buffer, ptr + 20)));
|
|
|
|
ptr += 2;
|
|
|
|
text.append (String.format ("WORSE01 %04X %04X %04X%n", Utility.getShort (buffer, ptr),
|
|
|
|
Utility.getShort (buffer, ptr + 10), Utility.getShort (buffer, ptr + 20)));
|
|
|
|
ptr += 2;
|
|
|
|
text.append (String.format ("RANGE0N %04X %04X %04X%n", Utility.getShort (buffer, ptr),
|
|
|
|
Utility.getShort (buffer, ptr + 10), Utility.getShort (buffer, ptr + 20)));
|
|
|
|
ptr += 2;
|
|
|
|
text.append (String.format ("PERCWORS %04X %04X %04X%n", Utility.getShort (buffer, ptr),
|
|
|
|
Utility.getShort (buffer, ptr + 10), Utility.getShort (buffer, ptr + 20)));
|
|
|
|
}
|
|
|
|
|
2020-02-11 07:29:55 +00:00
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
@Override
|
|
|
|
public BufferedImage getImage ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
Dimension cellSize = new Dimension (22, 22);
|
|
|
|
image = new BufferedImage (20 * cellSize.width + 1, 20 * cellSize.height + 1,
|
|
|
|
BufferedImage.TYPE_USHORT_555_RGB);
|
|
|
|
Graphics2D g = image.createGraphics ();
|
2022-03-10 06:21:18 +00:00
|
|
|
g.setRenderingHint (RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
|
2020-02-11 07:29:55 +00:00
|
|
|
|
|
|
|
for (int row = 0; row < 20; row++)
|
|
|
|
for (int column = 0; column < 20; column++)
|
|
|
|
{
|
|
|
|
MazeCell cell = getLocation (row, column);
|
|
|
|
int x = column * cellSize.width;
|
|
|
|
int y = image.getHeight () - (row + 1) * cellSize.height - 1;
|
|
|
|
cell.draw (g, x, y);
|
|
|
|
}
|
|
|
|
return image;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public void setMessages (List<Message> messages)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
this.messages = messages;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public void setMonsters (List<Monster> monsters)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
this.monsters = monsters;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public void setItems (List<Item> items)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
this.items = items;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public MazeCell getLocation (int row, int column)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
MazeAddress address = new MazeAddress (level, row, column);
|
|
|
|
MazeCell cell = new MazeCell (address);
|
|
|
|
|
|
|
|
// doors and walls
|
|
|
|
int BYTES_PER_COL = 6; // 20 / 4 = 5 bytes + 1 wasted
|
|
|
|
int CELLS_PER_BYTE = 4; // 2 bits each
|
|
|
|
int BITS_PER_ROW = 2;
|
|
|
|
|
|
|
|
int offset = column * BYTES_PER_COL + row / CELLS_PER_BYTE;
|
|
|
|
|
|
|
|
int value = buffer[offset] & 0xFF;
|
|
|
|
value >>>= (row % CELLS_PER_BYTE) * BITS_PER_ROW; // push 0, 2, 4, 6 bits
|
|
|
|
cell.westWall = ((value & 1) == 1); // use rightmost bit
|
|
|
|
value >>>= 1; // push 1 bit
|
|
|
|
cell.westDoor = ((value & 1) == 1); // use rightmost bit
|
|
|
|
|
|
|
|
value = buffer[offset + 120] & 0xFF;
|
|
|
|
value >>>= (row % CELLS_PER_BYTE) * BITS_PER_ROW;
|
|
|
|
cell.southWall = ((value & 1) == 1);
|
|
|
|
value >>>= 1;
|
|
|
|
cell.southDoor = ((value & 1) == 1);
|
|
|
|
|
|
|
|
value = buffer[offset + 240] & 0xFF;
|
|
|
|
value >>>= (row % CELLS_PER_BYTE) * BITS_PER_ROW;
|
|
|
|
cell.eastWall = ((value & 1) == 1);
|
|
|
|
value >>>= 1;
|
|
|
|
cell.eastDoor = ((value & 1) == 1);
|
|
|
|
|
|
|
|
value = buffer[offset + 360] & 0xFF;
|
|
|
|
value >>>= (row % CELLS_PER_BYTE) * BITS_PER_ROW;
|
|
|
|
cell.northWall = ((value & 1) == 1);
|
|
|
|
value >>>= 1;
|
|
|
|
cell.northDoor = ((value & 1) == 1);
|
|
|
|
|
|
|
|
// monster table
|
|
|
|
BYTES_PER_COL = 4; // 3 bytes + 1 wasted
|
|
|
|
CELLS_PER_BYTE = 8; // 1 bit each
|
|
|
|
BITS_PER_ROW = 1;
|
|
|
|
|
|
|
|
offset = column * BYTES_PER_COL + row / CELLS_PER_BYTE; // 4 bytes/column, 1 bit/row
|
|
|
|
value = buffer[offset + 480] & 0xFF;
|
|
|
|
value >>>= row % 8;
|
|
|
|
cell.monsterLair = ((value & 1) == 1);
|
|
|
|
|
|
|
|
// square extra
|
|
|
|
|
|
|
|
offset = column * 10 + row / 2; // 10 bytes/column, 4 bits/row
|
|
|
|
value = buffer[offset + 560] & 0xFF;
|
|
|
|
int b = (row % 2 == 0) ? value % 16 : value / 16; // 0:F
|
|
|
|
|
|
|
|
int c = buffer[760 + b / 2] & 0xFF; // 760:767
|
|
|
|
int cellFlag = (b % 2 == 0) ? c % 16 : c / 16;
|
|
|
|
|
|
|
|
switch (cellFlag)
|
|
|
|
{
|
|
|
|
case 0: // normal
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
cell.stairs = true;
|
|
|
|
cell.addressTo = getAddress (b);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
cell.pit = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
cell.chute = true;
|
|
|
|
cell.addressTo = getAddress (b);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
cell.spinner = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 5:
|
|
|
|
cell.darkness = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 6:
|
|
|
|
cell.teleport = true;
|
|
|
|
cell.addressTo = getAddress (b);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 7: // ouchy
|
|
|
|
cell.unknown = cellFlag;
|
|
|
|
break;
|
|
|
|
|
2020-12-18 01:00:37 +00:00
|
|
|
case 8: // buttonz
|
2020-02-11 07:29:55 +00:00
|
|
|
cell.elevator = true;
|
|
|
|
MazeAddress elevatorAddress = getAddress (b);
|
|
|
|
cell.elevatorTo = elevatorAddress.row;
|
|
|
|
// HexFormatter.intValue (buffer[800 + b * 2], buffer[801 + b * 2]);
|
|
|
|
cell.elevatorFrom = elevatorAddress.column;
|
|
|
|
// HexFormatter.intValue (buffer[832 + b * 2], buffer[833 + b * 2]);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 9: // rock/water
|
|
|
|
cell.rock = true;
|
|
|
|
break;
|
|
|
|
|
2020-12-18 01:00:37 +00:00
|
|
|
case 10: // fizzle
|
2020-02-11 07:29:55 +00:00
|
|
|
cell.spellsBlocked = true;
|
|
|
|
break;
|
|
|
|
|
2020-12-18 01:00:37 +00:00
|
|
|
case 11: // screen message
|
2020-02-11 07:29:55 +00:00
|
|
|
MazeAddress messageAddress = getAddress (b);
|
2020-12-18 01:00:37 +00:00
|
|
|
// int messageNum = HexFormatter.intValue (buffer[800 + b * 2], buffer[801 + b * 2]);
|
2020-02-11 07:29:55 +00:00
|
|
|
|
|
|
|
Message m = getMessage (messageAddress.row);
|
|
|
|
if (m != null)
|
|
|
|
cell.message = m;
|
|
|
|
|
|
|
|
cell.messageType = messageAddress.column;
|
2020-12-18 01:00:37 +00:00
|
|
|
// HexFormatter.intValue (buffer[832 + b * 2], buffer[833 + b * 2]);
|
2020-02-11 07:29:55 +00:00
|
|
|
|
|
|
|
int itemID = -1;
|
|
|
|
|
|
|
|
if (cell.messageType == 2 && items != null) // obtain Item
|
|
|
|
{
|
2020-12-18 01:00:37 +00:00
|
|
|
// itemID = HexFormatter.intValue (buffer[768 + b * 2], buffer[769 + b * 2]);
|
2020-02-11 07:29:55 +00:00
|
|
|
itemID = messageAddress.level;
|
|
|
|
cell.itemObtained = items.get (itemID);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cell.messageType == 5 && items != null) // requires Item
|
|
|
|
{
|
2020-12-18 01:00:37 +00:00
|
|
|
// itemID = HexFormatter.intValue (buffer[768 + b * 2], buffer[769 + b * 2]);
|
2020-02-11 07:29:55 +00:00
|
|
|
itemID = messageAddress.level;
|
|
|
|
cell.itemRequired = items.get (itemID);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cell.messageType == 4)
|
|
|
|
{
|
2020-12-18 01:00:37 +00:00
|
|
|
// value = HexFormatter.intValue (buffer[768 + b * 2], buffer[769 + b * 2]);
|
2020-02-11 07:29:55 +00:00
|
|
|
itemID = messageAddress.level;
|
|
|
|
if (value <= 100)
|
|
|
|
{
|
|
|
|
cell.monsterID = value;
|
|
|
|
cell.monsters = monsters;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int val = (value - 64536) * -1;
|
|
|
|
System.out.println ("Value : " + val);
|
|
|
|
// this gives Index error: 20410, Size 104 in Wizardry_III/legacy2.dsk
|
|
|
|
if (items != null && val < items.size ())
|
|
|
|
cell.itemObtained = items.get (val); // check this
|
|
|
|
if (cell.itemObtained == null)
|
|
|
|
System.out.printf ("Item %d not found%n", val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2020-12-18 01:00:37 +00:00
|
|
|
case 12: // encounter
|
2020-02-11 07:29:55 +00:00
|
|
|
MazeAddress monsterAddress = getAddress (b);
|
2020-12-18 01:00:37 +00:00
|
|
|
// cell.monsterID = HexFormatter.intValue (buffer[832 + b * 2], buffer[833 + b * 2]);
|
2020-02-11 07:29:55 +00:00
|
|
|
cell.monsterID = monsterAddress.column;
|
|
|
|
cell.monsters = monsters;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
System.out.println ("Unknown extra: " + cellFlag);
|
|
|
|
cell.unknown = cellFlag;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cell;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
private MazeAddress getAddress (int b) // 0:F
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
int x = b * 2;
|
2022-03-10 06:21:18 +00:00
|
|
|
return new MazeAddress (Utility.getShort (buffer, 768 + x), Utility.getShort (buffer, 800 + x),
|
|
|
|
Utility.getShort (buffer, 832 + x));
|
2020-02-11 07:29:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
private Message getMessage (int messageNo)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
if (messages == null)
|
|
|
|
return null;
|
|
|
|
|
|
|
|
for (Message m : messages)
|
|
|
|
if (m.match (messageNo))
|
|
|
|
return m;
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
private Monster getMonster (int monsterNo)
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
if (monsters == null)
|
|
|
|
return null;
|
|
|
|
|
|
|
|
for (Monster m : monsters)
|
|
|
|
if (m.match (monsterNo))
|
|
|
|
return m;
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public int getRows ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
return 20;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
public int getColumns ()
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
|
|
{
|
|
|
|
return 20;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Pascal code decompiled by Tom Ewers
|
|
|
|
*
|
|
|
|
* TWALL = (OPEN, WALL, DOOR, HIDEDOOR);
|
|
|
|
|
|
|
|
TSQUARE = (NORMAL, STAIRS, PIT, CHUTE, SPINNER, DARK, TRANSFER,
|
|
|
|
OUCHY, BUTTONZ, ROCKWATE, FIZZLE, SCNMSG, ENCOUNTE);
|
|
|
|
|
|
|
|
TMAZE = RECORD
|
|
|
|
W : PACKED ARRAY[ 0..19] OF PACKED ARRAY[ 0..19] OF TWALL;
|
|
|
|
S : PACKED ARRAY[ 0..19] OF PACKED ARRAY[ 0..19] OF TWALL;
|
|
|
|
E : PACKED ARRAY[ 0..19] OF PACKED ARRAY[ 0..19] OF TWALL;
|
|
|
|
N : PACKED ARRAY[ 0..19] OF PACKED ARRAY[ 0..19] OF TWALL;
|
|
|
|
|
|
|
|
FIGHTS : PACKED ARRAY[ 0..19] OF PACKED ARRAY[ 0..19] OF 0..1;
|
|
|
|
|
|
|
|
SQREXTRA : PACKED ARRAY[ 0..19] OF PACKED ARRAY[ 0..19] OF 0..15;
|
|
|
|
|
|
|
|
SQRETYPE : PACKED ARRAY[ 0..15] OF TSQUARE;
|
|
|
|
|
|
|
|
AUX0 : PACKED ARRAY[ 0..15] OF INTEGER;
|
|
|
|
AUX1 : PACKED ARRAY[ 0..15] OF INTEGER;
|
|
|
|
AUX2 : PACKED ARRAY[ 0..15] OF INTEGER;
|
|
|
|
|
|
|
|
ENMYCALC : PACKED ARRAY[ 1..3] OF RECORD
|
|
|
|
MINENEMY : INTEGER;
|
|
|
|
MULTWORS : INTEGER;
|
|
|
|
WORSE01 : INTEGER;
|
|
|
|
RANGE0N : INTEGER;
|
|
|
|
PERCWORS : INTEGER;
|
|
|
|
END;
|
|
|
|
END;
|
|
|
|
*/
|
2015-06-01 09:35:51 +00:00
|
|
|
}
|