Example #1
0
        private static void XmlWeaponData(XmlWriter xmlWriter, int character_id, ref Debug_battleDat r, StreamWriter csvFile, string prefix1)
        {
            ConcurrentDictionary <int, Debug_battleDat> WeaponData = new ConcurrentDictionary <int, Debug_battleDat>();

            xmlWriter.WriteStartElement("weapons");
            for (int i = 0; i <= 40; i++)
            {
                Debug_battleDat test;
                if (character_id == 1 || character_id == 9)
                {
                    test = Debug_battleDat.Load(character_id, Debug_battleDat.EntityType.Weapon, i, r);
                }
                else
                {
                    test = Debug_battleDat.Load(character_id, Debug_battleDat.EntityType.Weapon, i);
                }
                if (test != null && WeaponData.TryAdd(i, test))
                {
                }
                if (WeaponData.TryGetValue(i, out Debug_battleDat _BattleDat))
                {
                    const string type = "weapon";
                    string       id   = i.ToString();
                    xmlWriter.WriteStartElement(type);
                    xmlWriter.WriteAttributeString("id", id);
                    int index = Module_battle_debug.Weapons[(Characters)character_id].FindIndex(v => v == i);
                    Kernel_bin.Weapons_Data weapondata = Kernel_bin.WeaponsData.FirstOrDefault(v => v.Character == (Characters)character_id &&
                                                                                               v.AltID == index);

                    if (weapondata != default)
                    {
                        xmlWriter.WriteAttributeString("name", weapondata.Name);

                        string prefix = $"{type}{ls}{id}{ls}{weapondata.Name}/{prefix1}"; //bringing over name from character.
                                                                                          //xmlWriter.WriteAttributeString("name", Memory.Strings.GetName((Characters)i));

                        XMLAnimations(xmlWriter, _BattleDat);
                        XMLSequences(xmlWriter, _BattleDat, csvFile, prefix);
                    }
                    xmlWriter.WriteEndElement();
                }
            }
            xmlWriter.WriteEndElement();
        }
