internal static unsafe NXNode ParseNode(NodeData *ptr, NXNode parent, NXFile file)
{
NXNode ret;
switch (ptr->Type)
{
case 0:
ret = new NXNode(ptr, file);
break;
case 1:
ret = new NXInt64Node(ptr, file);
break;
case 2:
ret = new NXDoubleNode(ptr, file);
break;
case 3:
ret = new NXStringNode(ptr, file);
break;
case 4:
ret = new NXPointNode(ptr, file);
break;
case 5:
ret = new NXBitmapNode(ptr, file);
break;
case 6:
ret = new NXAudioNode(ptr, file);
break;
default:
return(Util.Die <NXNode>(string.Format("NX node has invalid type {0}; dying", ptr->Type)));
}
if ((file._flags & NXReadSelection.EagerParseFile) == NXReadSelection.EagerParseFile)
{
ret.CheckChild();
}
return(ret);
}
internal static unsafe NXNode ParseNode(NodeData *ptr, NXFile file)
{
NXNode ret;
switch (ptr->Type)
{
case NXNodeType.Nothing:
ret = new NXNode(ptr, file);
break;
case NXNodeType.Int64:
ret = new NXInt64Node(ptr, file);
break;
case NXNodeType.Double:
ret = new NXDoubleNode(ptr, file);
break;
case NXNodeType.String:
ret = new NXStringNode(ptr, file);
break;
case NXNodeType.Point:
ret = new NXPointNode(ptr, file);
break;
case NXNodeType.Bitmap:
ret = new NXBitmapNode(ptr, file);
break;
case NXNodeType.Audio:
ret = new NXAudioNode(ptr, file);
break;
default:
return(Util.Die <NXNode>($"NX node has invalid type {ptr->Type}"));
}
if (file.HasFlag(NXReadSelection.EagerParseFile))
{
ret.InitialiseMap();
}
return(ret);
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
try
{
NXFile nx = new NXFile(openFileDialog.FileName);
TreeNode baseTreeNode = new TreeNode(openFileDialog.SafeFileName);
baseTreeNode.Tag = nx;
treeView.Nodes.Add(baseTreeNode);
IterateNodes(baseTreeNode, nx.BaseNode);
}
catch (Exception ex)
{
string msg = string.Format("Unable to load {0}{1}{1}{2}", openFileDialog.SafeFileName, Environment.NewLine, ex.ToString());
MessageBox.Show(msg, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
private static void ExportItemNames(NXFile nxFile)
{
var sb = new StringBuilder();
void printItemName(NXNode item)
{
var hasName = item.ContainsChild("name");
byte level = 0;
var itemid = int.Parse(item.Name.TrimStart('0'));
if (Constants.isEquip(itemid))
{
if (DataProvider.Equips.TryGetValue(itemid, out var ed))
{
level = ed.RequiredLevel;
}
}
sb.AppendFormat("{0}\t{1}\t{2}\r\n", itemid, hasName ? item["name"].ValueString() : "-- NO NAME --", level);
}
foreach (var cat in nxFile.BaseNode["String"]["Item.img"]["Eqp"])
{
foreach (var item in cat)
{
printItemName(item);
}
}
foreach (var cat in nxFile.BaseNode["String"]["Item.img"].Where(x => x.Name != "Eqp"))
{
foreach (var item in cat)
{
printItemName(item);
}
}
File.WriteAllText("ids-of-items.tsv", sb.ToString());
}
public static KeyValuePair <NXFile, List <NXFile> > GetMergedDatafiles()
{
var mainFile = new NXFile(Path.Combine(Environment.CurrentDirectory, "..", "DataSvr", "Data.nx"));
var overrideFolder = Path.Combine(Environment.CurrentDirectory, "..", "DataSvr", "data");
var otherFiles = new List <NXFile>();
if (Directory.Exists(overrideFolder))
{
otherFiles.AddRange(Directory
.GetFiles(overrideFolder)
.Where(f => f.EndsWith(".nx"))
.Select(nxPath => new NXFile(nxPath))
);
foreach (var nxFile in otherFiles)
{
Console.WriteLine("Importing " + nxFile.FilePath);
mainFile.Import(nxFile);
}
}
return(new KeyValuePair <NXFile, List <NXFile> >(mainFile, otherFiles));
}
public CachedMobs(NXFile dataFile)
{
foreach (NXNode mobNode in dataFile.ResolvePath("/Mob"))
{
MapleData.InfoNode = mobNode["info"];
Mob mob = new Mob();
mob.MapleID = int.Parse(mobNode.Name.Replace(".img", ""));
mob.Level = MapleData.GetShort("level");
mob.MaxHP = MapleData.GetUInt("maxHP");
mob.MaxMP = MapleData.GetUInt("maxMP");
mob.CurrentHP = mob.MaxHP;
mob.CurrentMP = mob.MaxMP;
mob.HpRecovery = MapleData.GetUInt("hpRecovery");
mob.MpRecovery = MapleData.GetUInt("mpRecovery");
mob.Experience = MapleData.GetUInt("exp");
mob.SummonType = MapleData.GetShort("summonType");
mob.Speed = MapleData.GetShort("speed");
mob.Accuracy = MapleData.GetShort("acc");
mob.Avoidability = MapleData.GetShort("eva");
if (mobNode["info"].ContainsChild("revive"))
{
mob.DeathSummons = new List <int>();
foreach (NXNode reviveNode in mobNode["info"]["revive"])
{
mob.DeathSummons.Add(int.Parse(reviveNode.Name));
}
}
// TODO: Skills, Attacks and Loots.
this.Add(mob);
}
}
public NXDataDirectory(NXFile file) => _file = file;
public NXPointNode(NodeData *ptr, NXFile file) : base(ptr, file)
{
}
public NXStringNode(NodeData *ptr, NXFile file) : base(ptr, file)
{
}
public NXDoubleNode(NodeData *ptr, NXFile file) : base(ptr, file)
{
}
public NXInt64Node(NodeData *ptr, NXFile file) : base(ptr, file)
{
}
public void Load(string pPath)
{
DateTime Start = DateTime.Now;
Logger.WriteLog(Logger.LogTypes.NX, "Caching NX files...");
Equips = new Dictionary<int, EquipData>();
Maps = new Dictionary<int, Map>();
Mobs = new Dictionary<int, MobData>();
TamingMobs = new Dictionary<int, TamingMobData>();
CharacterNX = new NXFile(pPath + "\\Character.NX");
//EtcNX = new NXFile("\\Etc.NX");
//ItemNX = new NXFile("\\Item.NX");
MobNX = new NXFile(pPath + "\\Mob.NX");
MapNX = new NXFile(pPath + "\\Map.NX");
//QuestNX = new NXFile("\\Quest.NX");
//ReactorNX = new NXFile("\\Reactor.NX");
//SkillNX = new NXFile("\\Skill.NX");
//StringNX = new NXFile("\\String.NX");
//TamingMobNX = new NXFile("\\TamingMob.NX");
LoadMobs();
LoadMaps();
LoadEquips();
LoadTamingMobs();
CharacterNX.Dispose();
MapNX.Dispose();
MobNX.Dispose();
DateTime Finish = DateTime.Now;
Logger.WriteLog(Logger.LogTypes.NX, "Cached NX files in {0}ms.", (Finish-Start).Milliseconds);
}
public void LoadFile()
{
_nxFile = new NXFile(TestFileLoader.LoadTestFile());
}
internal unsafe NXNode(NodeData *ptr, NXFile file)
{
_nodeData = ptr;
_file = file;
}
public void DisposeFile()
{
_nxFile.Dispose();
_nxFile = null;
}
public void LoadFile()
{
_nxFile = new NXFile(TestFileLoader.LoadTestFile());
}
internal unsafe NXNode(NodeData *ptr, NXFile file)
{
_nodeData = ptr;
_file = file;
_childinit = _nodeData->ChildCount == 0;
}
internal unsafe NXLazyValuedNode(NodeData *ptr, NXFile file) : base(ptr, file)
{
}
internal NXValuedNode(string name, NXNode parent, NXFile file, T value, ushort childCount, uint firstChildId) : base(name, parent, file, childCount, firstChildId)
{
_value = value;
}
private static void LoadNX()
{
MapNx = new NXFile(@"C:\Nexon\NX 83\Map.nx");
}
public void DisposeFile()
{
_nxFile.Dispose();
_nxFile = null;
}
public CachedItems(NXFile dataFile)
: base()
{
foreach (NXNode categoryNode in dataFile.ResolvePath("/Character"))
{
if (categoryNode.Name == "Afterimage" || categoryNode.Name == "Face" || categoryNode.Name == "Hair" || categoryNode.Name.Contains(".img"))
{
continue;
}
foreach (NXNode equipNode in categoryNode)
{
MapleData.InfoNode = equipNode["info"];
Item item = new Item();
item.MapleID = int.Parse(equipNode.Name.Replace(".img", ""));
item.IsCash = MapleData.GetBool("cash");
item.SalePrice = MapleData.GetInt("price");
item.MaxUpgradesAvailable = MapleData.GetByte("tuc");
item.RequiredLevel = MapleData.GetShort("reqLevel");
item.RequiredJob = MapleData.GetShort("reqJob");
item.RequiredStrength = MapleData.GetShort("reqSTR");
item.RequiredDexterity = MapleData.GetShort("reqDEX");
item.RequiredIntelligence = MapleData.GetShort("reqINT");
item.RequiredLuck = MapleData.GetShort("reqLUK");
item.Strength = MapleData.GetShort("incSTR");
item.Dexterity = MapleData.GetShort("incDEX");
item.Intelligence = MapleData.GetShort("incINT");
item.Luck = MapleData.GetShort("incLUK");
item.MP = MapleData.GetShort("incHP");
item.MP = MapleData.GetShort("incMP");
item.WeaponAttack = MapleData.GetShort("incPAD");
item.WeaponDefense = MapleData.GetShort("incPDD");
item.MagicAttack = MapleData.GetShort("incMAD");
item.MagicDefense = MapleData.GetShort("incMDD");
item.Speed = MapleData.GetShort("incSpeed");
item.Jump = MapleData.GetShort("incJump");
item.Accuracy = MapleData.GetShort("incACC");
item.Avoidability = MapleData.GetShort("incEVA");
this.Add(item);
}
}
foreach (NXNode categoryNode in dataFile.ResolvePath("/Item"))
{
if (categoryNode.Name == "Pet" || categoryNode.Name == "Special")
{
continue;
}
foreach (NXNode containNode in categoryNode)
{
foreach (NXNode itemNode in containNode)
{
Item item = new Item();
item.MapleID = int.Parse(itemNode.Name
.Replace(".img", ""));
if (!itemNode.ContainsChild("info"))
{
item.MaxPerStack = 1;
item.IsCash = false;
this.Add(item);
}
else
{
MapleData.InfoNode = itemNode["info"];
item.MesoReward = MapleData.GetInt("meso");
item.IsCash = MapleData.GetBool("cash");
item.MaxPerStack = MapleData.GetShort("maxSlot");
item.SalePrice = MapleData.GetInt("price");
item.Success = MapleData.GetInt("success");
item.BreakItem = MapleData.GetInt("cursed");
item.IStrength = MapleData.GetShort("incSTR");
item.IDexterity = MapleData.GetShort("incDEX");
item.IIntelligence = MapleData.GetShort("incINT");
item.ILuck = MapleData.GetShort("incLUK");
item.IHP = MapleData.GetShort("incMHP");
item.IMP = MapleData.GetShort("incMMP");
item.IWeaponAttack = MapleData.GetShort("incPAD");
item.IMagicAttack = MapleData.GetShort("incMAD");
item.IWeaponDefense = MapleData.GetShort("incPDD");
item.IMagicDefense = MapleData.GetShort("incMDD");
item.IAccuracy = MapleData.GetShort("incACC");
item.IAvoidability = MapleData.GetShort("incEVA");
item.IJump = MapleData.GetShort("incJump");
item.ISpeed = MapleData.GetShort("incSpeed");
if (itemNode.ContainsChild("spec"))
{
MapleData.InfoNode = itemNode["spec"];
item.CMoveTo = MapleData.GetInt("moveTo");
byte cureFlags = 0x00;
if (itemNode["spec"].ContainsChild("curse"))
{
cureFlags += 0x01;
}
if (itemNode["spec"].ContainsChild("seal"))
{
cureFlags += 0x02;
}
if (itemNode["spec"].ContainsChild("weakness"))
{
cureFlags += 0x04;
}
if (itemNode["spec"].ContainsChild("darkness"))
{
cureFlags += 0x08;
}
if (itemNode["spec"].ContainsChild("poison"))
{
cureFlags += 0x10;
}
item.CFlags = cureFlags;
item.CHP = MapleData.GetShort("hp");
item.CMP = MapleData.GetShort("mp");
item.CHPPercentage = MapleData.GetShort("hpR");
item.CMPPercentage = MapleData.GetShort("mpR");
item.CSpeed = MapleData.GetShort("speed");
item.CAvoid = MapleData.GetShort("eva");
item.CAccuracy = MapleData.GetShort("acc");
item.CWeaponAttack = MapleData.GetShort("pad");
item.CMagicAttack = MapleData.GetShort("mad");
item.CBuffTime = MapleData.GetInt("time");
}
if (itemNode.ContainsChild("mob"))
{
item.CSummons = new List <MobSummon>();
foreach (NXNode summonNode in itemNode["mob"])
{
MapleData.InfoNode = summonNode;
MobSummon summon = new MobSummon();
summon.MapleID = MapleData.GetInt("id");
summon.Probability = MapleData.GetByte("prob");
item.CSummons.Add(summon);
}
}
this.Add(item);
}
}
}
}
}
public CachedFields(NXFile dataFile)
: base()
{
foreach (NXNode categoryNode in dataFile.ResolvePath("/Map/Map"))
{
if (categoryNode.Name == "AreaCode.img")
{
continue;
}
foreach (NXNode mapNode in categoryNode)
{
MapleData.InfoNode = mapNode["info"];
Field map = new Field();
map.MapleID = int.Parse(mapNode.Name.Replace(".img", ""));
map.ForcedReturnMapID = MapleData.GetInt("forcedReturn");
map.ReturnMapID = MapleData.GetInt("returnMap");
map.SpawnRate = MapleData.GetFloat("mobRate");
map.IsTown = MapleData.GetBool("town");
map.HasClock = MapleData.GetBool("clock");
if (mapNode.ContainsChild("portal"))
{
foreach (NXNode portalNode in mapNode["portal"])
{
MapleData.InfoNode = portalNode;
Portal portal = new Portal();
portal.ID = byte.Parse(portalNode.Name);
portal.Label = MapleData.GetString("pn");
portal.DestinationFieldID = MapleData.GetInt("tm");
portal.DestinationLabel = MapleData.GetString("tn");
portal.Position = new Position(MapleData.GetInt("x"), MapleData.GetInt("y"));
map.Portals.Add(portal);
}
}
if (mapNode.ContainsChild("life"))
{
int count = -1;
foreach (NXNode lifeNode in mapNode["life"])
{
count++;
MapleData.InfoNode = lifeNode;
string type = MapleData.GetString("type");
int mapleId = int.Parse(MapleData.GetString("id"));
Position position = new Position(MapleData.GetInt("x"), MapleData.GetInt("y"));
short foothold = MapleData.GetShort("fh");
short minimumClickX = MapleData.GetShort("rx0");
short maximumClickX = MapleData.GetShort("rx1");
int respawnTime = MapleData.GetInt("respawnTime");
bool facesLeft = MapleData.GetBool("f");
switch (type)
{
case "n":
map.Npcs.Add(new Npc(type, count, mapleId, position, foothold, minimumClickX, maximumClickX, respawnTime, facesLeft));
break;
case "m":
case "r":
map.SpawnPoints.Add(new SpawnPoint(type, count, mapleId, position, foothold, minimumClickX, maximumClickX, respawnTime, facesLeft));
break;
}
}
}
this.Add(map);
}
}
}
/// <summary>
/// Constructs a lazily-loaded node.
/// </summary>
/// <param name="name"> The name of the lazily-loaded node. </param>
/// <param name="parent"> The parent node of the lazily-loaded node. </param>
/// <param name="file"> The containing file of the lazily-loaded node. </param>
/// <param name="childCount"> The number of children this lazily-loaded node contains. </param>
/// <param name="firstChildId"> The Node ID of the first child of this node. </param>
protected NXLazyValuedNode(string name, NXNode parent, NXFile file, ushort childCount, uint firstChildId) : base(name, parent, file, childCount, firstChildId)
{
}
