/// <summary>
/// Construction a conversation
/// </summary>
/// <param name="npc">NPC you will have a conversation with</param>
/// <param name="state">The games current State</param>
/// <param name="dataOvlRef">Data.OVL for reference</param>
public Conversation(NonPlayerCharacterReference npc, GameState state, DataOvlReference dataOvlRef)
{
this.Npc = npc;
script = npc.Script;
this.gameStateRef = state;
this.dataOvlRef = dataOvlRef;
}
/// <summary>
/// Build the talk scripts
/// </summary>
/// <param name="u5Directory">Directory with Ultima 5 data files</param>
/// <param name="dataRef">DataOVL Reference provides compressed word details</param>
public TalkScripts(string u5Directory, DataOvlReference dataRef)
{
// save the compressed words, we're gonna need them
this.compressedWordRef = new CompressedWordReference(dataRef);
// just a lazy array that is easier to enumerate than the enum
SmallMapReferences.SingleMapReference.SmallMapMasterFiles[] smallMapRefs =
{
SmallMapReferences.SingleMapReference.SmallMapMasterFiles.Castle,
SmallMapReferences.SingleMapReference.SmallMapMasterFiles.Towne,
SmallMapReferences.SingleMapReference.SmallMapMasterFiles.Keep,
SmallMapReferences.SingleMapReference.SmallMapMasterFiles.Dwelling
};
// for each of the maps we are going to initialize
foreach (SmallMapReferences.SingleMapReference.SmallMapMasterFiles mapRef in smallMapRefs)
{
// initialize the raw component of the talk scripts
InitalizeTalkScriptsRaw(u5Directory, mapRef);
// initialize and allocate the appropriately sized list of TalkScript(s)
talkScriptRefs.Add(mapRef, new Dictionary <int, TalkScript>(talkRefs[mapRef].Count));
// for each of the NPCs in the particular map, initialize the individual NPC talk script
foreach (int key in talkRefs[mapRef].Keys)
{
talkScriptRefs[mapRef][key] = InitializeTalkScriptFromRaw(mapRef, key);
if (isDebug)
{
Console.WriteLine("TalkScript in " + mapRef.ToString() + " with #" + key.ToString());
}
}
}
}
/// <summary>
/// Construct a single map reference
/// </summary>
/// <param name="mapLocation">overall location (ie. Moonglow)</param>
/// <param name="floor">the floor in the location (-1 basement, 0 main level, 1+ upstairs)</param>
/// <param name="fileOffset">location of data offset in map file</param>
public SingleMapReference(Location mapLocation, int floor, int fileOffset, DataOvlReference dataRef)
{
MapLocation = mapLocation;
Floor = floor;
FileOffset = fileOffset;
DataRef = dataRef;
}
public U5StringRef(DataOvlReference dataRef)
{
this.dataRef = dataRef;
strMap = new Dictionary <Type, SomeStrings>();
SomeStrings strs = dataRef.GetDataChunk(DataOvlReference.DataChunkName.TRAVEL).GetChunkAsStringList();
strMap.Add(typeof(DataOvlReference.CHUNK__PHRASES_CONVERSATION), dataRef.GetDataChunk(DataOvlReference.DataChunkName.PHRASES_CONVERSATION).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.TRAVEL_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.TRAVEL).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.LOCATION_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.LOCATION_NAMES).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.WORLD_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.WORLD).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.CHIT_CHAT_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.CHIT_CHAT).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.KEYPRESS_COMMANDS_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.KEYPRESS_COMMANDS).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.VISION1_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.VISION1).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.VISION2_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.VISION2).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.OPENING_THINGS_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.OPENING_THINGS_STUFF).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.KLIMBING_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.KLIMBING).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.GET_THINGS_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.GET_THINGS).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.SPECIAL_ITEM_NAMES_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.SPECIAL_ITEM_NAMES).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.WEAR_USE_ITEM_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.WEAR_USE_ITEM).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.SHARDS_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.SHARDS).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.SHADOWLORD_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.SHADOWLORD).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.POTIONS_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.POTIONS).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.SPELL_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.SPELLS).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.SPECIAL_ITEM_NAMES2).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.LONG_ARMOUR_STRING), dataRef.GetDataChunk(DataOvlReference.DataChunkName.LONG_ARMOUR).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.SHORT_ARMOUR_STRING), dataRef.GetDataChunk(DataOvlReference.DataChunkName.SHORT_ARMOUR).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.EQUIPPING_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.EQUIPPING).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.ZSTATS_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.ZSTATS).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.SLEEP_TRANSPORT_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.SLEEP_TRANSPORT).GetChunkAsStringList());
strMap.Add(typeof(DataOvlReference.REAGENT_STRINGS), dataRef.GetDataChunk(DataOvlReference.DataChunkName.REAGENTS).GetChunkAsStringList());
}
/// <summary>
/// Construct all small map references
/// </summary>
public SmallMapReferences(DataOvlReference dataRef)
{
// I wish I could do this a smarter way, but as of now I have no idea where this data is stored in any of the data files
this.dataRef = dataRef;
InitializeLocationNames();
// Castle.dat
AddLocation(SingleMapReference.Location.Lord_Britishs_Castle, true, 5);
AddLocation(SingleMapReference.Location.Palace_of_Blackthorn, true, 5);
AddLocation(SingleMapReference.Location.West_Britanny, false, 1);
AddLocation(SingleMapReference.Location.North_Britanny, false, 1);
AddLocation(SingleMapReference.Location.East_Britanny, false, 1);
AddLocation(SingleMapReference.Location.Paws, false, 1);
AddLocation(SingleMapReference.Location.Cove, false, 1);
AddLocation(SingleMapReference.Location.Buccaneers_Den, false, 1);
// Towne.dat
AddLocation(SingleMapReference.Location.Moonglow, false, 2);
AddLocation(SingleMapReference.Location.Britain, false, 2);
AddLocation(SingleMapReference.Location.Jhelom, false, 2);
AddLocation(SingleMapReference.Location.Yew, true, 2);
AddLocation(SingleMapReference.Location.Minoc, false, 2);
AddLocation(SingleMapReference.Location.Trinsic, false, 2);
AddLocation(SingleMapReference.Location.Skara_Brae, false, 2);
AddLocation(SingleMapReference.Location.New_Magincia, false, 2);
// Dwelling.dat
AddLocation(SingleMapReference.Location.Fogsbane, false, 3);
AddLocation(SingleMapReference.Location.Stormcrow, false, 3);
AddLocation(SingleMapReference.Location.Greyhaven, false, 3);
AddLocation(SingleMapReference.Location.Waveguide, false, 3);
AddLocation(SingleMapReference.Location.Iolos_Hut, false, 1);
AddLocation(SingleMapReference.Location.Suteks_Hut, false, 1);
AddLocation(SingleMapReference.Location.SinVraals_Hut, false, 1);
AddLocation(SingleMapReference.Location.Grendels_Hut, false, 1);
// Keep.dat
AddLocation(SingleMapReference.Location.Ararat, false, 2);
AddLocation(SingleMapReference.Location.Bordermarch, false, 2);
AddLocation(SingleMapReference.Location.Farthing, false, 1);
AddLocation(SingleMapReference.Location.Windemere, false, 1);
AddLocation(SingleMapReference.Location.Stonegate, false, 1);
AddLocation(SingleMapReference.Location.Lycaeum, false, 3);
AddLocation(SingleMapReference.Location.Empath_Abbey, false, 3);
AddLocation(SingleMapReference.Location.Serpents_Hold, true, 3);
AddLocation(SingleMapReference.Location.Deceit, false, 0);
AddLocation(SingleMapReference.Location.Despise, false, 0);
AddLocation(SingleMapReference.Location.Destard, false, 0);
AddLocation(SingleMapReference.Location.Wrong, false, 0);
AddLocation(SingleMapReference.Location.Covetous, false, 0);
AddLocation(SingleMapReference.Location.Shame, false, 0);
AddLocation(SingleMapReference.Location.Hythloth, false, 0);
AddLocation(SingleMapReference.Location.Doom, false, 0);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="ultima5Directory">ultima 5 data and save game directory</param>
public World(string ultima5Directory) : base()
{
_u5Directory = ultima5Directory;
DataOvlRef = new DataOvlReference(_u5Directory);
SmallMapRef = new SmallMapReferences(DataOvlRef);
// build the overworld map
OverworldMap = new LargeMap(_u5Directory, LargeMap.Maps.Overworld, _tileOverrides);
// build the underworld map
UnderworldMap = new LargeMap(_u5Directory, LargeMap.Maps.Underworld, _tileOverrides);
SpriteTileReferences = new TileReferences(DataOvlRef.StringReferences);
InvRef = new InventoryReferences();
LargeMapRef = new LargeMapLocationReferences(DataOvlRef);
AllSmallMaps = new SmallMaps(SmallMapRef, _u5Directory, SpriteTileReferences, _tileOverrides);
MoonPhaseRefs = new MoonPhaseReferences(DataOvlRef);
State = new GameState(_u5Directory, DataOvlRef);
// build all combat maps from the Combat Map References
foreach (CombatMapReference.SingleCombatMapReference combatMapRef in _combatMapRef.MapReferenceList)
{
CombatMap combatMap = new CombatMap(_u5Directory, combatMapRef, _tileOverrides);
}
// build a "look" table for all tiles
LookRef = new Look(_u5Directory);
// build the sign tables
SignRef = new Signs(_u5Directory);
TalkScriptsRef = new TalkScripts(_u5Directory, DataOvlRef);
// build the NPC tables
NpcRef = new NonPlayerCharacterReferences(_u5Directory, SmallMapRef, TalkScriptsRef, State);
ShoppeKeeperDialogueReference = new ShoppeKeeperDialogueReference(_u5Directory, DataOvlRef, NpcRef, State.PlayerInventory);
// sadly I have to initialize this after the NPCs are created because there is a circular dependency
State.InitializeVirtualMap(SmallMapRef, AllSmallMaps, LargeMapRef, OverworldMap, UnderworldMap, NpcRef, SpriteTileReferences, State, NpcRef, InvRef);
if (State.Location != SmallMapReferences.SingleMapReference.Location.Britannia_Underworld)
{
State.TheVirtualMap.LoadSmallMap(SmallMapRef.GetSingleMapByLocation(State.Location, State.Floor), State.CharacterRecords, true);
}
else
{
State.TheVirtualMap.LoadLargeMap(LargeMap.Maps.Overworld);
}
}
public Spells(DataOvlReference dataOvlRef, List <byte> gameStateByteArray) : base(dataOvlRef, gameStateByteArray)
{
int nIndex = 0;
foreach (Spell.SpellWords spell in Enum.GetValues(typeof(Spell.SpellWords)))
{
AddSpell(spell, (DataOvlReference.SPELL_STRINGS)nIndex++);
}
}
//public CombatItem(int quantity, string longName, string shortName, int nSpriteNum, int attackStat, int defendStat, DataOvlReference.EQUIPMENT specificEquipment)
// : base(quantity, longName, shortName, nSpriteNum)
//{
// attackStat = AttackStat;
// defendStat = DefendStat;
// this.SpecificEquipment = specificEquipment;
//}
// ChestArmours.Add(new ChestArmour(chestArmour, gameStateByteArray[(int)chestArmour],
//equipmentNames[(int)equipment], equipmentNames[(int)equipment],
// CombatItem.GetAttack(dataOvlRef, (int) equipment),
// CombatItem.GetDefense(dataOvlRef, (int) equipment),equipment));
// CombatItem.GetAttack(dataOvlRef, (int)specificEquipment), CombatItem.GetDefense(dataOvlRef, (int)specificEquipment)
public CombatItem(DataOvlReference.EQUIPMENT specificEquipment, DataOvlReference dataOvlRef, List <byte> gameStateRef, int nOffset, int nSpriteNum)
: base(gameStateRef[nOffset], CombatItem.GetEquipmentString(dataOvlRef, (int)specificEquipment),
CombatItem.GetEquipmentString(dataOvlRef, (int)specificEquipment), nSpriteNum)
{
AttackStat = GetAttack(dataOvlRef, (int)specificEquipment);
DefendStat = GetDefense(dataOvlRef, (int)specificEquipment);
RequiredStrength = GetRequiredStrength(dataOvlRef, (int)specificEquipment);
this.SpecificEquipment = specificEquipment;
}
public Reagents(DataOvlReference dataOvlRef, List <byte> gameStateByteArray) : base(dataOvlRef, gameStateByteArray)
{
int nIndex = 0;
foreach (Reagent.ReagentTypeEnum reagent in Enum.GetValues(typeof(Reagent.ReagentTypeEnum)))
{
AddReagent(reagent, (DataOvlReference.REAGENT_STRINGS)nIndex++);
}
}
static public int GetRequiredStrength(DataOvlReference dataOvlRef, int nIndex)
{
List <byte> requiredStrengthValueList = dataOvlRef.GetDataChunk(DataOvlReference.DataChunkName.REQ_STRENGTH_EQUIP).GetAsByteList();
if (nIndex >= requiredStrengthValueList.Count)
{
return(0);
}
return(requiredStrengthValueList[nIndex]);
}
static public int GetDefense(DataOvlReference dataOvlRef, int nIndex)
{
List <byte> defenseValueList = dataOvlRef.GetDataChunk(DataOvlReference.DataChunkName.DEFENSE_VALUES).GetAsByteList();
if (nIndex >= defenseValueList.Count)
{
return(0);
}
return(defenseValueList[nIndex]);
}
static public int GetAttack(DataOvlReference dataOvlRef, int nIndex)
{
List <byte> attackValueList = dataOvlRef.GetDataChunk(DataOvlReference.DataChunkName.ATTACK_VALUES).GetAsByteList();
if (nIndex >= attackValueList.Count)
{
return(0);
}
return(attackValueList[nIndex]);
}
static public string GetEquipmentString(DataOvlReference dataOvlRef, int nString)
{
List <string> equipmentNames = dataOvlRef.GetDataChunk(DataOvlReference.DataChunkName.EQUIP_INDEXES).GetAsStringListFromIndexes();
if (nString == 0xFF)
{
return(" ");
}
return(equipmentNames[nString]);
}
public Armours(DataOvlReference dataOvlRef, List <byte> gameStateByteArray) : base(dataOvlRef, gameStateByteArray)
{
equipmentNames = dataOvlRef.GetDataChunk(DataOvlReference.DataChunkName.EQUIP_INDEXES).GetAsStringListFromIndexes();
InitializeHelms();
//InitializeShields();
InitializeChestArmour();
InitializeAmulets();
InitializeRings();
}
public Scrolls(DataOvlReference dataOvlRef, List <byte> gameStateByteArray) : base(dataOvlRef, gameStateByteArray)
{
AddScroll(Spell.SpellWords.Vas_Lor, DataOvlReference.SPELL_STRINGS.VAS_LOR);
AddScroll(Spell.SpellWords.Rel_Hur, DataOvlReference.SPELL_STRINGS.REL_HUR);
AddScroll(Spell.SpellWords.In_Sanct, DataOvlReference.SPELL_STRINGS.IN_SANCT);
AddScroll(Spell.SpellWords.In_An, DataOvlReference.SPELL_STRINGS.IN_AN);
AddScroll(Spell.SpellWords.In_Quas_Wis, DataOvlReference.SPELL_STRINGS.IN_QUAS_WIS);
AddScroll(Spell.SpellWords.Kal_Xen_Corp, DataOvlReference.SPELL_STRINGS.KAL_XEN_CORP);
AddScroll(Spell.SpellWords.In_Mani_Corp, DataOvlReference.SPELL_STRINGS.IN_MANI_CORP);
AddScroll(Spell.SpellWords.An_Tym, DataOvlReference.SPELL_STRINGS.AN_TYM);
}
public Potions(DataOvlReference dataOvlRef, List <byte> gameStateByteArray) : base(dataOvlRef, gameStateByteArray)
{
AddPotion(Potion.PotionColor.Blue, DataOvlReference.POTIONS_STRINGS.BLUE);
AddPotion(Potion.PotionColor.Yellow, DataOvlReference.POTIONS_STRINGS.YELLOW);
AddPotion(Potion.PotionColor.Red, DataOvlReference.POTIONS_STRINGS.RED);
AddPotion(Potion.PotionColor.Green, DataOvlReference.POTIONS_STRINGS.GREEN);
AddPotion(Potion.PotionColor.Orange, DataOvlReference.POTIONS_STRINGS.ORANGE);
AddPotion(Potion.PotionColor.Purple, DataOvlReference.POTIONS_STRINGS.PURPLE);
AddPotion(Potion.PotionColor.Black, DataOvlReference.POTIONS_STRINGS.BLACK);
AddPotion(Potion.PotionColor.White, DataOvlReference.POTIONS_STRINGS.WHITE);
}
public LordBritishArtifacts(DataOvlReference dataOvlRef, List <byte> gameStateByteArray) : base(dataOvlRef, gameStateByteArray)
{
Items[LordBritishArtifact.ArtifactType.Amulet] = new LordBritishArtifact(LordBritishArtifact.ArtifactType.Amulet,
gameStateByteArray[(int)OFFSETS.AMULET],
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES_STRINGS.AMULET),
dataOvlRef.StringReferences.GetString(DataOvlReference.WEAR_USE_ITEM_STRINGS.WEARING_AMULET));
Items[LordBritishArtifact.ArtifactType.Crown] = new LordBritishArtifact(LordBritishArtifact.ArtifactType.Crown,
gameStateByteArray[(int)OFFSETS.CROWN],
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES_STRINGS.CROWN),
dataOvlRef.StringReferences.GetString(DataOvlReference.WEAR_USE_ITEM_STRINGS.DON_THE_CROWN));
Items[LordBritishArtifact.ArtifactType.Sceptre] = new LordBritishArtifact(LordBritishArtifact.ArtifactType.Sceptre,
gameStateByteArray[(int)OFFSETS.SCEPTRE],
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES_STRINGS.SCEPTRE),
dataOvlRef.StringReferences.GetString(DataOvlReference.WEAR_USE_ITEM_STRINGS.WIELD_SCEPTRE));
}
public ShadowlordShards(DataOvlReference dataOvlRef, List <byte> gameStateByteArray) : base(dataOvlRef, gameStateByteArray)
{
Items[ShadowlordShard.ShardType.Falsehood] = new ShadowlordShard(ShadowlordShard.ShardType.Falsehood,
gameStateByteArray[(int)OFFSETS.FALSEHOOD],
dataOvlRef.StringReferences.GetString(DataOvlReference.SHARDS_STRINGS.FALSEHOOD),
dataOvlRef.StringReferences.GetString(DataOvlReference.SHADOWLORD_STRINGS.GEM_SHARD_THOU_HOLD_EVIL_SHARD) +
dataOvlRef.StringReferences.GetString(DataOvlReference.SHADOWLORD_STRINGS.FALSEHOOD_DOT));
Items[ShadowlordShard.ShardType.Hatred] = new ShadowlordShard(ShadowlordShard.ShardType.Hatred,
gameStateByteArray[(int)OFFSETS.HATRED],
dataOvlRef.StringReferences.GetString(DataOvlReference.SHARDS_STRINGS.HATRED),
dataOvlRef.StringReferences.GetString(DataOvlReference.SHADOWLORD_STRINGS.GEM_SHARD_THOU_HOLD_EVIL_SHARD) +
dataOvlRef.StringReferences.GetString(DataOvlReference.SHADOWLORD_STRINGS.HATRED_DOT));
Items[ShadowlordShard.ShardType.Cowardice] = new ShadowlordShard(ShadowlordShard.ShardType.Cowardice,
gameStateByteArray[(int)OFFSETS.COWARDICE],
dataOvlRef.StringReferences.GetString(DataOvlReference.SHARDS_STRINGS.COWARDICE),
dataOvlRef.StringReferences.GetString(DataOvlReference.SHADOWLORD_STRINGS.GEM_SHARD_THOU_HOLD_EVIL_SHARD) +
dataOvlRef.StringReferences.GetString(DataOvlReference.SHADOWLORD_STRINGS.COWARDICE_DOT));
}
public LargeMapReference(DataOvlReference dataRef, SmallMapReferences smallMapRef)
{
// Load the location XYs and map them against the location
List <byte> xLocs = dataRef.GetDataChunk(DataOvlReference.DataChunkName.LOCATIONS_X).GetAsByteList();
List <byte> yLocs = dataRef.GetDataChunk(DataOvlReference.DataChunkName.LOCATIONS_Y).GetAsByteList();
Debug.Assert(xLocs.Count == yLocs.Count);
// Towns, Dwellings, Castles, Keeps, Dungeons
//List<Point2D> vectors = new List<Point2D>();
for (int nVector = 0; nVector < 0x28; nVector++)
{
Point2D mapPoint = new Point2D(xLocs[nVector], yLocs[nVector]);
SmallMapReferences.SingleMapReference.Location location = (SmallMapReferences.SingleMapReference.Location)nVector + 1;
//vectors.Add(new Point2D(xLocs[nVector], yLocs[nVector]));
// LocationXY.Add((SmallMapReferences.SingleMapReference.Location)nVector + 1, new Point2D(xLocs[nVector], yLocs[nVector]));
LocationXY.Add(location, mapPoint);
LocationXYLocations.Add(mapPoint, location);
}
}
/// <summary>
/// Construct a compressed word reference using the Data.OVL reference
/// </summary>
/// <param name="dataRef"></param>
public CompressedWordReference(DataOvlReference dataRef)
{
CompressedWords = dataRef.GetDataChunk(DataOvlReference.DataChunkName.TALK_COMPRESSED_WORDS).GetChunkAsStringList();
CompressedWords.PrintSomeStrings();
// we are creating a lookup map because the indexes are not concurrent
compressWordLookupMap = new Dictionary <int, byte>(CompressedWords.Strs.Count);
// this is kind of gross, but these define the index gaps in the lookup table
// I have no idea why there are gaps, but alas, this works around them
int i = 0;
AddByteLookupMapping(1, 7, --i);
AddByteLookupMapping(9, 27, --i);
AddByteLookupMapping(29, 49, --i);
AddByteLookupMapping(51, 64, --i);
AddByteLookupMapping(66, 66, --i);
AddByteLookupMapping(68, 69, --i);
AddByteLookupMapping(71, 71, --i);
i -= 4;
AddByteLookupMapping(76, 129, i);
}
public Weapons(DataOvlReference dataOvlRef, List <byte> gameStateByteArray) : base(dataOvlRef, gameStateByteArray)
{
equipmentNames = dataOvlRef.GetDataChunk(DataOvlReference.DataChunkName.EQUIP_INDEXES).GetAsStringListFromIndexes();
// we need to actually add shields because they can be equipped as weapons
// but you should not expose shields twice in the UI
AddWeapon(Weapon.WeaponTypeEnum.SmallShield, Weapon.WeaponTypeSpriteEnum.SmallShield, DataOvlReference.EQUIPMENT.SmallShield);
AddWeapon(Weapon.WeaponTypeEnum.LargeShield, Weapon.WeaponTypeSpriteEnum.LargeShield, DataOvlReference.EQUIPMENT.LargeShield);
AddWeapon(Weapon.WeaponTypeEnum.SpikedShield, Weapon.WeaponTypeSpriteEnum.SpikedShield, DataOvlReference.EQUIPMENT.SpikedShield);
AddWeapon(Weapon.WeaponTypeEnum.MagicShield, Weapon.WeaponTypeSpriteEnum.MagicShield, DataOvlReference.EQUIPMENT.MagicShield);
AddWeapon(Weapon.WeaponTypeEnum.JewelShield, Weapon.WeaponTypeSpriteEnum.JewelShield, DataOvlReference.EQUIPMENT.JewelShield);
AddWeapon(Weapon.WeaponTypeEnum.Dagger, Weapon.WeaponTypeSpriteEnum.Dagger, DataOvlReference.EQUIPMENT.Dagger);
AddWeapon(Weapon.WeaponTypeEnum.Sling, Weapon.WeaponTypeSpriteEnum.Sling, DataOvlReference.EQUIPMENT.Sling);
AddWeapon(Weapon.WeaponTypeEnum.Club, Weapon.WeaponTypeSpriteEnum.Club, DataOvlReference.EQUIPMENT.Club);
AddWeapon(Weapon.WeaponTypeEnum.FlamingOil, Weapon.WeaponTypeSpriteEnum.FlamingOil, DataOvlReference.EQUIPMENT.FlamingOil);
AddWeapon(Weapon.WeaponTypeEnum.MainGauche, Weapon.WeaponTypeSpriteEnum.MainGauche, DataOvlReference.EQUIPMENT.MainGauche);
AddWeapon(Weapon.WeaponTypeEnum.Spear, Weapon.WeaponTypeSpriteEnum.Spear, DataOvlReference.EQUIPMENT.Spear);
AddWeapon(Weapon.WeaponTypeEnum.ThrowingAxe, Weapon.WeaponTypeSpriteEnum.ThrowingAxe, DataOvlReference.EQUIPMENT.ThrowingAxe);
AddWeapon(Weapon.WeaponTypeEnum.ShortSword, Weapon.WeaponTypeSpriteEnum.ShortSword, DataOvlReference.EQUIPMENT.ShortSword);
AddWeapon(Weapon.WeaponTypeEnum.Mace, Weapon.WeaponTypeSpriteEnum.Mace, DataOvlReference.EQUIPMENT.Mace);
AddWeapon(Weapon.WeaponTypeEnum.MorningStar, Weapon.WeaponTypeSpriteEnum.MorningStar, DataOvlReference.EQUIPMENT.MorningStar);
AddWeapon(Weapon.WeaponTypeEnum.Bow, Weapon.WeaponTypeSpriteEnum.Bow, DataOvlReference.EQUIPMENT.Bow);
AddWeapon(Weapon.WeaponTypeEnum.Arrows, Weapon.WeaponTypeSpriteEnum.Arrows, DataOvlReference.EQUIPMENT.Arrows);
AddWeapon(Weapon.WeaponTypeEnum.Crossbow, Weapon.WeaponTypeSpriteEnum.Crossbow, DataOvlReference.EQUIPMENT.Crossbow);
AddWeapon(Weapon.WeaponTypeEnum.Quarrels, Weapon.WeaponTypeSpriteEnum.Quarrels, DataOvlReference.EQUIPMENT.Quarrels);
AddWeapon(Weapon.WeaponTypeEnum.LongSword, Weapon.WeaponTypeSpriteEnum.LongSword, DataOvlReference.EQUIPMENT.LongSword);
AddWeapon(Weapon.WeaponTypeEnum.TwoHHammer, Weapon.WeaponTypeSpriteEnum.TwoHHammer, DataOvlReference.EQUIPMENT.TwoHHammer);
AddWeapon(Weapon.WeaponTypeEnum.TwoHAxe, Weapon.WeaponTypeSpriteEnum.TwoHAxe, DataOvlReference.EQUIPMENT.TwoHAxe);
AddWeapon(Weapon.WeaponTypeEnum.TwoHSword, Weapon.WeaponTypeSpriteEnum.TwoHSword, DataOvlReference.EQUIPMENT.TwoHSword);
AddWeapon(Weapon.WeaponTypeEnum.Halberd, Weapon.WeaponTypeSpriteEnum.Halberd, DataOvlReference.EQUIPMENT.Halberd);
AddWeapon(Weapon.WeaponTypeEnum.SwordofChaos, Weapon.WeaponTypeSpriteEnum.SwordofChaos, DataOvlReference.EQUIPMENT.SwordofChaos);
AddWeapon(Weapon.WeaponTypeEnum.MagicBow, Weapon.WeaponTypeSpriteEnum.MagicBow, DataOvlReference.EQUIPMENT.MagicBow);
AddWeapon(Weapon.WeaponTypeEnum.SilverSword, Weapon.WeaponTypeSpriteEnum.SilverSword, DataOvlReference.EQUIPMENT.SilverSword);
AddWeapon(Weapon.WeaponTypeEnum.MagicAxe, Weapon.WeaponTypeSpriteEnum.MagicAxe, DataOvlReference.EQUIPMENT.MagicAxe);
AddWeapon(Weapon.WeaponTypeEnum.GlassSword, Weapon.WeaponTypeSpriteEnum.GlassSword, DataOvlReference.EQUIPMENT.GlassSword);
AddWeapon(Weapon.WeaponTypeEnum.JeweledSword, Weapon.WeaponTypeSpriteEnum.JeweledSword, DataOvlReference.EQUIPMENT.JeweledSword);
AddWeapon(Weapon.WeaponTypeEnum.MysticSword, Weapon.WeaponTypeSpriteEnum.MysticSword, DataOvlReference.EQUIPMENT.MysticSword);
}
public SpecialItems(DataOvlReference dataOvlRef, List <byte> gameStateByteArray) : base(dataOvlRef, gameStateByteArray)
{
// Carpet = 170, Grapple = 12, Spyglass = 89, HMSCape = 260, PocketWatch = 232, BlackBadge = 281,
//WoodenBox = 270, Sextant = 256
Items[SpecialItem.ItemTypeSpriteEnum.Carpet] = new SpecialItem(SpecialItem.ItemTypeSpriteEnum.Carpet,
gameStateByteArray[(int)SpecialItem.ItemTypeEnum.Carpet],
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES_STRINGS.MAGIC_CRPT),
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES_STRINGS.MAGIC_CRPT));
Items[SpecialItem.ItemTypeSpriteEnum.Grapple] = new SpecialItem(SpecialItem.ItemTypeSpriteEnum.Grapple,
gameStateByteArray[(int)SpecialItem.ItemTypeEnum.Grapple],
"Grappling Hook",
"Grapple");
Items[SpecialItem.ItemTypeSpriteEnum.Spyglass] = new SpecialItem(SpecialItem.ItemTypeSpriteEnum.Spyglass,
gameStateByteArray[(int)SpecialItem.ItemTypeEnum.Spyglass],
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.SPYGLASS),
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.SPYGLASS));
Items[SpecialItem.ItemTypeSpriteEnum.HMSCape] = new SpecialItem(SpecialItem.ItemTypeSpriteEnum.HMSCape,
gameStateByteArray[(int)SpecialItem.ItemTypeEnum.HMSCape],
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.HMS_CAPE_PLAN),
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.HMS_CAPE_PLAN));
Items[SpecialItem.ItemTypeSpriteEnum.Sextant] = new SpecialItem(SpecialItem.ItemTypeSpriteEnum.Sextant,
gameStateByteArray[(int)SpecialItem.ItemTypeEnum.Sextant],
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.SEXTANT),
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.SEXTANT));
Items[SpecialItem.ItemTypeSpriteEnum.PocketWatch] = new SpecialItem(SpecialItem.ItemTypeSpriteEnum.PocketWatch,
//gameStateByteArray[(int)SpecialItem.ItemTypeEnum.PocketWatch],
1,
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.POCKET_WATCH),
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.POCKET_WATCH));
Items[SpecialItem.ItemTypeSpriteEnum.BlackBadge] = new SpecialItem(SpecialItem.ItemTypeSpriteEnum.BlackBadge,
gameStateByteArray[(int)SpecialItem.ItemTypeEnum.BlackBadge],
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.BLACK_BADGE),
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.BLACK_BADGE));
Items[SpecialItem.ItemTypeSpriteEnum.WoodenBox] = new SpecialItem(SpecialItem.ItemTypeSpriteEnum.WoodenBox,
gameStateByteArray[(int)SpecialItem.ItemTypeEnum.WoodenBox],
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.WOODEN_BOX),
dataOvlRef.StringReferences.GetString(DataOvlReference.SPECIAL_ITEM_NAMES2_STRINGS.WOODEN_BOX));
}
public Inventory(List <byte> gameStateByteArray, DataOvlReference dataOvlRef)
{
this.gameStateByteArray = gameStateByteArray;
DataChunk.CreateDataChunk(DataChunk.DataFormatType.Byte, "Grapple", gameStateByteArray, 0x209, sizeof(byte));
DataChunk.CreateDataChunk(DataChunk.DataFormatType.Byte, "Magic Carpet", gameStateByteArray, 0x20A, sizeof(byte));
ProtectiveArmour = new Armours(dataOvlRef, gameStateByteArray);
AllItems.AddRange(ProtectiveArmour.GenericItemList);
ReadyItems.AddRange(ProtectiveArmour.GenericItemList);
TheWeapons = new Weapons(dataOvlRef, gameStateByteArray);
ReadyItems.AddRange(TheWeapons.GenericItemList);
MagicScrolls = new Scrolls(dataOvlRef, gameStateByteArray);
UseItems.AddRange(MagicScrolls.GenericItemList);
MagicPotions = new Potions(dataOvlRef, gameStateByteArray);
UseItems.AddRange(MagicPotions.GenericItemList);
SpecializedItems = new SpecialItems(dataOvlRef, gameStateByteArray);
AllItems.AddRange(SpecializedItems.GenericItemList);
UseItems.AddRange(SpecializedItems.GenericItemList);
Artifacts = new LordBritishArtifacts(dataOvlRef, gameStateByteArray);
AllItems.AddRange(Artifacts.GenericItemList);
UseItems.AddRange(Artifacts.GenericItemList);
Shards = new ShadowlordShards(dataOvlRef, gameStateByteArray);
AllItems.AddRange(Shards.GenericItemList);
UseItems.AddRange(Shards.GenericItemList);
SpellReagents = new Reagents(dataOvlRef, gameStateByteArray);
AllItems.AddRange(SpellReagents.GenericItemList);
MagicSpells = new Spells(dataOvlRef, gameStateByteArray);
AllItems.AddRange(MagicSpells.GenericItemList);
}
public ChestArmour(ChestArmourEnum chestArmourType, DataOvlReference.EQUIPMENT equipment, DataOvlReference dataOvlRef, List <byte> gameStateByteArray)
: base(equipment, dataOvlRef, gameStateByteArray, (int)chestArmourType, CHEST_ARMOUR_SPRITE)
{
ChestArmourType = chestArmourType;
}
/// <summary>
/// Construct the GameState
/// </summary>
/// <param name="u5Directory">Directory of the game State files</param>
public GameState(string u5Directory, DataOvlReference dataOvlRef)
{
dataRef = dataOvlRef;
string saveFileAndPath = Path.Combine(u5Directory, FileConstants.SAVED_GAM);
dataChunks = new DataChunks <DataChunkName>(saveFileAndPath, DataChunkName.Unused);
List <byte> gameStateByteArray;
gameStateByteArray = Utils.GetFileAsByteList(saveFileAndPath);
// import all character records
dataChunks.AddDataChunk(DataChunk.DataFormatType.ByteList, "All Character Records (ie. name, stats)", 0x02, 0x20 * 16, 0x00, DataChunkName.CHARACTER_RECORDS);
DataChunk rawCharacterRecords = dataChunks.GetDataChunk(DataChunkName.CHARACTER_RECORDS);
CharacterRecords = new PlayerCharacterRecords(rawCharacterRecords.GetAsByteList());
// import the players invetry
PlayerInventory = new Inventory(gameStateByteArray, dataRef);
// player location
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Current Party Location", 0x2ED, 0x01, 0x00, DataChunkName.PARTY_LOC);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Z Coordinate of Party [10]", 0x2EF, 0x01, 0x00, DataChunkName.Z_COORD);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "X Coordinate of Party", 0x2F0, 0x01, 0x00, DataChunkName.X_COORD);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Y Coordinate of Party", 0x2F1, 0x01, 0x00, DataChunkName.Y_COORD);
// quantities of standard items
dataChunks.AddDataChunk(DataChunk.DataFormatType.UINT16, "Food Quantity", 0x202, 0x02, 0x00, DataChunkName.FOOD_QUANTITY);
dataChunks.AddDataChunk(DataChunk.DataFormatType.UINT16, "Gold Quantity", 0x204, 0x02, 0x00, DataChunkName.GOLD_QUANTITY);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Keys Quantity", 0x206, 0x01, 0x00, DataChunkName.KEYS_QUANTITY);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Gems Quantity", 0x207, 0x01, 0x00, DataChunkName.GEMS_QUANTITY);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Torches Quantity", 0x208, 0x01, 0x00, DataChunkName.TORCHES_QUANTITY);
// time and date
dataChunks.AddDataChunk(DataChunk.DataFormatType.UINT16, "Current Year", 0x2CE, 0x02, 0x00, DataChunkName.CURRENT_YEAR);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Current Month", 0x2D7, 0x01, 0x00, DataChunkName.CURRENT_MONTH);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Current Day", 0x2D8, 0x01, 0x00, DataChunkName.CURRENT_DAY);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Current Hour", 0x2D9, 0x01, 0x00, DataChunkName.CURRENT_HOUR);
// 0x2DA is copy of 2D9 for some reason
dataChunks.AddDataChunk(DataChunk.DataFormatType.Byte, "Current Minute", 0x2DB, 0x01, 0x00, DataChunkName.CURRENT_MINUTE);
//dataChunks.AddDataChunk()
dataChunks.AddDataChunk(DataChunk.DataFormatType.Bitmap, "NPC Killed Bitmap", 0x5B4, 0x80, 0x00, DataChunkName.NPC_ISALIVE_TABLE);
dataChunks.AddDataChunk(DataChunk.DataFormatType.Bitmap, "NPC Met Bitmap", 0x634, 0x80, 0x00, DataChunkName.NPC_ISMET_TABLE);
dataChunks.AddDataChunk(DataChunk.DataFormatType.ByteList, "Number of Party Members", 0x2B5, 0x1, 0x00, DataChunkName.N_PEOPLE_PARTY);
dataChunks.AddDataChunk(DataChunk.DataFormatType.ByteList, "NPC Type Map", 0x5B4, 0x20, 0x00, DataChunkName.NPC_TYPES);
List <byte> chunks = dataChunks.GetDataChunk(DataChunkName.NPC_TYPES).GetAsByteList();
// get the NPCs movement list - 0x20 NPCs, with 0x10 movement commands each, consisting of 0x1 direction byte + 0x1 repetitions
dataChunks.AddDataChunk(DataChunk.DataFormatType.ByteList, "NPC Movement List", 0xBB8, 0x20 * 0x10 * (sizeof(byte) * 2), 0x00, DataChunkName.NPC_MOVEMENT_LISTS);
// bajh: Jan 12 2020, moved from BB8 to BBA to test a theory that it actually begins a few bytes after the original documentation indicates
//dataChunks.AddDataChunk(DataChunk.DataFormatType.ByteList, "NPC Movement List", 0xBBA, 0x20 * 0x10 * (sizeof(byte) * 2), 0x00, DataChunkName.NPC_MOVEMENT_LISTS);
// get the offsets to the current movement instructions of the NPCs
dataChunks.AddDataChunk(DataChunk.DataFormatType.UINT16List, "NPC Movement Offset Lists", 0xFB8, 0x20 * (sizeof(byte) * 2), 0x00, DataChunkName.NPC_MOVEMENT_OFFSETS);
// we will need to add 0x100 for now, but cannot because it's read in as a bytelist
dataChunks.AddDataChunk(DataChunk.DataFormatType.ByteList, "NPC Sprite (by smallmap)", 0xFF8, 0x20, 0x00, DataChunkName.NPC_SPRITE_INDEXES);
// Initialize the table to determine if an NPC is dead
List <bool> npcAlive = dataChunks.GetDataChunk(DataChunkName.NPC_ISALIVE_TABLE).GetAsBitmapBoolList();
npcIsDeadArray = Utils.ListTo2DArray <bool>(npcAlive, NonPlayerCharacterReferences.NPCS_PER_TOWN, 0x00, NonPlayerCharacterReferences.NPCS_PER_TOWN * SmallMapReferences.SingleMapReference.TOTAL_SMALL_MAP_LOCATIONS);
// Initialize a table to determine if an NPC has been met
List <bool> npcMet = dataChunks.GetDataChunk(DataChunkName.NPC_ISMET_TABLE).GetAsBitmapBoolList();
// these will map directly to the towns and the NPC dialog #
npcIsMetArray = Utils.ListTo2DArray <bool>(npcMet, NonPlayerCharacterReferences.NPCS_PER_TOWN, 0x00, NonPlayerCharacterReferences.NPCS_PER_TOWN * SmallMapReferences.SingleMapReference.TOTAL_SMALL_MAP_LOCATIONS);
// this stores monsters, party, objects and NPC location info and other stuff too (apparently!?)
dataChunks.AddDataChunk(DataChunk.DataFormatType.ByteList, "Character Animation States - including xyz", 0x6B4, 0x100, 0x00, DataChunkName.CHARACTER_ANIMATION_STATES);
// this stores monsters, party, objects and NPC location info and other stuff too (apparently!?)
dataChunks.AddDataChunk(DataChunk.DataFormatType.UINT16List, "Character States - including xyz", 0x9B8, 0x200, 0x00, DataChunkName.CHARACTER_STATES);
// load the overworld and underworld overlays
string overworldOverlayPath = Path.Combine(u5Directory, FileConstants.BRIT_OOL);
string underworldOverlayPath = Path.Combine(u5Directory, FileConstants.UNDER_OOL);
overworldOverlayDataChunks = new DataChunks <OverlayChunkName>(overworldOverlayPath, OverlayChunkName.Unused);
underworldOverlayDataChunks = new DataChunks <OverlayChunkName>(underworldOverlayPath, OverlayChunkName.Unused);
overworldOverlayDataChunks.AddDataChunk(DataChunk.DataFormatType.ByteList, "Character Animation States - including xyz", 0x00, 0x100, 0x00, OverlayChunkName.CHARACTER_ANIMATION_STATES);
underworldOverlayDataChunks.AddDataChunk(DataChunk.DataFormatType.ByteList, "Character Animation States - including xyz", 0x00, 0x100, 0x00, OverlayChunkName.CHARACTER_ANIMATION_STATES);
TheTimeOfDay = new TimeOfDay(dataChunks.GetDataChunk(DataChunkName.CURRENT_YEAR), dataChunks.GetDataChunk(DataChunkName.CURRENT_MONTH),
dataChunks.GetDataChunk(DataChunkName.CURRENT_DAY), dataChunks.GetDataChunk(DataChunkName.CURRENT_HOUR),
dataChunks.GetDataChunk(DataChunkName.CURRENT_MINUTE));
}
public Shield(ShieldTypeEnum shieldType, DataOvlReference.EQUIPMENT equipment, DataOvlReference dataOvlRef, List <byte> gameStateByteArray)
: base(equipment, dataOvlRef, gameStateByteArray, (int)shieldType, SHIELD_SPRITE)
{
ShieldType = shieldType;
}
public Weapon(WeaponTypeEnum weapon, WeaponTypeSpriteEnum sprite, DataOvlReference.EQUIPMENT equipment, DataOvlReference dataOvlRef, List <byte> gameStateByteArray)
: base(equipment, dataOvlRef, gameStateByteArray, (int)weapon, (int)sprite)
{
IsAmmo = equipment == DataOvlReference.EQUIPMENT.Quarrels || equipment == DataOvlReference.EQUIPMENT.Arrows;
IsTwoHanded = equipment == DataOvlReference.EQUIPMENT.TwoHAxe || equipment == DataOvlReference.EQUIPMENT.TwoHSword ||
equipment == DataOvlReference.EQUIPMENT.TwoHHammer || equipment == DataOvlReference.EQUIPMENT.Bow || equipment == DataOvlReference.EQUIPMENT.MagicBow ||
equipment == DataOvlReference.EQUIPMENT.Crossbow || equipment == DataOvlReference.EQUIPMENT.Halberd || equipment == DataOvlReference.EQUIPMENT.FlamingOil;
IsShield = equipment == DataOvlReference.EQUIPMENT.SmallShield || equipment == DataOvlReference.EQUIPMENT.LargeShield ||
equipment == DataOvlReference.EQUIPMENT.SpikedShield || equipment == DataOvlReference.EQUIPMENT.MagicShield ||
equipment == DataOvlReference.EQUIPMENT.JewelShield;
}
public Armour(DataOvlReference.EQUIPMENT specificEquipment, DataOvlReference dataOvlRef, List <byte> gameStateByteRef, int nOffset, int nSpriteNum)
: base(specificEquipment, dataOvlRef, gameStateByteRef, nOffset, nSpriteNum)
{
}
public World(string ultima5Directory) : base()
{
u5Directory = ultima5Directory;
// build the overworld map
OverworldMap = new LargeMap(u5Directory, LargeMap.Maps.Overworld);
// build the underworld map
UnderworldMap = new LargeMap(u5Directory, LargeMap.Maps.Underworld);
DataOvlRef = new DataOvlReference(u5Directory);
SpriteTileReferences = new TileReferences(DataOvlRef.StringReferences);
SmallMapRef = new SmallMapReferences(DataOvlRef);
LargeMapRef = new LargeMapReference(DataOvlRef, SmallMapRef);
AllSmallMaps = new SmallMaps(SmallMapRef, u5Directory, SpriteTileReferences);
State = new GameState(u5Directory, DataOvlRef);
//CharacterRecord character = State.GetCharacterFromParty(0);
//CharacterRecord character3 = State.GetCharacterFromParty(3);
//CharacterRecord character4 = State.GetCharacterFromParty(4);
//character.Equipped.Amulet = DataOvlReference.EQUIPMENT.Ankh;
//CharacterRecord character2 = State.GetCharacterFromParty(0);
// build all the small maps from the Small Map reference
//foreach (SmallMapReferences.SingleMapReference mapRef in SmallMapRef.MapReferenceList)
//{
// // now I can go through each and every reference
// SmallMap smallMap = new SmallMap(u5Directory, mapRef);
// smallMaps.Add(smallMap);
// //U5Map.PrintMapSection(smallMap.RawMap, 0, 0, 32, 32);
//}
// build all combat maps from the Combat Map References
foreach (CombatMapReference.SingleCombatMapReference combatMapRef in combatMapRef.MapReferenceList)
{
CombatMap combatMap = new CombatMap(u5Directory, combatMapRef);
//System.Console.WriteLine("\n");
//System.Console.WriteLine(combatMap.Description);
//Map.PrintMapSection(combatMap.RawMap, 0, 0, 11, 11);
}
// build a "look" table for all tiles
LookRef = new Look(ultima5Directory);
// build the sign tables
SignRef = new Signs(ultima5Directory);
//Signs.Sign sign = SignRef.GetSign(SmallMapReferences.SingleMapReference.Location.Yew, 16, 2);
Signs.Sign sign = SignRef.GetSign(42);
string str = sign.SignText;
TalkScriptsRef = new TalkScripts(u5Directory, DataOvlRef);
// build the NPC tables
NpcRef = new NonPlayerCharacterReferences(ultima5Directory, SmallMapRef, TalkScriptsRef, State);
//CharAnimationStates = new MapCharacterAnimationStates(State, SpriteTileReferences);
//CharStates = new MapCharacterStates(State, SpriteTileReferences);
// sadly I have to initilize this after the Npcs are created because there is a circular dependency
State.InitializeVirtualMap(SmallMapRef, AllSmallMaps, LargeMapRef, OverworldMap, UnderworldMap, NpcRef, SpriteTileReferences, State, NpcRef);
if (State.Location != SmallMapReferences.SingleMapReference.Location.Britainnia_Underworld)
{
State.TheVirtualMap.LoadSmallMap(SmallMapRef.GetSingleMapByLocation(State.Location, State.Floor), true);
}
else
{
State.TheVirtualMap.LoadLargeMap(LargeMap.Maps.Overworld);
}
//State.TheVirtualMap.LoadSmallMap()
//State.PlayerInventory.MagicSpells.Items[Spell.SpellWords.An_Ex_Por].GetLiteralTranslation();
//State.TheVirtualMap.LoadSmallMap(SmallMapRef.GetSingleMapByLocation(SmallMapReferences.SingleMapReference.Location.Serpents_Hold, 0), false);
//int nSpriteGuess = State.TheVirtualMap.GuessTile(new Point2D(15, 15));
//NpcRef.GetNonPlayerCharacter(SmallMapReferences.SingleMapReference.Location.Britain, new Point2D(0, 31), 0);
//State.Year = 100;
//State.Month = 13;
//State.Day = 28;
//State.Hour = 22;
//State.Minute = 2;
//Conversation convo = new Conversation(NpcRef.NPCs[21]); // dunkworth
// Conversation convo = new Conversation(NpcRef.NPCs[296], State, DataOvlRef); // Gwenno
// 19 = Margarett
// NpcRef.NPCs[296].Script.PrintComprehensiveScript();
int count = 0;
if (false)
{
foreach (NonPlayerCharacterReference npc in NpcRef.NPCs)
{
if (npc.NPCType != 0 && npc.Script != null)
{
Console.WriteLine("");
Console.WriteLine("---- SCRIPT for " + npc.Name.Trim() + " -----");
//Npc.Script.PrintScript();
npc.Script.PrintComprehensiveScript();
if (npc.Name.Trim() == "Geoffrey")
{
Console.WriteLine(npc.NPCType.ToString());
}
}
count++;
}
}
// Scally
//Conversation convo = new Conversation(NpcRef.NPCs[0xe6], State, DataOvlRef);
// Bidney
//Conversation convo = new Conversation(NpcRef.NPCs[0xe8], State);
// Lord Dalgrin
//Conversation convo = new Conversation(NpcRef.NPCs[0xea], State);
// Geoffery
//Conversation convo = new Conversation(NpcRef.NPCs[0xec], State, DataOvlRef);
// Tierra
//Conversation convo = new Conversation(NpcRef.NPCs[0xeb], State, DataOvlRef);
// Conversation.EnqueuedScriptItem enqueuedScriptItemDelegate = new Conversation.EnqueuedScriptItem(this.EnqueuedScriptItem);
// convo.EnqueuedScriptItemCallback += enqueuedScriptItemDelegate;
// convo.BeginConversation();
//0x48 or 0x28
//Console.WriteLine("Shutting down... Hit any key...");
//Console.ReadKey(false);
}
public InventoryItems(DataOvlReference dataOvlRef, List <byte> gameStateByteArray)
{
this.dataOvlRef = dataOvlRef;
this.gameStateByteArray = gameStateByteArray;
}
