private List <MapDataFile> ReadMapDataFiles(string[] directories)
{
if (directories == null)
{
throw new ArgumentNullException("Directories is null");
}
List <MapDataFile> mapDataFiles = new List <MapDataFile>();
foreach (string directory in directories)
{
string localDataPath = Path.Combine(DataPath, directory);
if (!Directory.Exists(localDataPath))
{
continue;
}
List <string> filePaths = Directory.EnumerateFiles(localDataPath, "*.ymd", SearchOption.AllDirectories).ToList();
foreach (string filePath in filePaths)
{
loadWaitWorker.ReportProgress(-1, string.Format("Reading {0}...", Path.GetFileName(filePath)));
MapDataFile ymd = new MapDataFile(this, filePath);
mapDataFiles.Add(ymd);
}
}
return(mapDataFiles.OrderBy(x => x.Filename).ToList());
}
private static void ExtractNpcs(List <string> npcList, int mapId, MapDataFile ifo)
{
foreach (var npc in ifo.NPCs)
{
var eventDataFile = new DataFile();
eventDataFile.Load("./3DDATA/stb/list_event.stb");
int dialogId = 0;
for (int i = 0; i < eventDataFile.RowCount; i++)
{
if (eventDataFile[i][0] == npc.ConversationFile)
{
dialogId = i;
break;
}
}
var adjPosCoords = new Vector3(((npc.Position.X + 520000.00f) / 100.0f), ((npc.Position.Y + 520000.00f) / 100.0f), ((npc.Position.Z) / 100.0f));
npcList.Add("npc(\"" + dialogId.ToString("G", CultureInfo.InvariantCulture) + "\", "
+ npc.ObjectID.ToString("G", CultureInfo.InvariantCulture) + ", "
+ mapId.ToString("G", CultureInfo.InvariantCulture) + ", "
+ (adjPosCoords.X).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (adjPosCoords.Y).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (adjPosCoords.Z).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (npc.Rotation.Angle * (180.0 / Math.PI)).ToString("G", CultureInfo.InvariantCulture) + ");\n");
}
}
private static void ExtractMobs(List <string> mobList, int mapId, MapDataFile ifo)
{
foreach (var mobSpawns in ifo.MonsterSpawns)
{
var adjPosCoords = new Vector3(((mobSpawns.Position.X + 520000.00f) / 100.0f), ((mobSpawns.Position.Y + 520000.00f) / 100.0f), ((mobSpawns.Position.Z) / 100.0f));
foreach (var normalMobs in mobSpawns.NormalSpawnPoints)
{
mobList.Add("mob(\"\", "
+ normalMobs.Monster.ToString("G", CultureInfo.InvariantCulture) + ", "
+ normalMobs.Count.ToString("G", CultureInfo.InvariantCulture) + ", "
+ mobSpawns.Limit.ToString("G", CultureInfo.InvariantCulture) + ", "
+ mobSpawns.Interval.ToString("G", CultureInfo.InvariantCulture) + ", "
+ mobSpawns.Range.ToString("G", CultureInfo.InvariantCulture) + ", "
+ mapId.ToString("G", CultureInfo.InvariantCulture) + ", "
+ (adjPosCoords.X).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (adjPosCoords.Y).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (adjPosCoords.Z).ToString("G", CultureInfo.InvariantCulture) + ");\n");
}
foreach (var tacticalMobs in mobSpawns.TacticalSpawnPoints)
{
mobList.Add("mob(\"\", "
+ tacticalMobs.Monster.ToString("G", CultureInfo.InvariantCulture) + ", "
+ tacticalMobs.Count.ToString("G", CultureInfo.InvariantCulture) + ", "
+ mobSpawns.Limit.ToString("G", CultureInfo.InvariantCulture) + ", "
+ mobSpawns.Interval.ToString("G", CultureInfo.InvariantCulture) + ", "
+ mobSpawns.Range.ToString("G", CultureInfo.InvariantCulture) + ", "
+ mapId.ToString("G", CultureInfo.InvariantCulture) + ", "
+ (adjPosCoords.X).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (adjPosCoords.Y).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (adjPosCoords.Z).ToString("G", CultureInfo.InvariantCulture) + ");\n");
}
}
}
private void cbMaps_SelectedIndexChanged(object sender, EventArgs e)
{
ComboBox comboBox = (sender as ComboBox);
if (comboBox.SelectedItem != null)
{
mapDataFile = (comboBox.SelectedItem as MapDataFile);
gatherItemParsers = gameDataManager.ParsedData.Where(x => x is GatherItemParser && (x as GatherItemParser).FloorNumber == (mapDataFile.FloorNumber - 1)).Cast <GatherItemParser>().ToList();
pgMapTile.SelectedObject = gameDataManager.MapTileData[mapDataFile][0, 0];
}
gridEditControl.Invalidate();
pgMapTile.Refresh();
}
public BaseTile(GameDataManager gameDataManager, MapDataFile mapDataFile, int offset, Point coordinates, PropertyChangedEventHandler propertyChanged = null)
{
GameDataManager = gameDataManager;
MapDataFile = mapDataFile;
Offset = offset;
Coordinates = coordinates;
PropertyChanged = propertyChanged;
MapDataFile.Stream.Seek(Offset, SeekOrigin.Begin);
Data = new byte[16];
MapDataFile.Stream.Read(Data, 0, Data.Length);
tileType = (MapDataFile.TileTypes)Data[0];
Load();
}
public BaseTile(GameDataManager gameDataManager, MapDataFile mapDataFile, int offset, Point coordinates, PropertyChangedEventHandler propertyChanged = null)
{
this.GameDataManager = gameDataManager;
this.MapDataFile = mapDataFile;
this.Offset = offset;
this.Coordinates = coordinates;
this.PropertyChanged = propertyChanged;
this.MapDataFile.Stream.Seek(this.Offset, SeekOrigin.Begin);
this.Data = new byte[16];
this.MapDataFile.Stream.Read(this.Data, 0, this.Data.Length);
this.tileType = (MapDataFile.TileTypes) this.Data[0];
Load();
}
public FloorTile(GameDataManager gameDataManager, MapDataFile mapDataFile, int offset, System.Drawing.Point coordinates, PropertyChangedEventHandler propertyChanged = null) :
base(gameDataManager, mapDataFile, offset, coordinates, propertyChanged)
{
}
public void TestSaveMethod()
{
MapDataFile mapDataFile = new MapDataFile();
mapDataFile.Load(TEST_FILE);
MemoryStream savedStream = new MemoryStream();
mapDataFile.Save(savedStream);
savedStream.Seek(0, SeekOrigin.Begin);
MapDataFile savedMapDataFile = new MapDataFile();
savedMapDataFile.Load(savedStream);
savedStream.Close();
Assert.AreEqual(mapDataFile.MapPosition, savedMapDataFile.MapPosition, "Map position values do not match");
Assert.AreEqual(mapDataFile.ZonePosition, savedMapDataFile.ZonePosition, "Zone position values do not match");
Assert.AreEqual(mapDataFile.World, savedMapDataFile.World, "World matrices do not match");
Assert.AreEqual(mapDataFile.Name, savedMapDataFile.Name, "Names do not match");
Assert.AreEqual(mapDataFile.Objects.Count, savedMapDataFile.Objects.Count, "Object counts do not match");
for (int i = 0; i < mapDataFile.Objects.Count; i++)
{
Assert.AreEqual(mapDataFile.Objects[i].Name, savedMapDataFile.Objects[i].Name, "Object names do not match");
Assert.AreEqual(mapDataFile.Objects[i].WarpID, savedMapDataFile.Objects[i].WarpID, "Object warp ID values do not match");
Assert.AreEqual(mapDataFile.Objects[i].EventID, savedMapDataFile.Objects[i].EventID, "Object event ID values do not match");
Assert.AreEqual(mapDataFile.Objects[i].ObjectType, savedMapDataFile.Objects[i].ObjectType, "Object object type values do not match");
Assert.AreEqual(mapDataFile.Objects[i].ObjectID, savedMapDataFile.Objects[i].ObjectID, "Object object ID values do not match");
Assert.AreEqual(mapDataFile.Objects[i].MapPosition, savedMapDataFile.Objects[i].MapPosition, "Object map positions do not match");
Assert.AreEqual(mapDataFile.Objects[i].Rotation, savedMapDataFile.Objects[i].Rotation, "Object rotations do not match");
Assert.AreEqual(mapDataFile.Objects[i].Position, savedMapDataFile.Objects[i].Position, "Object positions do not match");
Assert.AreEqual(mapDataFile.Objects[i].Scale, savedMapDataFile.Objects[i].Scale, "Object scales do not match");
}
Assert.AreEqual(mapDataFile.NPCs.Count, savedMapDataFile.NPCs.Count, "NPC counts do not match");
for (int i = 0; i < mapDataFile.NPCs.Count; i++)
{
Assert.AreEqual(mapDataFile.NPCs[i].Name, savedMapDataFile.NPCs[i].Name, "NPC names do not match");
Assert.AreEqual(mapDataFile.NPCs[i].WarpID, savedMapDataFile.NPCs[i].WarpID, "NPC warp ID values do not match");
Assert.AreEqual(mapDataFile.NPCs[i].EventID, savedMapDataFile.NPCs[i].EventID, "NPC event ID values do not match");
Assert.AreEqual(mapDataFile.NPCs[i].ObjectType, savedMapDataFile.NPCs[i].ObjectType, "NPC object type values do not match");
Assert.AreEqual(mapDataFile.NPCs[i].ObjectID, savedMapDataFile.NPCs[i].ObjectID, "NPC object ID values do not match");
Assert.AreEqual(mapDataFile.NPCs[i].MapPosition, savedMapDataFile.NPCs[i].MapPosition, "NPC map positions do not match");
Assert.AreEqual(mapDataFile.NPCs[i].Rotation, savedMapDataFile.NPCs[i].Rotation, "NPC rotations do not match");
Assert.AreEqual(mapDataFile.NPCs[i].Position, savedMapDataFile.NPCs[i].Position, "NPC positions do not match");
Assert.AreEqual(mapDataFile.NPCs[i].Scale, savedMapDataFile.NPCs[i].Scale, "NPC scales do not match");
Assert.AreEqual(mapDataFile.NPCs[i].AI, savedMapDataFile.NPCs[i].AI, "NPC AI values do not match");
Assert.AreEqual(mapDataFile.NPCs[i].ConversationFile, savedMapDataFile.NPCs[i].ConversationFile, "NPC conversation file values do not match");
}
Assert.AreEqual(mapDataFile.Buildings.Count, savedMapDataFile.Buildings.Count, "Building counts do not match");
for (int i = 0; i < mapDataFile.Buildings.Count; i++)
{
Assert.AreEqual(mapDataFile.Buildings[i].Name, savedMapDataFile.Buildings[i].Name, "Building names do not match");
Assert.AreEqual(mapDataFile.Buildings[i].WarpID, savedMapDataFile.Buildings[i].WarpID, "Building warp ID values do not match");
Assert.AreEqual(mapDataFile.Buildings[i].EventID, savedMapDataFile.Buildings[i].EventID, "Building event ID values do not match");
Assert.AreEqual(mapDataFile.Buildings[i].ObjectType, savedMapDataFile.Buildings[i].ObjectType, "Building object type values do not match");
Assert.AreEqual(mapDataFile.Buildings[i].ObjectID, savedMapDataFile.Buildings[i].ObjectID, "Building object ID values do not match");
Assert.AreEqual(mapDataFile.Buildings[i].MapPosition, savedMapDataFile.Buildings[i].MapPosition, "Building map positions do not match");
Assert.AreEqual(mapDataFile.Buildings[i].Rotation, savedMapDataFile.Buildings[i].Rotation, "Building rotations do not match");
Assert.AreEqual(mapDataFile.Buildings[i].Position, savedMapDataFile.Buildings[i].Position, "Building positions do not match");
Assert.AreEqual(mapDataFile.Buildings[i].Scale, savedMapDataFile.Buildings[i].Scale, "Building scales do not match");
}
Assert.AreEqual(mapDataFile.Sounds.Count, savedMapDataFile.Sounds.Count, "Sound counts do not match");
for (int i = 0; i < mapDataFile.Sounds.Count; i++)
{
Assert.AreEqual(mapDataFile.Sounds[i].Name, savedMapDataFile.Sounds[i].Name, "Sound names do not match");
Assert.AreEqual(mapDataFile.Sounds[i].WarpID, savedMapDataFile.Sounds[i].WarpID, "Sound warp ID values do not match");
Assert.AreEqual(mapDataFile.Sounds[i].EventID, savedMapDataFile.Sounds[i].EventID, "Sound event ID values do not match");
Assert.AreEqual(mapDataFile.Sounds[i].ObjectType, savedMapDataFile.Sounds[i].ObjectType, "Sound object type values do not match");
Assert.AreEqual(mapDataFile.Sounds[i].ObjectID, savedMapDataFile.Sounds[i].ObjectID, "Sound object ID values do not match");
Assert.AreEqual(mapDataFile.Sounds[i].MapPosition, savedMapDataFile.Sounds[i].MapPosition, "Sound map positions do not match");
Assert.AreEqual(mapDataFile.Sounds[i].Rotation, savedMapDataFile.Sounds[i].Rotation, "Sound rotations do not match");
Assert.AreEqual(mapDataFile.Sounds[i].Position, savedMapDataFile.Sounds[i].Position, "Sound positions do not match");
Assert.AreEqual(mapDataFile.Sounds[i].Scale, savedMapDataFile.Sounds[i].Scale, "Sound scales do not match");
Assert.AreEqual(mapDataFile.Sounds[i].FilePath, savedMapDataFile.Sounds[i].FilePath, "Sound file paths do not match");
Assert.AreEqual(mapDataFile.Sounds[i].Range, savedMapDataFile.Sounds[i].Range, "Sound range values do not match");
Assert.AreEqual(mapDataFile.Sounds[i].Interval, savedMapDataFile.Sounds[i].Interval, "Sound interval values do not match");
}
Assert.AreEqual(mapDataFile.Effects.Count, savedMapDataFile.Effects.Count, "Effect counts do not match");
for (int i = 0; i < mapDataFile.Effects.Count; i++)
{
Assert.AreEqual(mapDataFile.Effects[i].Name, savedMapDataFile.Effects[i].Name, "Effect names do not match");
Assert.AreEqual(mapDataFile.Effects[i].WarpID, savedMapDataFile.Effects[i].WarpID, "Effect warp ID values do not match");
Assert.AreEqual(mapDataFile.Effects[i].EventID, savedMapDataFile.Effects[i].EventID, "Effect event ID values do not match");
Assert.AreEqual(mapDataFile.Effects[i].ObjectType, savedMapDataFile.Effects[i].ObjectType, "Effect object type values do not match");
Assert.AreEqual(mapDataFile.Effects[i].ObjectID, savedMapDataFile.Effects[i].ObjectID, "Effect object ID values do not match");
Assert.AreEqual(mapDataFile.Effects[i].MapPosition, savedMapDataFile.Effects[i].MapPosition, "Effect map positions do not match");
Assert.AreEqual(mapDataFile.Effects[i].Rotation, savedMapDataFile.Effects[i].Rotation, "Effect rotations do not match");
Assert.AreEqual(mapDataFile.Effects[i].Position, savedMapDataFile.Effects[i].Position, "Effect positions do not match");
Assert.AreEqual(mapDataFile.Effects[i].Scale, savedMapDataFile.Effects[i].Scale, "Effect scales do not match");
Assert.AreEqual(mapDataFile.Effects[i].FilePath, savedMapDataFile.Effects[i].FilePath, "Effect file paths do not match");
}
Assert.AreEqual(mapDataFile.Animations.Count, savedMapDataFile.Animations.Count, "Animation counts do not match");
for (int i = 0; i < mapDataFile.Animations.Count; i++)
{
Assert.AreEqual(mapDataFile.Animations[i].Name, savedMapDataFile.Animations[i].Name, "Animation names do not match");
Assert.AreEqual(mapDataFile.Animations[i].WarpID, savedMapDataFile.Animations[i].WarpID, "Animation warp ID values do not match");
Assert.AreEqual(mapDataFile.Animations[i].EventID, savedMapDataFile.Animations[i].EventID, "Animation event ID values do not match");
Assert.AreEqual(mapDataFile.Animations[i].ObjectType, savedMapDataFile.Animations[i].ObjectType, "Animation object type values do not match");
Assert.AreEqual(mapDataFile.Animations[i].ObjectID, savedMapDataFile.Animations[i].ObjectID, "Animation object ID values do not match");
Assert.AreEqual(mapDataFile.Animations[i].MapPosition, savedMapDataFile.Animations[i].MapPosition, "Animation map positions do not match");
Assert.AreEqual(mapDataFile.Animations[i].Rotation, savedMapDataFile.Animations[i].Rotation, "Animation rotations do not match");
Assert.AreEqual(mapDataFile.Animations[i].Position, savedMapDataFile.Animations[i].Position, "Animation positions do not match");
Assert.AreEqual(mapDataFile.Animations[i].Scale, savedMapDataFile.Animations[i].Scale, "Animation scales do not match");
}
Assert.AreEqual(mapDataFile.WaterPatches.Name, savedMapDataFile.WaterPatches.Name, "Water patch names do not match");
Assert.AreEqual(mapDataFile.WaterPatches.WarpID, savedMapDataFile.WaterPatches.WarpID, "Water patch warp ID values do not match");
Assert.AreEqual(mapDataFile.WaterPatches.EventID, savedMapDataFile.WaterPatches.EventID, "Water patch event ID values do not match");
Assert.AreEqual(mapDataFile.WaterPatches.ObjectType, savedMapDataFile.WaterPatches.ObjectType, "Water patch object type values do not match");
Assert.AreEqual(mapDataFile.WaterPatches.ObjectID, savedMapDataFile.WaterPatches.ObjectID, "Water patch object ID values do not match");
Assert.AreEqual(mapDataFile.WaterPatches.MapPosition, savedMapDataFile.WaterPatches.MapPosition, "Water patch map positions do not match");
Assert.AreEqual(mapDataFile.WaterPatches.Rotation, savedMapDataFile.WaterPatches.Rotation, "Water patch rotations do not match");
Assert.AreEqual(mapDataFile.WaterPatches.Position, savedMapDataFile.WaterPatches.Position, "Water patch positions do not match");
Assert.AreEqual(mapDataFile.WaterPatches.Scale, savedMapDataFile.WaterPatches.Scale, "Water patch scales do not match");
Assert.AreEqual(mapDataFile.WaterPatches.Width, savedMapDataFile.WaterPatches.Width, "Water patch width values do not match");
Assert.AreEqual(mapDataFile.WaterPatches.Height, savedMapDataFile.WaterPatches.Height, "Water patch height values do not match");
for (int h = 0; h < mapDataFile.WaterPatches.Height; h++)
{
for (int w = 0; w < mapDataFile.WaterPatches.Width; w++)
{
Assert.AreEqual(mapDataFile.WaterPatches.Patches[h, w].HasWater, mapDataFile.WaterPatches.Patches[h, w].HasWater, "Water patch has water values do not match");
Assert.AreEqual(mapDataFile.WaterPatches.Patches[h, w].Height, mapDataFile.WaterPatches.Patches[h, w].Height, "Water patch has water values do not match");
Assert.AreEqual(mapDataFile.WaterPatches.Patches[h, w].Type, mapDataFile.WaterPatches.Patches[h, w].Type, "Water patch has water values do not match");
Assert.AreEqual(mapDataFile.WaterPatches.Patches[h, w].ID, mapDataFile.WaterPatches.Patches[h, w].ID, "Water patch has water values do not match");
Assert.AreEqual(mapDataFile.WaterPatches.Patches[h, w].Reserved, mapDataFile.WaterPatches.Patches[h, w].Reserved, "Water patch has water values do not match");
}
}
Assert.AreEqual(mapDataFile.MonsterSpawns.Count, savedMapDataFile.MonsterSpawns.Count, "Monster spawn counts do not match");
for (int i = 0; i < mapDataFile.MonsterSpawns.Count; i++)
{
Assert.AreEqual(mapDataFile.MonsterSpawns[i].Name, savedMapDataFile.MonsterSpawns[i].Name, "Monster spawn names do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].WarpID, savedMapDataFile.MonsterSpawns[i].WarpID, "Monster spawn warp ID values do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].EventID, savedMapDataFile.MonsterSpawns[i].EventID, "Monster spawn event ID values do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].ObjectType, savedMapDataFile.MonsterSpawns[i].ObjectType, "Monster spawn object type values do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].ObjectID, savedMapDataFile.MonsterSpawns[i].ObjectID, "Monster spawn object ID values do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].MapPosition, savedMapDataFile.MonsterSpawns[i].MapPosition, "Monster spawn map positions do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].Rotation, savedMapDataFile.MonsterSpawns[i].Rotation, "Monster spawn rotations do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].Position, savedMapDataFile.MonsterSpawns[i].Position, "Monster spawn positions do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].Scale, savedMapDataFile.MonsterSpawns[i].Scale, "Monster spawn scales do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].SpawnName, savedMapDataFile.MonsterSpawns[i].SpawnName, "Monster spawn names do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].NormalSpawnPoints.Count, savedMapDataFile.MonsterSpawns[i].NormalSpawnPoints.Count, "Normal spawn point counts do not match");
for (int j = 0; j < mapDataFile.MonsterSpawns[i].NormalSpawnPoints.Count; j++)
{
Assert.AreEqual(mapDataFile.MonsterSpawns[i].NormalSpawnPoints[j].Name, mapDataFile.MonsterSpawns[i].NormalSpawnPoints[j].Name, "Normal spawn point names do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].NormalSpawnPoints[j].Monster, mapDataFile.MonsterSpawns[i].NormalSpawnPoints[j].Monster, "Normal spawn point monster values do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].NormalSpawnPoints[j].Count, mapDataFile.MonsterSpawns[i].NormalSpawnPoints[j].Count, "Normal spawn point Count values do not match");
}
Assert.AreEqual(mapDataFile.MonsterSpawns[i].TacticalSpawnPoints.Count, savedMapDataFile.MonsterSpawns[i].TacticalSpawnPoints.Count, "Tactical spawn point counts do not match");
for (int j = 0; j < mapDataFile.MonsterSpawns[i].TacticalSpawnPoints.Count; j++)
{
Assert.AreEqual(mapDataFile.MonsterSpawns[i].TacticalSpawnPoints[j].Name, mapDataFile.MonsterSpawns[i].TacticalSpawnPoints[j].Name, "Tactical spawn point names do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].TacticalSpawnPoints[j].Monster, mapDataFile.MonsterSpawns[i].TacticalSpawnPoints[j].Monster, "Tactical spawn point monster values do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].TacticalSpawnPoints[j].Count, mapDataFile.MonsterSpawns[i].TacticalSpawnPoints[j].Count, "Tactical spawn point Count values do not match");
}
Assert.AreEqual(mapDataFile.MonsterSpawns[i].Interval, savedMapDataFile.MonsterSpawns[i].Interval, "Monster spawn interval values do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].Limit, savedMapDataFile.MonsterSpawns[i].Limit, "Monster spawn limit values do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].Range, savedMapDataFile.MonsterSpawns[i].Range, "Monster spawn range values do not match");
Assert.AreEqual(mapDataFile.MonsterSpawns[i].TacticalVariable, savedMapDataFile.MonsterSpawns[i].TacticalVariable, "Monster spawn tactical variable values do not match");
}
Assert.AreEqual(mapDataFile.WaterSize, savedMapDataFile.WaterSize, "Water size values do not match");
Assert.AreEqual(mapDataFile.WaterPlanes.Count, savedMapDataFile.WaterPlanes.Count, "Water plane counts do not match");
for (int i = 0; i < mapDataFile.WaterPlanes.Count; i++)
{
Assert.AreEqual(mapDataFile.WaterPlanes[i].StartPosition, savedMapDataFile.WaterPlanes[i].StartPosition, "Water plane start positions do not match");
Assert.AreEqual(mapDataFile.WaterPlanes[i].EndPosition, savedMapDataFile.WaterPlanes[i].EndPosition, "Water plane end positions do not match");
}
Assert.AreEqual(mapDataFile.WarpPoints.Count, savedMapDataFile.WarpPoints.Count, "Warp point counts do not match");
for (int i = 0; i < mapDataFile.WarpPoints.Count; i++)
{
Assert.AreEqual(mapDataFile.WarpPoints[i].Name, savedMapDataFile.WarpPoints[i].Name, "Warp point names do not match");
Assert.AreEqual(mapDataFile.WarpPoints[i].WarpID, savedMapDataFile.WarpPoints[i].WarpID, "Warp point warp ID values do not match");
Assert.AreEqual(mapDataFile.WarpPoints[i].EventID, savedMapDataFile.WarpPoints[i].EventID, "Warp point event ID values do not match");
Assert.AreEqual(mapDataFile.WarpPoints[i].ObjectType, savedMapDataFile.WarpPoints[i].ObjectType, "Warp point object type values do not match");
Assert.AreEqual(mapDataFile.WarpPoints[i].ObjectID, savedMapDataFile.WarpPoints[i].ObjectID, "Warp point object ID values do not match");
Assert.AreEqual(mapDataFile.WarpPoints[i].MapPosition, savedMapDataFile.WarpPoints[i].MapPosition, "Warp point map positions do not match");
Assert.AreEqual(mapDataFile.WarpPoints[i].Rotation, savedMapDataFile.WarpPoints[i].Rotation, "Warp point rotations do not match");
Assert.AreEqual(mapDataFile.WarpPoints[i].Position, savedMapDataFile.WarpPoints[i].Position, "Warp point positions do not match");
Assert.AreEqual(mapDataFile.WarpPoints[i].Scale, savedMapDataFile.WarpPoints[i].Scale, "Warp point scales do not match");
}
Assert.AreEqual(mapDataFile.CollisionObjects.Count, savedMapDataFile.CollisionObjects.Count, "Collision object counts do not match");
for (int i = 0; i < mapDataFile.CollisionObjects.Count; i++)
{
Assert.AreEqual(mapDataFile.CollisionObjects[i].Name, savedMapDataFile.CollisionObjects[i].Name, "Collision object names do not match");
Assert.AreEqual(mapDataFile.CollisionObjects[i].WarpID, savedMapDataFile.CollisionObjects[i].WarpID, "Collision object warp ID values do not match");
Assert.AreEqual(mapDataFile.CollisionObjects[i].EventID, savedMapDataFile.CollisionObjects[i].EventID, "Collision object event ID values do not match");
Assert.AreEqual(mapDataFile.CollisionObjects[i].ObjectType, savedMapDataFile.CollisionObjects[i].ObjectType, "Collision object object type values do not match");
Assert.AreEqual(mapDataFile.CollisionObjects[i].ObjectID, savedMapDataFile.CollisionObjects[i].ObjectID, "Collision object object ID values do not match");
Assert.AreEqual(mapDataFile.CollisionObjects[i].MapPosition, savedMapDataFile.CollisionObjects[i].MapPosition, "Collision object map positions do not match");
Assert.AreEqual(mapDataFile.CollisionObjects[i].Rotation, savedMapDataFile.CollisionObjects[i].Rotation, "Collision object rotations do not match");
Assert.AreEqual(mapDataFile.CollisionObjects[i].Position, savedMapDataFile.CollisionObjects[i].Position, "Collision object positions do not match");
Assert.AreEqual(mapDataFile.CollisionObjects[i].Scale, savedMapDataFile.CollisionObjects[i].Scale, "Collision object scales do not match");
}
Assert.AreEqual(mapDataFile.EventObjects.Count, savedMapDataFile.EventObjects.Count, "Event object counts do not match");
for (int i = 0; i < mapDataFile.EventObjects.Count; i++)
{
Assert.AreEqual(mapDataFile.EventObjects[i].Name, savedMapDataFile.EventObjects[i].Name, "Event object names do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].WarpID, savedMapDataFile.EventObjects[i].WarpID, "Event object warp ID values do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].EventID, savedMapDataFile.EventObjects[i].EventID, "Event object event ID values do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].ObjectType, savedMapDataFile.EventObjects[i].ObjectType, "Event object object type values do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].ObjectID, savedMapDataFile.EventObjects[i].ObjectID, "Event object object ID values do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].MapPosition, savedMapDataFile.EventObjects[i].MapPosition, "Event object map positions do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].Rotation, savedMapDataFile.EventObjects[i].Rotation, "Event object rotations do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].Position, savedMapDataFile.EventObjects[i].Position, "Event object positions do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].Scale, savedMapDataFile.EventObjects[i].Scale, "Event object scales do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].FunctionName, savedMapDataFile.EventObjects[i].FunctionName, "Event object function names do not match");
Assert.AreEqual(mapDataFile.EventObjects[i].ConversationFile, savedMapDataFile.EventObjects[i].ConversationFile, "Event object conversation file values do not match");
}
}
public void TestLoadMethod()
{
MapDataFile mapDataFile = new MapDataFile();
mapDataFile.Load(TEST_FILE);
}
public void Load(string filePath = null, int mapId = 0)
{
if (filePath == null)
{
return;
}
var directoryPath = Path.GetDirectoryName(filePath);
var fileName = Path.GetFileNameWithoutExtension(filePath);
var zoneFile = new ZoneFile();
try
{
zoneFile.Load(filePath);
}
catch (FileNotFoundException)
{
Console.Write("Failed!\n");
return;
}
Console.Write("Successful!\n");
// Do the data conversion here
var mapDataFile = new MapDataFile[65, 65];
for (var x = 0; x < zoneFile.Width; x++)
{
for (var y = 0; y < zoneFile.Height; y++)
{
if (!zoneFile.Positions[x, y].IsUsed)
{
continue;
}
mapDataFile[x, y] = new MapDataFile();
try
{
mapDataFile[x, y].Load(directoryPath + "\\" + y + "_" + x + ".ifo");
}
catch (FileNotFoundException)
{
continue;
}
}
}
var mobList = new List <string>();
var npcList = new List <string>();
var spawnList = new List <string>();
var warpList = new List <string>();
ExtractSpawnPoints(mapId, zoneFile, spawnList);
foreach (var ifo in mapDataFile)
{
if (ifo == null)
{
continue;
}
var blockX = ifo.ZonePosition.X * PostionModifier;
var blockY = ifo.ZonePosition.Y * PostionModifier;
ExtractNpcs(npcList, mapId, ifo);
ExtractMobs(mobList, mapId, ifo);
ExtractWarpGates(warpList, mapId, ifo);
}
WriteLua(fileName, mobList, npcList, spawnList, warpList);
Console.Write("\n\n");
}
private static void ExtractWarpGates(List <string> warpList, int mapId, MapDataFile ifo)
{
const string warpStb = "./3DDATA/stb/warp.stb";
const string zoneStb = "./3DDATA/stb/list_zone.stb";
const string warpGateModel = "./3DDATA/special/warp_gate01/warp.zms";
const string decoSpecialList = "./3DDATA/special/list_deco_special.zsc";
var zoneDataFile = new DataFile();
zoneDataFile.Load(zoneStb);
var warpDataFile = new DataFile();
warpDataFile.Load(warpStb);
var destCoords = Vector3.Zero;
ModelListFile modelListFile = new ModelListFile();
modelListFile.Load(decoSpecialList);
ModelFile modelFile = new ModelFile();
modelFile.Load(warpGateModel);
var vertices = modelFile.Vertices;
foreach (var warpGate in ifo.WarpPoints)
{
var destMapId = int.Parse(warpDataFile[warpGate.WarpID][2]);
if (zoneDataFile[destMapId][2].ToString().Contains(".zon"))
{
ZoneFile zoneFile = new ZoneFile();
zoneFile.Load(zoneDataFile[destMapId][2].ToString()); // Load the zon file
foreach (var spawnPoint in zoneFile.SpawnPoints)
{
if (spawnPoint.Name != warpDataFile[warpGate.WarpID][3].ToString())
{
continue;
}
// rose is stupid and we need to do this to get the right coords
destCoords = new Vector3(((spawnPoint.Position.X + 520000.00f) / 100.0f), ((spawnPoint.Position.Z + 520000.00f) / 100.0f), ((spawnPoint.Position.Y) / 100.0f));
break;
}
}
var position = new Vector3(((warpGate.Position.X + 520000.00f) / 100.0f), ((warpGate.Position.Y + 520000.00f) / 100.0f), ((warpGate.Position.Z) / 100.0f));
var rot = Matrix.RotationQuaternion(modelListFile.Objects[1].Parts[0].Rotation);
var scale = Matrix.Scaling(modelListFile.Objects[1].Parts[0].Scale);
var trans = Matrix.Translation(modelListFile.Objects[1].Parts[0].Position);
var world = rot * scale * trans;
var objRot = Matrix.RotationQuaternion(warpGate.Rotation);
var objScale = Matrix.Scaling(warpGate.Scale);
var objTrans = Matrix.Translation(position);
var objectWorld = objRot * objScale * objTrans;
Vector3[] vectorPositions = new Vector3[vertices.Count];
for (int i = 0; i < vertices.Count; i++)
{
vectorPositions[i] = (Vector3)Vector3.Transform(vertices[i].Position, world * objectWorld);
}
var boundingBox = BoundingBox.FromPoints(vectorPositions);
warpList.Add("warp_gate(\"\", "
+ warpDataFile[warpGate.WarpID][2].ToString("G", CultureInfo.InvariantCulture) + ", "
+ (destCoords.X).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (destCoords.Y).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (destCoords.Z).ToString("G", CultureInfo.InvariantCulture) + ", "
+ mapId.ToString("G", CultureInfo.InvariantCulture) + ", "
+ (boundingBox.Minimum.X).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (boundingBox.Minimum.Y).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (boundingBox.Minimum.Z).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (boundingBox.Maximum.X).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (boundingBox.Maximum.Y).ToString("G", CultureInfo.InvariantCulture) + ", "
+ (boundingBox.Maximum.Z).ToString("G", CultureInfo.InvariantCulture) + ");\n");
}
}