Example #2
0
        protected override void Init()
        {
            base.Init();
            if (CommandFunc == null)
            {
                CommandFunc = new Dictionary <int, Func <bool> >
                {
                    //{0,Command00 },
                    { 1, Command01_ATTACK },
                    { 2, Command02_MAGIC },
                    //{3,Command03_GF },
                    { 4, Command04_ITEM },
                    { 5, Command05_RENZOKUKEN },
                    { 6, Command06_DRAW },
                    { 7, Command07_DEVOUR },
                    //{8,Command08_UNNAMED },
                    //{9,Command09_CAST },
                    //{10,Command10_STOCK },
                    { 11, Command11_DUEL },
                    { 12, Command12_MUG },
                    //{13,Command13_NOMSG },
                    { 14, Command14_SHOT },
                    { 15, Command15_BLUE_MAGIC },
                    //{16,Command16_SLOT },
                    { 17, Command17_FIRE_CROSS_NO_MERCY },
                    { 18, Command18_SORCERY_ICE_STRIKE },
                    { 19, Command19_COMBINE },
                    { 20, Command20_DESPERADO },
                    { 21, Command21_BLOOD_PAIN },
                    { 22, Command22_MASSIVE_ANCHOR },
                    //{23,Command23_DEFEND },
                    { 24, Command24_MADRUSH },
                    { 25, Command25_TREATMENT },
                    { 26, Command26_RECOVERY },
                    { 27, Command27_REVIVE },
                    { 28, Command28_DARKSIDE },
                    { 29, Command29_CARD },
                    { 30, Command30_DOOM },
                    { 31, Command31_KAMIKAZI },
                    { 32, Command32_ABSORB },
                    { 33, Command33_LVL_DOWN },
                    { 34, Command34_LVL_UP },
                    { 35, Command35_SINGLE },
                    { 36, Command36_DOUBLE },
                    { 37, Command37_TRIPLE },
                    { 38, Command38_MINIMOG },
                }
            }
            ;

            //bool Command00() => throw new NotImplementedException();

            bool Command01_ATTACK()
            {
                Neededvaribles(out Damageable[] d);
                if (EnemyAttack != null && Damageable.GetEnemy(out Enemy e))
                {
                    Debug.WriteLine($"{Damageable.Name} uses {EnemyAttack.Name}({EnemyAttack.MagicID}) enemy attack on { DebugMessageSuffix(d) }");
                }
                EndTurn();
                return(true);
            }

            bool Command02_MAGIC()
            {
                Neededvaribles(out Damageable[] d, Magic.PositiveMagic);
                Debug.WriteLine($"{Damageable.Name} casts {Magic.Name}({Magic.ID}) spell on { DebugMessageSuffix(d) }");
                EndTurn();
                return(true);
            }

            //bool Command03_GF() => throw new NotImplementedException();

            bool Command04_ITEM()
            {
                Neededvaribles(out Damageable[] d);
                Debug.WriteLine($"{Damageable.Name} uses {Item.Name}({Item.ID}) item on { DebugMessageSuffix(d) }");
                EndTurn();
                return(true);
            }

            bool Command05_RENZOKUKEN()
            {
                Neededvaribles(out Damageable[] d);
                if (d.First().GetType() == typeof(Enemy) && Damageable.GetCharacterData(out Saves.CharacterData c))
                {
                    Saves.CharacterData squall = Memory.State[Characters.Squall_Leonhart];
                    //Renzokuken
                    byte weaponid = squall.WeaponID;
                    int  hits     = 0;
                    if (c.CurrentCrisisLevel > 0)
                    {
                        hits = c.CurrentCrisisLevel < Renzokuken_hits.Length ? Renzokuken_hits[c.CurrentCrisisLevel] : Renzokuken_hits.Last();
                    }
                    //else return false;
                    else
                    {
                        hits = Renzokuken_hits.First();
                    }
                    int  finisherchance = (c.CurrentCrisisLevel + 1) * 60;
                    bool willfinish     = Memory.Random.Next(byte.MaxValue + 1) <= finisherchance;
                    int  choosefinish   = Memory.Random.Next(3 + 1);
                    Kernel_bin.Weapons_Data        weapondata         = Kernel_bin.WeaponsData[weaponid];
                    Kernel_bin.Renzokeken_Finisher renzokekenfinisher = weapondata.Renzokuken;
                    if (renzokekenfinisher == 0)
                    {
                        willfinish = false;
                    }

                    //per wiki the chance of which finisher is 25% each and the highest value finisher get the remaining of 100 percent.
                    //so rough divide is 100% when you only only have that
                    //when you unlock 2 one is 75% chance
                    //when you onlock 3 last one is 50%
                    //when you unlock all 4 it's 25% each.

                    //finishers each have their own target
                    Menu.BattleMenus.GetCurrentBattleMenu().Renzokeken.Reset(hits);
                    Menu.BattleMenus.GetCurrentBattleMenu().Renzokeken.Show();
                    if (willfinish)
                    {
                        List <Kernel_bin.Renzokeken_Finisher> flags = Enum.GetValues(typeof(Kernel_bin.Renzokeken_Finisher))
                                                                      .Cast <Kernel_bin.Renzokeken_Finisher>()
                                                                      .Where(f => (f & renzokekenfinisher) != 0)
                                                                      .ToList();
                        Kernel_bin.Renzokeken_Finisher finisher = choosefinish >= flags.Count ? flags.Last() : flags[choosefinish];
                        Debug.WriteLine($"{Damageable.Name} hits {hits} times with {Command.Name}({Command.ID}) then uses {Kernel_bin.RenzokukenFinishersData[finisher].Name}.");
                    }
                    else
                    {
                        Debug.WriteLine($"{Damageable.Name} hits {hits} times with {Command.Name}({Command.ID}) then fails to use a finisher.");
                    }
                }
                return(true);
            }

            bool Command06_DRAW()
            {
                Neededvaribles(out Damageable[] d);
                //draw
                //spawn a 1 page 4 row pool of the magic/gfs that the selected enemy has.
                if (d.First().GetType() == typeof(Enemy))
                {
                    Enemy e = (Enemy)d.First();
                    DrawMagic(e.DrawList);
                    Draw_Pool.Refresh(e.DrawList);
                    Draw_Pool.Show();
                }
                return(true);
            }

            bool Command07_DEVOUR()
            {
                Neededvaribles(out Damageable[] d);
                //TODO add devour commands
                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            //bool Command08_UNNAMED() => throw new NotImplementedException();

            //bool Command09_CAST() => throw new NotImplementedException();

            //bool Command10_STOCK() => throw new NotImplementedException();

            bool Command11_DUEL()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command12_MUG()
            {
                Neededvaribles(out Damageable[] d);
                if (d.First().GetType() == typeof(Enemy))
                {
                    Enemy e = (Enemy)d.First();
                    //unsure if party member being ejected or if they need to be in the party for rare item to work
                    Saves.Item i = e.Mug(Damageable.SPD, Memory.State.PartyHasAbility(Kernel_bin.Abilities.RareItem));
                    Debug.WriteLine($"{Damageable.Name} stole {i.DATA?.Name}({i.ID}) x {i.QTY} from { DebugMessageSuffix(d) }");
                }
                EndTurn();
                return(true);
            }

            //bool Command13_NOMSG() => throw new NotImplementedException();

            bool Command14_SHOT()
            {
                Neededvaribles(out Damageable[] d);

                Menu.BattleMenus.GetCurrentBattleMenu().Shot.Refresh(Item, d);
                Menu.BattleMenus.GetCurrentBattleMenu().Shot.Show();

                Debug.WriteLine($"{Damageable.Name} uses {Item.Name}({Item.ID}) item on { DebugMessageSuffix(d) }");
                return(true);
            }

            bool Command15_BLUE_MAGIC()
            {
                Neededvaribles(out Damageable[] d);
                Debug.WriteLine($"{Damageable.Name} casts {BlueMagic.Name}({BlueMagic.ID}) spell on { DebugMessageSuffix(d) }");
                EndTurn();
                return(false);
            }

            //bool Command16_SLOT() => throw new NotImplementedException();

            bool Command17_FIRE_CROSS_NO_MERCY()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command18_SORCERY_ICE_STRIKE()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command19_COMBINE()
            {
                //perform angelo attack unless angel wing is unlocked and chosen in menu.
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {CombineKernelItem.Name}({CombineKernelItem.ID}) - Combine Limit Break on { DebugMessageSuffix(d) }");

                EndTurn();

                return(true);
            }

            bool Command20_DESPERADO()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command21_BLOOD_PAIN()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command22_MASSIVE_ANCHOR()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            //bool Command23_DEFEND() => throw new NotImplementedException();

            bool Command24_MADRUSH()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command25_TREATMENT()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command26_RECOVERY()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command27_REVIVE()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command28_DARKSIDE()
            {
                Neededvaribles(out Damageable[] d);
                EndTurn();
                return(true);
            }

            bool Command29_CARD()
            {
                Neededvaribles(out Damageable[] d);
                if (d.First().GetType() == typeof(Enemy))
                {
                    Enemy    e = (Enemy)d.First();
                    Cards.ID c = e.Card();
                    if (c == Cards.ID.Fail)
                    {
                        Debug.WriteLine($"{Damageable.Name} Failed to use {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                    }
                    else if (c == Cards.ID.Immune)
                    {
                        Debug.WriteLine($"{Damageable.Name} Failed to use {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) } because they are immune!");
                    }
                    else
                    {
                        Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) } and got a {c} card");
                    }
                    EndTurn();
                }
                return(true);
            }

            bool Command30_DOOM()
            {
                Neededvaribles(out Damageable[] d);
                EndTurn();
                return(true);
            }

            bool Command31_KAMIKAZI()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command32_ABSORB()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command33_LVL_DOWN()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command34_LVL_UP()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }

            bool Command35_SINGLE() => Command02_MAGIC();

            bool Command36_DOUBLE()
            {
                // CHOOSE 2X TARGETS
                throw new NotImplementedException();
            }

            bool Command37_TRIPLE()
            {
                // CHOOSE 3X TARGETS
                throw new NotImplementedException();
            }

            bool Command38_MINIMOG()
            {
                Neededvaribles(out Damageable[] d);

                Debug.WriteLine($"{Damageable.Name} used {Command.Name}({Command.ID}) on { DebugMessageSuffix(d) }");
                EndTurn();

                return(true);
            }
        }