BrawlCrate.NodeWrappers.MDefWrapper Class Reference

Inheritance diagram for BrawlCrate.NodeWrappers.MDefWrapper:

Public Member Functions
	MDefWrapper ()
void	LoadModel ()
void	SaveEvents ()
void	SaveParameters ()
void	SaveEventSyntax ()
void	SaveAttributes ()
void	SaveRequirements ()
void	SaveEnums ()
void	SaveMovesetData ()
Public Member Functions inherited from BrawlCrate.NodeWrappers.GenericWrapper
	GenericWrapper (IWin32Window owner)
	GenericWrapper ()
virtual void	Sort ()
void	MoveUp ()
virtual void	MoveUp (bool select)
void	MoveDown ()
virtual void	MoveDown (bool select)
void	DeleteSelected ()
void	ExportSelected ()
virtual string	Export ()
virtual void	OnExport (string outPath)
virtual void	Replace ()
virtual void	OnReplace (string inStream)
void	Restore ()
virtual void	Delete ()
void	Rename ()
virtual ResourceNode	Duplicate ()
virtual ResourceNode	Duplicate (bool changeName)
Public Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
void	Link (ResourceNode res)
void	Unlink ()

Static Protected Member Functions
static void	LoadModelAction (object sender, EventArgs e)
static void	SaveDataAction (object sender, EventArgs e)
Static Protected Member Functions inherited from BrawlCrate.NodeWrappers.GenericWrapper
static void	MoveUpAction (object sender, EventArgs e)
static void	MoveDownAction (object sender, EventArgs e)
static void	ExportAction (object sender, EventArgs e)
static void	ExportSelectedAction (object sender, EventArgs e)
static void	DeleteSelectedAction (object sender, EventArgs e)
static void	DuplicateAction (object sender, EventArgs e)
static void	ReplaceAction (object sender, EventArgs e)
static void	RestoreAction (object sender, EventArgs e)
static void	DeleteAction (object sender, EventArgs e)
static void	RenameAction (object sender, EventArgs e)
static void	SortAction (object sender, EventArgs e)
Static Protected Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
static T	GetInstance< T > ()
static IEnumerable< T >	GetInstances< T > ()

Properties
override string	ExportFilter [get]
Properties inherited from BrawlCrate.NodeWrappers.GenericWrapper
virtual ContextMenuStrip	MultiSelectMenuStrip [get]
virtual string	DefaultName [get]
virtual string	ExportFilter [get]
virtual string	ImportFilter [get]
virtual string	ReplaceFilter [get]
Properties inherited from BrawlCrate.NodeWrappers.BaseWrapper
ResourceNode	Resource [get]
virtual ? Color	DefaultBackColor [get]
virtual ? Color	DefaultForeColor [get]
Properties inherited from BrawlCrate.NodeWrappers.MultiSelectableWrapper
ContextMenuStrip	MultiSelectMenuStrip [get]

Additional Inherited Members
Static Public Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
static BaseWrapper[]	GetAllNodes (BaseWrapper root)
static BaseWrapper	Wrap (ResourceNode node)
static BaseWrapper	Wrap (IWin32Window owner, ResourceNode node)
Static Public Attributes inherited from BrawlCrate.NodeWrappers.BaseWrapper
static IWin32Window	_owner
Protected Member Functions inherited from BrawlCrate.NodeWrappers.BaseWrapper
	BaseWrapper ()
Protected Attributes inherited from BrawlCrate.NodeWrappers.BaseWrapper
bool	_discovered
ResourceNode	_resource
Static Protected Attributes inherited from BrawlCrate.NodeWrappers.BaseWrapper
static readonly ContextMenuStrip	_emptyMenu = new ContextMenuStrip()

Constructor & Destructor Documentation

MDefWrapper()

BrawlCrate.NodeWrappers.MDefWrapper.MDefWrapper ( )

inline

        {
            ContextMenuStrip = _menu;
        }

Member Function Documentation

LoadModel()

void BrawlCrate.NodeWrappers.MDefWrapper.LoadModel ( )

