protected virtual void AddCommand(object sender, RoutedEventArgs e)
        {
            if (WorkingType != null)
            {
                //New script

                Console.WriteLine(WorkingType);

                var newscript = new Script(App.OpenedFiles.BACFile.VFXScripts.Count, "New Script")
                {
                    FirstHitboxFrame = 0,
                    LastHitboxFrame  = 0,
                    IASAFrame        = 0,
                    TotalFrames      = 100,
                    UnknownFlags1    = 0,
                    UnknownFlags2    = 0,
                    UnknownFlags3    = 0
                };


                foreach (var type in Enum.GetValues(typeof(CommandListType)))
                {
                    var cmd = CommandListFactory.ByType((CommandListType)type);
                    cmd.Type = (CommandListType)type;
                    newscript.CommandLists.Add(cmd);
                }
                switch (WorkingType)
                {
                case "VFXScripts":
                    App.OpenedFiles.BACFile.VFXScripts.Add(newscript);
                    break;

                case "Scripts":
                    App.OpenedFiles.BACFile.Scripts.Add(newscript);
                    break;

                default:
                    Console.WriteLine("No valid ID"); break;
                }
                return;
            }

            try
            {
                ListCollectionView lc = ListCollectionView;

                if (!lc.CanAddNew)
                {
                    return;
                }

                var newObj = lc.AddNew();
                CheckScriptIndex(newObj);
                ScrollCurrent();
            }
            catch
            {
                MessageBox.Show("This feature is unavailable at this time.");
            }
        }
Beispiel #2
0
        public static void Run(string code, string location)
        {
            Logger.GetInstance().LogOn();
            InterVariables.GetInstance().Clear();
            RuntimeVariables.GetInstance().InitializeInnerVariables();
            RuntimeVariables.GetInstance().Actualize("location", location);

            try
            {
                List <Token>    tokens   = Reader.CreateTokenlist(code);
                List <ICommand> commands = CommandListFactory.Build(tokens);
                RunCommands(commands);
            }
            catch (Uroboros.syntax.SyntaxErrorException te)
            {
                Logger.GetInstance().LogSyntaxError(te.GetMessage());
            }
        }
