public static void IndexNamedData(string dataPath)
{
try
{
EntryDataIndex fullGuide = new EntryDataIndex();
foreach (string dir in PathMod.GetModFiles(dataPath, "*" + DataManager.DATA_EXT))
{
string file = Path.GetFileNameWithoutExtension(dir);
int num = Convert.ToInt32(file);
IEntryData data = (IEntryData)DataManager.LoadData(dir);
while (fullGuide.Entries.Count <= num)
{
fullGuide.Entries.Add(new EntrySummary());
}
fullGuide.Entries[num] = data.GenerateEntrySummary();
}
using (Stream stream = new FileStream(PathMod.ModPath(dataPath + "index.idx"), FileMode.Create, FileAccess.Write, FileShare.None))
{
using (BinaryWriter writer = new BinaryWriter(stream))
{
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, fullGuide);
}
}
}
catch (Exception ex)
{
DiagManager.Instance.LogError(new Exception("Error importing index at " + dataPath + "\n", ex));
}
}
public override void ContentChanged(int idx)
{
string dataPath = DataManager.DATA_PATH + DataManager.DataType.Monster.ToString() + "/";
string dir = PathMod.ModPath(dataPath + idx + DataManager.DATA_EXT);
MonsterData data = DataManager.LoadData <MonsterData>(dir);
Dictionary <int, FormFeatureSummary> formSummaries = computeSummary(dataPath, idx, data);
FeatureData[idx] = formSummaries;
}
public static void RunExtraIndexing(DataManager.DataType conversionFlags)
{
//index extra based on triggers
foreach (BaseData baseData in DataManager.Instance.UniversalData)
{
if ((baseData.TriggerType & conversionFlags) != DataManager.DataType.None)
{
baseData.ReIndex();
DataManager.SaveData(PathMod.ModPath(DataManager.MISC_PATH + baseData.FileName + DataManager.DATA_EXT), baseData);
}
}
}
public static Bitmap GetTile(TileFrame tileTex)
{
long tilePos = GraphicsManager.TileIndex.GetPosition(tileTex.Sheet, tileTex.TexLoc);
TileAddr addr = new TileAddr(tilePos, tileTex.Sheet);
Bitmap sheet;
if (tileCache.TryGetValue(addr, out sheet))
{
return(sheet);
}
if (tilePos > 0)
{
try
{
using (FileStream stream = new FileStream(PathMod.ModPath(String.Format(GraphicsManager.TILE_PATTERN, tileTex.Sheet)), FileMode.Open, FileAccess.Read, FileShare.Read))
{
// Seek to the location of the tile
stream.Seek(tilePos, SeekOrigin.Begin);
using (BinaryReader reader = new BinaryReader(stream))
{
//usually handled by basesheet, cheat a little here
long length = reader.ReadInt64();
byte[] tileBytes = reader.ReadBytes((int)length);
using (MemoryStream tileStream = new MemoryStream(tileBytes))
sheet = new Bitmap(tileStream);
}
}
tileCache.Add(addr, sheet);
return(sheet);
}
catch (Exception ex)
{
DiagManager.Instance.LogError(new Exception("Error retrieving tile " + tileTex.TexLoc.X + ", " + tileTex.TexLoc.Y + " from Tileset #" + tileTex.Sheet + "\n", ex));
}
}
return(null);
}
public override void ContentChanged(int idx)
{
//remove the index from its previous locations
foreach (Dictionary <int, List <int> > rarityTable in RarityMap.Values)
{
foreach (List <int> items in rarityTable.Values)
{
if (items.Remove(idx))
{
break;
}
}
}
//Add it to its new locations
string dataPath = DataManager.DATA_PATH + DataManager.DataType.Item.ToString() + "/";
string dir = PathMod.ModPath(dataPath + idx + DataManager.DATA_EXT);
ItemData data = DataManager.LoadData <ItemData>(dir);
computeSummary(idx, data);
}
public static void ReserializeBase()
{
{
string dir = PathMod.ModPath(DataManager.DATA_PATH + "Universal.bin");
object data = DataManager.LoadData(dir, DiagManager.Instance.UpgradeBinder);
DataManager.SaveData(dir, data);
}
string editPath = Path.Combine(PathMod.RESOURCE_PATH, "Extensions");
foreach (string dir in Directory.GetFiles(editPath, "*.op"))
{
object data = DataManager.LoadData(dir, DiagManager.Instance.UpgradeBinder);
DataManager.SaveData(dir, data);
}
foreach (string dir in PathMod.GetModFiles(DataManager.FX_PATH, "*.fx"))
{
object data = DataManager.LoadData(dir, DiagManager.Instance.UpgradeBinder);
DataManager.SaveData(dir, data);
}
}
public static Bitmap GetTileset(string tileset)
{
Bitmap sheet;
if (tilesetCache.TryGetValue(tileset, out sheet))
{
return(sheet);
}
try
{
Loc tileDims = GraphicsManager.TileIndex.GetTileDims(tileset);
int tileSize = GraphicsManager.TileIndex.GetTileSize(tileset);
System.Drawing.Bitmap baseBitmap = new System.Drawing.Bitmap(tileDims.X * tileSize, tileDims.Y * tileSize);
using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(baseBitmap))
{
for (int xx = 0; xx < tileDims.X; xx++)
{
for (int yy = 0; yy < tileDims.Y; yy++)
{
long tilePos = GraphicsManager.TileIndex.GetPosition(tileset, new Loc(xx, yy));
if (tilePos > 0)
{
using (FileStream stream = new FileStream(PathMod.ModPath(String.Format(GraphicsManager.TILE_PATTERN, tileset)), FileMode.Open, FileAccess.Read, FileShare.Read))
{
// Seek to the location of the tile
stream.Seek(tilePos, SeekOrigin.Begin);
using (BinaryReader reader = new BinaryReader(stream))
{
//usually handled by basesheet, cheat a little here
long length = reader.ReadInt64();
byte[] tileBytes = reader.ReadBytes((int)length);
using (MemoryStream tileStream = new MemoryStream(tileBytes))
{
System.Drawing.Bitmap tile = new System.Drawing.Bitmap(tileStream);
graphics.DrawImage(tile, xx * tileSize, yy * tileSize);
}
}
}
}
}
}
}
using (MemoryStream tileStream = new MemoryStream())
{
baseBitmap.Save(tileStream, System.Drawing.Imaging.ImageFormat.Png);
tileStream.Seek(0, SeekOrigin.Begin);
sheet = new Bitmap(tileStream);
}
tilesetCache.Add(tileset, sheet);
return(sheet);
}
catch (Exception ex)
{
DiagManager.Instance.LogError(new Exception("Error retrieving Tileset #" + tileset + "\n", ex));
}
return(null);
}
private Dictionary <int, FormFeatureSummary> computeSummary(string dataPath, int num, MonsterData data)
{
Dictionary <int, FormFeatureSummary> formFeatureData = new Dictionary <int, FormFeatureSummary>();
int family = num;
MonsterData preEvo = data;
while (preEvo.PromoteFrom > -1)
{
family = preEvo.PromoteFrom;
string preDir = PathMod.ModPath(dataPath + family + DataManager.DATA_EXT);
preEvo = DataManager.LoadData <MonsterData>(preDir);
}
EvoFlag stage = EvoFlag.NoEvo;
bool evolvedFrom = (data.PromoteFrom > -1);
bool evolves = (data.Promotions.Count > 0);
if (evolvedFrom && evolves)
{
stage = EvoFlag.MidEvo;
}
else if (evolvedFrom)
{
stage = EvoFlag.FinalEvo;
}
else if (evolves)
{
stage = EvoFlag.FirstEvo;
}
for (int ii = 0; ii < data.Forms.Count; ii++)
{
FormFeatureSummary summary = new FormFeatureSummary();
summary.Family = family;
summary.Stage = stage;
MonsterFormData formData = data.Forms[ii] as MonsterFormData;
summary.Element1 = formData.Element1;
summary.Element2 = formData.Element2;
Stat bestStat = Stat.HP;
Stat worstStat = Stat.HP;
for (int nn = 0; nn < (int)Stat.HitRate; nn++)
{
if (bestStat != Stat.None)
{
if (formData.GetBaseStat((Stat)nn) > formData.GetBaseStat(bestStat))
{
bestStat = (Stat)nn;
}
else if (formData.GetBaseStat((Stat)nn) == formData.GetBaseStat(bestStat))
{
bestStat = Stat.None;
}
}
if (worstStat != Stat.None)
{
if (formData.GetBaseStat((Stat)nn) < formData.GetBaseStat(worstStat))
{
worstStat = (Stat)nn;
}
else if (formData.GetBaseStat((Stat)nn) == formData.GetBaseStat(worstStat))
{
worstStat = Stat.None;
}
}
}
summary.BestStat = bestStat;
summary.WorstStat = worstStat;
formFeatureData[ii] = summary;
}
return(formFeatureData);
}
static void Main()
{
InitDllMap();
//SetProcessDPIAware();
//TODO: figure out how to set this switch in appconfig
AppContext.SetSwitch("Switch.System.Runtime.Serialization.SerializationGuard.AllowFileWrites", true);
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
string[] args = Environment.GetCommandLineArgs();
PathMod.InitExePath(args[0]);
DiagManager.InitInstance();
DiagManager.Instance.CurSettings = DiagManager.Instance.LoadSettings();
DiagManager.Instance.LoadModSettings();
DiagManager.Instance.UpgradeBinder = new UpgradeBinder();
try
{
DiagManager.Instance.LogInfo("=========================================");
DiagManager.Instance.LogInfo(String.Format("SESSION STARTED: {0}", String.Format("{0:yyyy/MM/dd HH:mm:ss}", DateTime.Now)));
DiagManager.Instance.LogInfo("Version: " + Versioning.GetVersion().ToString());
DiagManager.Instance.LogInfo(Versioning.GetDotNetInfo());
DiagManager.Instance.LogInfo("=========================================");
bool logInput = true;
bool guideBook = false;
bool guideCsv = false;
GraphicsManager.AssetType convertAssets = GraphicsManager.AssetType.None;
DataManager.DataType convertIndices = DataManager.DataType.None;
DataManager.DataType reserializeIndices = DataManager.DataType.None;
string langArgs = "";
bool dev = false;
string quest = "";
List <string> mod = new List <string>();
bool buildQuest = false;
string playInputs = null;
for (int ii = 1; ii < args.Length; ii++)
{
if (args[ii] == "-dev")
{
dev = true;
}
else if (args[ii] == "-play" && args.Length > ii + 1)
{
playInputs = args[ii + 1];
ii++;
}
else if (args[ii] == "-lang" && args.Length > ii + 1)
{
langArgs = args[ii + 1];
ii++;
}
else if (args[ii] == "-nolog")
{
logInput = false;
}
else if (args[ii] == "-guide")
{
guideBook = true;
}
else if (args[ii] == "-csv")
{
guideCsv = true;
}
else if (args[ii] == "-asset")
{
PathMod.ASSET_PATH = Path.GetFullPath(args[ii + 1]);
ii++;
}
else if (args[ii] == "-raw")
{
PathMod.DEV_PATH = Path.GetFullPath(args[ii + 1]);
ii++;
}
else if (args[ii] == "-quest")
{
quest = args[ii + 1];
ii++;
}
else if (args[ii] == "-mod")
{
int jj = 1;
while (args.Length > ii + jj)
{
if (args[ii + jj].StartsWith("-"))
{
break;
}
else
{
mod.Add(args[ii + jj]);
}
jj++;
}
ii += jj - 1;
}
else if (args[ii] == "-build")
{
buildQuest = true;
ii++;
}
else if (args[ii] == "-convert")
{
int jj = 1;
while (args.Length > ii + jj)
{
GraphicsManager.AssetType conv = GraphicsManager.AssetType.None;
foreach (GraphicsManager.AssetType type in Enum.GetValues(typeof(GraphicsManager.AssetType)))
{
if (args[ii + jj].ToLower() == type.ToString().ToLower())
{
conv = type;
break;
}
}
if (conv != GraphicsManager.AssetType.None)
{
convertAssets |= conv;
}
else
{
break;
}
jj++;
}
ii += jj - 1;
}
else if (args[ii] == "-index")
{
int jj = 1;
while (args.Length > ii + jj)
{
DataManager.DataType conv = DataManager.DataType.None;
foreach (DataManager.DataType type in Enum.GetValues(typeof(DataManager.DataType)))
{
if (args[ii + jj].ToLower() == type.ToString().ToLower())
{
conv = type;
break;
}
}
if (conv != DataManager.DataType.None)
{
convertIndices |= conv;
}
else
{
break;
}
jj++;
}
ii += jj - 1;
}
else if (args[ii] == "-reserialize")
{
int jj = 1;
while (args.Length > ii + jj)
{
DataManager.DataType conv = DataManager.DataType.None;
foreach (DataManager.DataType type in Enum.GetValues(typeof(DataManager.DataType)))
{
if (args[ii + jj].ToLower() == type.ToString().ToLower())
{
conv = type;
break;
}
}
if (conv != DataManager.DataType.None)
{
reserializeIndices |= conv;
}
else
{
break;
}
jj++;
}
ii += jj - 1;
}
}
DiagManager.Instance.SetupGamepad();
GraphicsManager.InitParams();
DiagManager.Instance.DevMode = dev;
if (quest != "")
{
ModHeader header = PathMod.GetModDetails(Path.Combine(PathMod.MODS_PATH, quest));
if (header.IsValid())
{
PathMod.Quest = header;
DiagManager.Instance.LogInfo(String.Format("Loaded quest \"{0}\".", quest));
}
else
{
DiagManager.Instance.LogInfo(String.Format("Cannot find quest \"{0}\" in {1}. Falling back to base game.", quest, PathMod.MODS_PATH));
}
}
if (mod.Count > 0)
{
List <ModHeader> workingMods = new List <ModHeader>();
for (int ii = 0; ii < mod.Count; ii++)
{
ModHeader header = PathMod.GetModDetails(Path.Combine(PathMod.MODS_PATH, mod[ii]));
if (header.IsValid())
{
workingMods.Add(header);
DiagManager.Instance.LogInfo(String.Format("Loaded mod \"{0}\".", String.Join(", ", mod[ii])));
}
else
{
DiagManager.Instance.LogInfo(String.Format("Cannot find mod \"{0}\" in {1}. It will be ignored.", mod, PathMod.MODS_PATH));
mod.RemoveAt(ii);
ii--;
}
}
PathMod.Mods = workingMods.ToArray();
}
if (playInputs != null)
{
DiagManager.Instance.LoadInputs(playInputs);
}
Text.Init();
if (langArgs != "" && DiagManager.Instance.CurSettings.Language == "")
{
if (langArgs.Length > 0)
{
DiagManager.Instance.CurSettings.Language = langArgs.ToLower();
Text.SetCultureCode(langArgs.ToLower());
}
else
{
DiagManager.Instance.CurSettings.Language = "en";
}
}
Text.SetCultureCode(DiagManager.Instance.CurSettings.Language == "" ? "" : DiagManager.Instance.CurSettings.Language.ToString());
if (buildQuest)
{
if (!PathMod.Quest.IsValid())
{
DiagManager.Instance.LogInfo("No quest specified to build.");
return;
}
RogueEssence.Dev.DevHelper.MergeQuest(quest);
return;
}
if (convertAssets != GraphicsManager.AssetType.None)
{
//run conversions
using (GameBase game = new GameBase())
{
GraphicsManager.InitSystem(game.GraphicsDevice);
GraphicsManager.RunConversions(convertAssets);
}
return;
}
if (reserializeIndices != DataManager.DataType.None)
{
DiagManager.Instance.LogInfo("Beginning Reserialization");
using (GameBase game = new GameBase())
{
GraphicsManager.InitSystem(game.GraphicsDevice);
GraphicsManager.RebuildIndices(GraphicsManager.AssetType.All);
}
//we need the datamanager for this, but only while data is hardcoded
//TODO: remove when data is no longer hardcoded
LuaEngine.InitInstance();
DataManager.InitInstance();
DataManager.InitDataDirs(PathMod.ModPath(""));
RogueEssence.Dev.DevHelper.ReserializeBase();
DiagManager.Instance.LogInfo("Reserializing main data");
RogueEssence.Dev.DevHelper.Reserialize(reserializeIndices);
DiagManager.Instance.LogInfo("Reserializing map data");
if ((reserializeIndices & DataManager.DataType.Zone) != DataManager.DataType.None)
{
RogueEssence.Dev.DevHelper.ReserializeData <Map>(DataManager.DATA_PATH + "Map/", DataManager.MAP_EXT);
RogueEssence.Dev.DevHelper.ReserializeData <GroundMap>(DataManager.DATA_PATH + "Ground/", DataManager.GROUND_EXT);
}
DiagManager.Instance.LogInfo("Reserializing indices");
RogueEssence.Dev.DevHelper.RunIndexing(reserializeIndices);
DataManager.Instance.UniversalData = (TypeDict <BaseData>)RogueEssence.Dev.DevHelper.LoadWithLegacySupport(PathMod.ModPath(DataManager.MISC_PATH + "Index.bin"), typeof(TypeDict <BaseData>));
RogueEssence.Dev.DevHelper.RunExtraIndexing(reserializeIndices);
return;
}
if (convertIndices != DataManager.DataType.None)
{
//we need the datamanager for this, but only while data is hardcoded
//TODO: remove when data is no longer hardcoded
LuaEngine.InitInstance();
DataManager.InitInstance();
DiagManager.Instance.LogInfo("Reserializing indices");
DataManager.InitDataDirs(PathMod.ModPath(""));
RogueEssence.Dev.DevHelper.RunIndexing(convertIndices);
DataManager.Instance.UniversalData = (TypeDict <BaseData>)RogueEssence.Dev.DevHelper.LoadWithLegacySupport(PathMod.ModPath(DataManager.MISC_PATH + "Index.bin"), typeof(TypeDict <BaseData>));
RogueEssence.Dev.DevHelper.RunExtraIndexing(convertIndices);
return;
}
if (guideBook || guideCsv)
{
//print the guidebook in the chosen language
//we need the datamanager for this
LuaEngine.InitInstance();
DataManager.InitInstance();
DataManager.Instance.InitData();
//just print a guidebook and exit
StrategyGuide.PrintMoveGuide(guideCsv);
StrategyGuide.PrintItemGuide(guideCsv);
StrategyGuide.PrintAbilityGuide(guideCsv);
StrategyGuide.PrintEncounterGuide(guideCsv);
return;
}
//Dev.ImportManager.PrintMoveUsers(PathMod.DEV_PATH+"moves.txt");
//Dev.ImportManager.PrintAbilityUsers(PathMod.DEV_PATH+"abilities.txt");
logInput = false; //this feature is disabled for now...
if (DiagManager.Instance.ActiveDebugReplay == null && logInput)
{
DiagManager.Instance.BeginInput();
}
if (DiagManager.Instance.DevMode)
{
InitDataEditor();
AppBuilder builder = RogueEssence.Dev.Program.BuildAvaloniaApp();
builder.StartWithClassicDesktopLifetime(args);
}
else
{
DiagManager.Instance.DevEditor = new EmptyEditor();
using (GameBase game = new GameBase())
game.Run();
}
}
catch (Exception ex)
{
DiagManager.Instance.LogError(ex);
throw;
}
}