inline

        {
            OpenFileDialog o = new OpenFileDialog();
            o.Filter = "All Available Formats (*.mdl0, *.pac)|*.mdl0;*.pac|" + "MDL0 Raw Model (*.mdl0)|*.mdl0|" +
                       "PAC Archive (*.pac)|*.pac";
            o.Title = "Please select a file to load a model from.";
            if (o.ShowDialog() == DialogResult.OK)
            {
                if (o.FileName.EndsWith(".pac", StringComparison.OrdinalIgnoreCase))
                {
                    ResourceNode r = (ARCNode) NodeFactory.FromFile(null, o.FileName);
                    for (int i = 0; i < 3; i++)
                    {
                        if (r.Children.Count > 0)
                        {
                            r = r.Children[0];
                        }
                    }
 
                    if (r is MDL0Node)
                    {
                        if ((((MoveDefNode) _resource)._model = (MDL0Node) r) != null)
                        {
                            ((MoveDefNode) _resource)._model.Populate();
                        }
                    }
                }
                else if (o.FileName.EndsWith(".mdl0", StringComparison.OrdinalIgnoreCase))
                {
                    if ((((MoveDefNode) _resource)._model = (MDL0Node) NodeFactory.FromFile(null, o.FileName)) != null)
                    {
                        ((MoveDefNode) _resource)._model.Populate();
                    }
                }
            }
        }

LoadModelAction()

static void BrawlCrate.NodeWrappers.MDefWrapper.LoadModelAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDefWrapper>().LoadModel();
        }

SaveAttributes()

void BrawlCrate.NodeWrappers.MDefWrapper.SaveAttributes ( )