Beispiel #3
0
        private static void readScript(BinaryReader inFile, Script script, BCMFile bcm, BACFile bac)
        {
            script.FirstHitboxFrame = inFile.ReadUInt16();
            script.LastHitboxFrame  = inFile.ReadUInt16();
            script.IASAFrame        = inFile.ReadUInt16();
            script.TotalFrames      = inFile.ReadUInt16();

            script.UnknownFlags1 = inFile.ReadUInt32();
            script.UnknownFlags2 = inFile.ReadUInt32();
            script.UnknownFlags3 = inFile.ReadUInt16();
            ushort CommandListCount = inFile.ReadUInt16();
            int    HeaderSize       = inFile.ReadInt32();
            var    baseoff          = inFile.BaseStream.Position;

            for (int j = 0; j < CommandListCount; j++)
            {
                inFile.BaseStream.Seek(baseoff + 12 * j);
                ushort type = inFile.ReadUInt16();
                var    cl   = CommandListFactory.ByType((CommandListType)type);
                cl.Type = (CommandListType)type;
                int cnt = inFile.ReadUInt16();
                for (int o = 0; o < cnt; o++)
                {
                    cl.Add(cl.GenerateCommand());
                }
                int frameoff = inFile.ReadInt32();
                int dataoff  = inFile.ReadInt32();
                inFile.BaseStream.Seek(baseoff + frameoff + 12 * j);
                foreach (BaseCommand cmd in cl)
                {
                    cmd.StartFrame = inFile.ReadUInt16();
                    cmd.EndFrame   = inFile.ReadUInt16();
                }
                inFile.BaseStream.Seek(baseoff + dataoff + 12 * j);
                foreach (BaseCommand cmd in cl)
                {
                    switch ((CommandListType)cl.Type)
                    {
                    case CommandListType.FLOW:
                        (cmd as FlowCommand).Type = (FlowCommand.FlowType)inFile.ReadInt16();
                        Util.LogUnkEnum((cmd as FlowCommand).Type, "script", script.Name);
                        (cmd as FlowCommand).Input = (Input)inFile.ReadUInt16();
                        Util.LogUnkEnum((cmd as FlowCommand).Input, "script", script.Name);
                        var index = inFile.ReadInt16();
                        if (index != -1)
                        {
                            (cmd as FlowCommand).TargetScript = bac.Scripts[index];
                        }
                        else
                        {
                            (cmd as FlowCommand).TargetScript = Script.NullScript;
                        }
                        (cmd as FlowCommand).TargetFrame = inFile.ReadInt16();
                        break;

                    case CommandListType.ANIMATION:
                        var ani = cmd as AnimationCommand;
                        ani.Animation = inFile.ReadInt16();
                        ani.Type      = (AnimationCommand.AnimationType)inFile.ReadByte();
                        Util.LogUnkEnum(ani.Type, "script", script.Name);
                        ani.Flags = (AnimationCommand.AnimationFlags)inFile.ReadByte();
                        Util.LogUnkEnum(ani.Flags, "script", script.Name);
                        ani.FromFrame = inFile.ReadInt16();
                        ani.ToFrame   = inFile.ReadInt16();
                        break;

                    case CommandListType.TRANSITION:
                        var transition = (TransitionCommand)cmd;
                        transition.Flag1  = inFile.ReadUInt16();
                        transition.Flag2  = inFile.ReadUInt16();
                        transition.Float1 = inFile.ReadSingle();
                        transition.Float2 = inFile.ReadSingle();
                        transition.Float3 = inFile.ReadSingle();
                        transition.Float4 = inFile.ReadSingle();
                        transition.Float5 = inFile.ReadSingle();
                        transition.Float6 = inFile.ReadSingle();
                        break;

                    case CommandListType.STATE:
                        var unk3 = cmd as StateCommand;
                        unk3.Flags = (StateCommand.StateFlags)inFile.ReadUInt32();
                        Util.LogUnkEnumFlags(unk3.Flags, "script", script.Name);
                        unk3.UnknownFlags2 = inFile.ReadUInt32();
                        break;

                    case CommandListType.SPEED:
                        (cmd as SpeedCommand).Multiplier = inFile.ReadSingle();
                        break;

                    case CommandListType.CANCELS:
                        (cmd as CancelCommand).Condition = (CancelCommand.CancelConditions)inFile.ReadUInt32();
                        Util.LogUnkEnumFlags((cmd as CancelCommand).Condition, "script", script.Name);
                        var d = inFile.ReadInt32();
                        if (d != -1 && d < bcm.CancelLists.Count)
                        {
                            (cmd as CancelCommand).CancelList = bcm.CancelLists[d];
                        }
                        break;

                    case CommandListType.HURTBOX:
                        var hurt = cmd as HurtboxCommand;
                        hurt.X            = inFile.ReadSingle();
                        hurt.Y            = inFile.ReadSingle();
                        hurt.Rotation     = inFile.ReadSingle();
                        hurt.Width        = inFile.ReadSingle();
                        hurt.Height       = inFile.ReadSingle();
                        hurt.FloatUnknown = inFile.ReadSingle();
                        hurt.Unknown1     = inFile.ReadUInt32();
                        hurt.Unused       = (Unused16)inFile.ReadUInt16();
                        hurt.Unknown4     = inFile.ReadByte();
                        hurt.Unknown5     = inFile.ReadSByte();
                        break;

                    case CommandListType.PHYSICS:
                        var physics = cmd as PhysicsCommand;
                        physics.VelX         = inFile.ReadSingle();
                        physics.VelY         = inFile.ReadSingle();
                        physics.Unk01        = inFile.ReadUInt32();
                        physics.PhysicsFlags = (PhysicsCommand.PFlags)inFile.ReadUInt32();
                        Util.LogUnkEnumFlags(physics.PhysicsFlags, "script", script.Name);
                        physics.AccX  = inFile.ReadSingle();
                        physics.AccY  = inFile.ReadSingle();
                        physics.Unk02 = inFile.ReadUInt64();
                        //cmd.Raw = inFile.ReadBytes(0x20);
                        break;

                    case CommandListType.ETC:
                        var etc = cmd as EtcCommand;
                        etc.Type = (EtcCommand.EtcCommandType)inFile.ReadUInt16();
                        Util.LogUnkEnum(etc.Type, "script", script.Name);
                        etc.ShortParam = inFile.ReadUInt16();
                        var arr = new int[7];
                        for (int tmp = 0; tmp < 7; tmp++)
                        {
                            arr[tmp] = inFile.ReadInt32();
                        }
                        etc.RawParams = arr;
                        //cmd.Raw = inFile.ReadBytes(30);
                        break;

                    case CommandListType.HITBOX:
                        var hit = cmd as HitboxCommand;
                        hit.X        = inFile.ReadSingle();
                        hit.Y        = inFile.ReadSingle();
                        hit.Rotation = inFile.ReadSingle();
                        hit.Width    = inFile.ReadSingle();
                        hit.Height   = inFile.ReadSingle();
                        hit.Unused   = (Unused32)inFile.ReadInt32();
                        hit.ID       = inFile.ReadSByte();
                        hit.Juggle   = inFile.ReadSByte();
                        hit.Type     = (HitboxCommand.HitboxType)inFile.ReadByte();
                        Util.LogUnkEnum(hit.Type, "script", script.Name);
                        hit.HitLevel = (HitboxCommand.HitLevelType)inFile.ReadByte();
                        Util.LogUnkEnum(hit.HitLevel, "script", script.Name);
                        hit.HitFlags = (HitboxCommand.Flags)inFile.ReadInt16();
                        Util.LogUnkEnumFlags(hit.HitFlags, "script", script.Name);
                        hit.UnknownByte1         = inFile.ReadSByte();
                        hit.UnknownByte2         = inFile.ReadSByte();
                        hit.Hits                 = inFile.ReadSByte();
                        hit.JugglePotential      = inFile.ReadSByte();
                        hit.JuggleIncrement      = inFile.ReadSByte();
                        hit.JuggleIncrementLimit = inFile.ReadSByte();
                        hit.HitboxEffect         = inFile.ReadSByte();
                        hit.UnknownByte3         = inFile.ReadSByte();
                        hit.Unused2              = (Unused16)inFile.ReadInt16();
                        var index2 = inFile.ReadInt32();
                        hit.HitboxDataSet = bac.HitboxTable[index2];
                        if (!hit.HitboxDataSet.Usage.Contains(script) && hit.Type != HitboxCommand.HitboxType.PROXIMITY)
                        {
                            hit.HitboxDataSet.Usage.Add(script);
                        }
                        break;

                    case CommandListType.INVINC:
                        var invinc = cmd as HurtNodeCommand;
                        invinc.Flags = (HurtNodeCommand.VulnerabilityFlags)inFile.ReadUInt32();
                        Util.LogUnkEnumFlags(invinc.Flags, "script", script.Name);
                        invinc.Location = (HurtNodeCommand.BodyParts)inFile.ReadUInt32();
                        invinc.Unk02    = inFile.ReadUInt16();
                        invinc.Unk03    = inFile.ReadUInt16();
                        invinc.Unk04    = inFile.ReadUInt16();
                        invinc.Unk05    = inFile.ReadUInt16();
                        break;

                    case CommandListType.TARGETLOCK:
                        var targetLock = (TargetLockCommand)cmd;
                        targetLock.Type = (TargetLockCommand.TargetLockType)inFile.ReadInt32();
                        var dmgScriptIndex = inFile.ReadInt32();
                        targetLock.DmgScript = dmgScriptIndex > -1 ? bac.Scripts.First(x => x.Index == dmgScriptIndex) : Script.NullScript;
                        targetLock.Unknown2  = inFile.ReadInt32();
                        targetLock.Unknown3  = inFile.ReadInt32();
                        break;

                    case CommandListType.SFX:
                        var sfx = (SfxCommand)cmd;
                        sfx.Type     = (SfxType)inFile.ReadUInt16();
                        sfx.Sound    = inFile.ReadInt16();
                        sfx.Unknown1 = inFile.ReadUInt32();
                        sfx.Unknown2 = inFile.ReadUInt32();
                        sfx.Unknown3 = inFile.ReadUInt32();
                        break;

                    default:
                        cmd.Raw = inFile.ReadBytes(8);
                        break;
                    }
                }
                script.CommandLists.Add(cl);
            }
            for (int i = 0; i < 13; i++)
            {
                if (script.CommandLists.Count <= i || script.CommandLists[i].Type != (CommandListType)i)
                {
                    var c = CommandListFactory.ByType((CommandListType)i);
                    c.Type = (CommandListType)i;
                    script.CommandLists.Insert(i, c);
                }
            }
        }