public override bool OnInitialize()
        {
            base.OnInitialize();

            if (WorkingUncompressed.Length != sizeof(ClassicFighterData))
            {
                throw new Exception("Wrong size for ClassicFighterNode");
            }

            // Copy the data from the address
            ClassicFighterData *ptr = (ClassicFighterData *)WorkingUncompressed.Address;

            _header._fighterID     = ptr->_fighterID;
            _header._fighterstatus = ptr->_fighterstatus;
            _header._unknown02     = ptr->_unknown02;
            _header._unknown03     = ptr->_unknown03;
            _header._fighterscale  = ptr->_fighterscale;

            if (_name == null)
            {
                var fighter = Fighter.Fighters.Where(s => s.ID == FighterID).FirstOrDefault();
                _name = (fighter == null ? "" : fighter.Name + " ") + "(0x" + FighterID.ToString("X2") + ")";
            }

            return(true);
        }
        public override void OnPopulate()
        {
            ClassicFighterData *ptr = &((ClassicStageBlock *)WorkingUncompressed.Address)->_opponent1;

            for (int i = 0; i < 3; i++)
            {
                DataSource source = new DataSource(ptr, sizeof(ClassicFighterData));
                new ClassicFighterNode().Initialize(this, source);
                ptr++;
            }
        }
        public override void OnRebuild(VoidPtr address, int length, bool force)
        {
            // Copy the data back to the address
            ClassicStageBlock *dataPtr = (ClassicStageBlock *)address;

            dataPtr->_stages._unknown00 = data._unknown00;
            dataPtr->_stages._stageID1  = data._stageID1;
            dataPtr->_stages._stageID2  = data._stageID2;
            dataPtr->_stages._stageID3  = data._stageID3;
            dataPtr->_stages._stageID4  = data._stageID4;

            // Rebuild children using new address
            ClassicFighterData *ptr = &((ClassicStageBlock *)address)->_opponent1;

            for (int i = 0; i < Children.Count; i++)
            {
                Children[i].Rebuild(ptr, sizeof(ClassicFighterData), true);
                ptr++;
            }
        }
        public override void OnRebuild(VoidPtr address, int length, bool force)
        {
            // Copy the data back to the address
            ClassicFighterData *header_ptr = (ClassicFighterData *)address;

            header_ptr->_fighterID     = _header._fighterID;
            header_ptr->_fighterstatus = _header._fighterstatus;
            header_ptr->_unknown02     = _header._unknown02;
            header_ptr->_unknown03     = _header._unknown03;
            header_ptr->_fighterscale  = _header._fighterscale;

            // Rebuild children using new address
            VoidPtr ptr = address + 8;

            for (int i = 0; i < Children.Count; i++)
            {
                Children[i].Rebuild(ptr, sizeof(ClassicDifficultyData), true);
                ptr += sizeof(ClassicDifficultyData);
            }
        }