inline

        {
            if (!Directory.Exists(Application.StartupPath + "/MovesetData"))
            {
                Directory.CreateDirectory(Application.StartupPath + "/MovesetData");
            }
 
            MoveDefNode node = _resource as MoveDefNode;
 
            if (node.iRequirements == null ||
                node.AttributeArray == null ||
                node.iAirGroundStats == null ||
                node.iCollisionStats == null)
            {
                node.LoadOtherData();
            }
 
            bool go = true;
            string attributes = Application.StartupPath + "/MovesetData/Attributes.txt";
 
            if (File.Exists(attributes))
            {
                if (MessageBox.Show("Do you want to overwrite Attributes.txt in the MovesetData folder?",
                    "Overwrite Permission", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                using (StreamWriter file = new StreamWriter(attributes))
                {
                    foreach (AttributeInfo i in node.AttributeArray)
                    {
                        file.WriteLine(i._name);
                        file.WriteLine(i._description);
                        file.WriteLine(i._type);
                        file.WriteLine();
                    }
                }
            }
 
            go = true;
 
            if (!Directory.Exists(Application.StartupPath + "/MovesetData/CharSpecific"))
            {
                Directory.CreateDirectory(Application.StartupPath + "/MovesetData/CharSpecific");
            }
 
            string Params = Application.StartupPath + "/MovesetData/CharSpecific/" + _resource.Parent.Name + ".txt";
 
            if (File.Exists(Params))
            {
                if (MessageBox.Show(
                    "Do you want to overwrite " + _resource.Parent.Name +
                    ".txt in the MovesetData/CharSpecific folder?", "Overwrite Permission",
                    MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                using (StreamWriter file = new StreamWriter(Params))
                {
                    foreach (KeyValuePair<string, SectionParamInfo> i in node.Params)
                    {
                        file.WriteLine(i.Key);
                        file.WriteLine(i.Value._newName);
                        foreach (AttributeInfo a in i.Value._attributes)
                        {
                            file.WriteLine(a._name);
                            file.WriteLine(a._description);
                            file.WriteLine(a._type);
                            file.WriteLine();
                        }
 
                        file.WriteLine();
                    }
                }
            }
        }

SaveDataAction()

static void BrawlCrate.NodeWrappers.MDefWrapper.SaveDataAction ( object  sender, EventArgs  e  )

inlinestaticprotected

        {
            GetInstance<MDefWrapper>().SaveMovesetData();
        }

SaveEnums()

void BrawlCrate.NodeWrappers.MDefWrapper.SaveEnums ( )

inline

        {
            if (!Directory.Exists(Application.StartupPath + "/MovesetData"))
            {
                Directory.CreateDirectory(Application.StartupPath + "/MovesetData");
            }
 
            MoveDefNode node = _resource as MoveDefNode;
 
            if (node.iRequirements == null ||
                node.AttributeArray == null ||
                node.iAirGroundStats == null ||
                node.iCollisionStats == null)
            {
                node.LoadOtherData();
            }
 
            if (MoveDefNode.EventDictionary == null)
            {
                MoveDefNode.LoadEventDictionary();
            }
 
            bool go = true;
            string airground = Application.StartupPath + "/MovesetData/AirGroundStats.txt";
            string collision = Application.StartupPath + "/MovesetData/CollisionStats.txt";
            string gfx = Application.StartupPath + "/MovesetData/GFXFiles.txt";
            string enums = Application.StartupPath + "/MovesetData/Enums.txt";
 
            if (File.Exists(airground))
            {
                if (MessageBox.Show("Do you want to overwrite AirGroundStats.txt in the MovesetData folder?",
                    "Overwrite Permission", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                using (StreamWriter file = new StreamWriter(airground))
                {
                    foreach (string i in node.iAirGroundStats)
                    {
                        file.WriteLine(i);
                    }
                }
            }
 
            if (File.Exists(collision))
            {
                if (MessageBox.Show("Do you want to overwrite CollisionStats.txt in the MovesetData folder?",
                    "Overwrite Permission", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                using (StreamWriter file = new StreamWriter(collision))
                {
                    foreach (string i in node.iCollisionStats)
                    {
                        file.WriteLine(i);
                    }
                }
            }
 
            if (File.Exists(gfx))
            {
                if (MessageBox.Show("Do you want to overwrite GFXFiles.txt in the MovesetData folder?",
                    "Overwrite Permission", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                using (StreamWriter file = new StreamWriter(gfx))
                {
                    foreach (string i in node.iGFXFiles)
                    {
                        file.WriteLine(i);
                    }
                }
            }
 
            if (File.Exists(enums))
            {
                if (MessageBox.Show("Do you want to overwrite Enums.txt in the MovesetData folder?",
                    "Overwrite Permission", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                //list of enum dictionaries
                List<Dictionary<int, List<string>>> EnumList = new List<Dictionary<int, List<string>>>();
                //enum index, event id, param index list
                Dictionary<int, Dictionary<long, List<int>>> EnumIds =
                    new Dictionary<int, Dictionary<long, List<int>>>();
                //remap events and enums
                foreach (ActionEventInfo info in MoveDefNode.EventDictionary.Values)
                {
                    if (info.Enums != null && info.Enums.Count > 0)
                    {
                        List<int> p = new List<int>();
 
                        bool has = false;
                        int index = -1;
                        foreach (Dictionary<int, List<string>> t in EnumList)
                        {
                            bool match = true;
                            index++;
                            foreach (int g in info.Enums.Keys)
                            {
                                if (t.ContainsKey(g))
                                {
                                    int r = 0;
                                    foreach (string s in t[g])
                                    {
                                        if (s != info.Enums[g][r++])
                                        {
                                            match = false;
                                            break;
                                        }
                                    }
                                }
                                else
                                {
                                    match = false;
                                }
                            }
 
                            if (match)
                            {
                                has = true;
                                break;
                            }
 
                            continue;
                        }
 
                        if (!has)
                        {
                            EnumList.Add(info.Enums);
                            index = EnumList.Count - 1;
                        }
 
                        if (!EnumIds.ContainsKey(index))
                        {
                            EnumIds.Add(index, new Dictionary<long, List<int>>());
                        }
 
                        foreach (int i in info.Enums.Keys)
                        {
                            p.Add(i);
                        }
 
                        EnumIds[index].Add(info.idNumber, p);
                    }
                }
 
                using (StreamWriter file = new StreamWriter(enums))
                {
                    int i = 0;
                    foreach (Dictionary<int, List<string>> d in EnumList)
                    {
                        Dictionary<long, List<int>> events = EnumIds[i];
                        foreach (KeyValuePair<long, List<int>> ev in events)
                        {
                            file.WriteLine(Helpers.Hex8(ev.Key));
                            foreach (int v in ev.Value)
                            {
                                file.WriteLine(v);
                            }
 
                            file.WriteLine();
                        }
 
                        file.WriteLine();
                        foreach (int x in d.Keys)
                        {
                            if (d[x] != null && d[x].Count > 0)
                            {
                                foreach (string value in d[x])
                                {
                                    file.WriteLine(value);
                                }
                            }
                        }
 
                        file.WriteLine();
                        i++;
                    }
                }
            }
        }

SaveEvents()

void BrawlCrate.NodeWrappers.MDefWrapper.SaveEvents ( )

inline

        {
            if (!Directory.Exists(Application.StartupPath + "/MovesetData"))
            {
                Directory.CreateDirectory(Application.StartupPath + "/MovesetData");
            }
 
            MoveDefNode node = _resource as MoveDefNode;
 
            if (MoveDefNode.EventDictionary == null)
            {
                MoveDefNode.LoadEventDictionary();
            }
 
            bool go = true;
            string events = Application.StartupPath + "/MovesetData/Events.txt";
            if (File.Exists(events))
            {
                if (MessageBox.Show("Do you want to overwrite Events.txt in the MovesetData folder?",
                    "Overwrite Permission", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                using (StreamWriter file = new StreamWriter(events))
                {
                    foreach (ActionEventInfo info in MoveDefNode.EventDictionary.Values)
                    {
                        file.WriteLine(Helpers.Hex8(info.idNumber));
                        file.WriteLine(info._name);
                        file.WriteLine(info._description);
                        string s = "";
                        foreach (int i in info.defaultParams)
                        {
                            s += i;
                        }
 
                        file.WriteLine(s);
                        file.WriteLine();
                    }
                }
            }
        }

SaveEventSyntax()

void BrawlCrate.NodeWrappers.MDefWrapper.SaveEventSyntax ( )

inline

        {
            if (!Directory.Exists(Application.StartupPath + "/MovesetData"))
            {
                Directory.CreateDirectory(Application.StartupPath + "/MovesetData");
            }
 
            MoveDefNode node = _resource as MoveDefNode;
 
            if (MoveDefNode.EventDictionary == null)
            {
                MoveDefNode.LoadEventDictionary();
            }
 
            bool go = true;
            string syntax = Application.StartupPath + "/MovesetData/EventSyntax.txt";
 
            if (File.Exists(syntax))
            {
                if (MessageBox.Show("Do you want to overwrite EventSyntax.txt in the MovesetData folder?",
                    "Overwrite Permission", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                using (StreamWriter file = new StreamWriter(syntax))
                {
                    foreach (ActionEventInfo info in MoveDefNode.EventDictionary.Values)
                    {
                        if (string.IsNullOrEmpty(info._syntax))
                        {
                            continue;
                        }
 
                        file.WriteLine(Helpers.Hex8(info.idNumber));
                        file.WriteLine(info._syntax);
                        file.WriteLine();
                    }
                }
            }
        }

SaveMovesetData()

void BrawlCrate.NodeWrappers.MDefWrapper.SaveMovesetData ( )

inline

        {
            SaveEvents();
            SaveParameters();
            SaveEventSyntax();
            SaveAttributes();
            SaveRequirements();
            SaveEnums();
        }

SaveParameters()

void BrawlCrate.NodeWrappers.MDefWrapper.SaveParameters ( )

inline

        {
            if (!Directory.Exists(Application.StartupPath + "/MovesetData"))
            {
                Directory.CreateDirectory(Application.StartupPath + "/MovesetData");
            }
 
            MoveDefNode node = _resource as MoveDefNode;
 
            if (MoveDefNode.EventDictionary == null)
            {
                MoveDefNode.LoadEventDictionary();
            }
 
            bool go = true;
            string parameters = Application.StartupPath + "/MovesetData/Parameters.txt";
 
            if (File.Exists(parameters))
            {
                if (MessageBox.Show("Do you want to overwrite Parameters.txt in the MovesetData folder?",
                    "Overwrite Permission", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                using (StreamWriter file = new StreamWriter(parameters))
                {
                    foreach (ActionEventInfo info in MoveDefNode.EventDictionary.Values)
                    {
                        if (info.Params != null && info.Params.Length > 0)
                        {
                            file.WriteLine(Helpers.Hex8(info.idNumber));
                            for (int i = 0; i < info.Params.Length; i++)
                            {
                                file.WriteLine(info.Params[i]);
                                if (info.pDescs.Length > i)
                                {
                                    file.WriteLine(info.pDescs[i]);
                                }
                                else
                                {
                                    file.WriteLine();
                                }
                            }
 
                            file.WriteLine();
                        }
                    }
                }
            }
        }

SaveRequirements()

void BrawlCrate.NodeWrappers.MDefWrapper.SaveRequirements ( )

inline

        {
            if (!Directory.Exists(Application.StartupPath + "/MovesetData"))
            {
                Directory.CreateDirectory(Application.StartupPath + "/MovesetData");
            }
 
            MoveDefNode node = _resource as MoveDefNode;
 
            if (node.iRequirements == null ||
                node.AttributeArray == null ||
                node.iAirGroundStats == null ||
                node.iCollisionStats == null)
            {
                node.LoadOtherData();
            }
 
            bool go = true;
            string requirements = Application.StartupPath + "/MovesetData/Requirements.txt";
 
            if (File.Exists(requirements))
            {
                if (MessageBox.Show("Do you want to overwrite Requirements.txt in the MovesetData folder?",
                    "Overwrite Permission", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    go = true;
                }
                else
                {
                    go = false;
                }
            }
            else
            {
                go = true;
            }
 
            if (go)
            {
                using (StreamWriter file = new StreamWriter(requirements))
                {
                    foreach (string i in node.iRequirements)
                    {
                        file.WriteLine(i);
                    }
                }
            }
        }

Property Documentation

ExportFilter

override string BrawlCrate.NodeWrappers.MDefWrapper.ExportFilter

get

---

The documentation for this class was generated from the following file:

• BrawlCrate/NodeWrappers/MDefWrapper.cs