Beispiel #1
0
        public static HitBox LoadFromStorage(Storage.HitBox storageBox, Storage.Character storageCharacter)
        {
            HitBox newBox = new HitBox();

            // Populate boxes
            newBox.boxesPerFrame = new List <Box>(storageBox.boxIds.Length);
            newBox.enabledFrames = new List <bool>(storageBox.boxIds.Length);
            foreach (int boxId in storageBox.boxIds)
            {
                if (boxId == Box.invalidBoxId)
                {
                    newBox.enabledFrames.Add(false);
                    newBox.boxesPerFrame.Add(new Box());
                }
                else
                {
                    newBox.enabledFrames.Add(true);
                    newBox.boxesPerFrame.Add(Box.LoadFromStorage(storageCharacter.boxes[boxId]));
                }
            }

            newBox.param = GenericParameter.LoadFromStorage(storageCharacter.genericParameters[storageBox.paramId]);

            return(newBox);
        }
        public static ConditionalEvent LoadFromStorage(Storage.GenericEvent storageEvent, Storage.Character storageCharacter)
        {
            ConditionalEvent newEvent = new ConditionalEvent();

            // Populate subjects
            if (storageEvent.subjectIds != null)
            {
                newEvent.subjects = new List <GenericParameter>(storageEvent.subjectIds.Length);
                foreach (int subjectId in storageEvent.subjectIds)
                {
                    newEvent.subjects.Add(GenericParameter.LoadFromStorage(storageCharacter.genericParameters[subjectId]));
                }
            }
            else
            {
                newEvent.subjects = new List <GenericParameter>();
            }

            // Populate conditions
            if (storageEvent.conditionIds != null)
            {
                newEvent.conditions = new List <GenericParameter>(storageEvent.conditionIds.Length);
                foreach (int conditionId in storageEvent.conditionIds)
                {
                    newEvent.conditions.Add(GenericParameter.LoadFromStorage(storageCharacter.genericParameters[conditionId]));
                }
            }
            else
            {
                newEvent.conditions = new List <GenericParameter>();
            }

            // Populate events
            if (storageEvent.eventIds != null)
            {
                newEvent.events = new List <GenericParameter>(storageEvent.eventIds.Length);
                foreach (int eventId in storageEvent.eventIds)
                {
                    newEvent.events.Add(GenericParameter.LoadFromStorage(storageCharacter.genericParameters[eventId]));
                }
            }
            else
            {
                newEvent.events = new List <GenericParameter>();
            }

            return(newEvent);
        }
        public static ConditionalEvent LoadFromStorage(Storage.GenericEvent storageEvent, Storage.HUD storageHud)
        {
            ConditionalEvent newEvent = new ConditionalEvent();

            // Populate conditions
            newEvent.conditions = new List <GenericParameter>(storageEvent.conditionIds.Length);
            foreach (int conditionId in storageEvent.conditionIds)
            {
                newEvent.conditions.Add(GenericParameter.LoadFromStorage(storageHud.genericParameters[conditionId]));
            }

            // Populate events
            newEvent.events = new List <GenericParameter>(storageEvent.eventIds.Length);
            foreach (int eventId in storageEvent.eventIds)
            {
                newEvent.events.Add(GenericParameter.LoadFromStorage(storageHud.genericParameters[eventId]));
            }

            return(newEvent);
        }