source: 2015/26/MikkoL/JRPG/JRPG/JRPG/Battle/BattleView.cs @ 6319

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Jypeli;
using Jypeli.Widgets;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

public class BattleView : GameObject
{
    public static BattleView CurrentBattleView { get; set; }

    public _Background Background;
    public Image Background_Image;

    public EnemyGroup _EnemyGroup { get; set; }
    public EnemyBase Attacker { get; set; }

    public List<CharacterBase> Allies = new List<CharacterBase>();
    public List<BetterLabel> AllyNames = new List<BetterLabel>();
    public List<EnemyBase> Enemies = new List<EnemyBase>();
    public List<GameObject> EnemiesOnScreen = new List<GameObject>();

    public bool IsAttackAnimationPlaying { get; set; }
    public bool IsTimerActive { get; set; }
    public bool IsInMenu { get; set; }

    private SpecialQueue<CharacterBase> _AllyQueue = new SpecialQueue<CharacterBase>();
    public SpecialQueue<Action<CharacterBase>> AllyQueue = new SpecialQueue<Action<CharacterBase>>();
    public Queue<Action> ActionQueue = new Queue<Action>();

    private BetterLabel EnemyName;
    private Pointer Pointer;

    private Widget BattleHUD { get; set; }
    private List<GameObject> ToDeleteOnExit = new List<GameObject>();
    private ScrollingTextMenu BattleMenu { get; set; }

    private int SelectedAllyIndex;

    private float WaitTimeBetweenActions = 1f;
    private float TimeBetweenActions;

    int SelectedEnemy;
    int PrevSelectedEnemy = 0;

    public BattleView()
        : base(0, 0)
    { }

    public void LoadBattle(EnemyGroup _Enemies, Image BG_Image)
    {
        Background_Image = BG_Image;
        LoadBattle(_Enemies);
    }

    public void LoadBattle(EnemyGroup _Enemies)
    {
        JRPG.Game.ClearControls();

        CurrentBattleView = this;

        _EnemyGroup = _Enemies;

        Background = new _Background(JRPG.Game.Content.Load<Texture2D>("BG//bg_test"));
        JRPG.Game.Add(Background, 1);

        JRPG.Game.Keyboard.Listen(Key.Enter, ButtonState.Pressed, EndBattle, null);

        Allies.Add(CharacterList.TestChar());
        Allies.Add(CharacterList.TestChar());
        Allies.Add(CharacterList.TestChar());

        for (int i = 0; i < Allies.Count; i++)
        {
            Allies[i].Index = i;
        }

        LoadEnemies(_Enemies);
        LoadHUD();

        Flags.InBattle = true;
        IsTimerActive = true;
    }

    void LoadEnemies(EnemyGroup _Enemies)
    {
        for (int i = 0; i < _Enemies.Count; i++)
        {
            
            _Enemies[i].EnemyOnScreen = new GameObject(_Enemies[i].Idle.Width, _Enemies[i].Idle.Height);
            _Enemies[i].EnemyOnScreen.Image = _Enemies[i].Idle;

            if (_Enemies.Count == 1)
            {
                
                _Enemies[i].EnemyOnScreen.Position = JRPG.Game.Camera.Position + new Vector(-240, 0);
                
            }
            else if (_Enemies.Count == 2)
            {
                _Enemies[i].EnemyOnScreen.Position = JRPG.Game.Camera.Position + new Vector(-160 - (i*100), 120 + (i*-160));
            }
            else if (_Enemies.Count == 3)
            {
                _Enemies[i].EnemyOnScreen.Position = JRPG.Game.Camera.Position + new Vector(-260+i*100, 160+i*-120);
                if (i == 2)
                {
                    _Enemies[i].EnemyOnScreen.X = (_Enemies[0].EnemyOnScreen.Position.X + _Enemies[1].EnemyOnScreen.X) / 2;
                }
            }
            else if (_Enemies.Count == 4)
            {
                _Enemies[i].EnemyOnScreen.Y = JRPG.Game.Camera.Position.Y - (100 * i - 200);
                if (i % 2 == 0)
                {
                    _Enemies[i].EnemyOnScreen.X = JRPG.Game.Camera.Position.X - 160;
                }
                else if (i % 2 == 1)
                {
                    _Enemies[i].EnemyOnScreen.X = JRPG.Game.Camera.Position.X - 260;
                }
            }

            Enemies.Add(_Enemies[i]);

            JRPG.Game.Add(_Enemies[i].EnemyOnScreen, 2);
            EnemiesOnScreen.Add(_Enemies[i].EnemyOnScreen);
        }
    }

    void LoadHUD()
    {
        Vector Position = new Vector(-60, -235);
        double Offset = 40;

        BattleHUD = new Widget(Images.HUD.BattleHUD.Width, Images.HUD.BattleHUD.Height);
        BattleHUD.Image = Images.HUD.BattleHUD;
        BattleHUD.Position = Position + new Vector(64.5, -34.5);
        JRPG.Game.Add(BattleHUD);

        for (int i = 0; i < Allies.Count; i++)
        {
            int Index = i;

            BetterLabel Name = new BetterLabel(JRPG.Game.MainFont, Position + new Vector(-200, i * -Offset), Allies[i].Name);
            JRPG.Game.Add(Name);
            AllyNames.Add(Name);

            string HP = Allies[i].CurrentHP.Value.ToString() + "/" + Allies[i].CurrentHP.MaxValue.ToString();
            BetterLabel HPMeter = new BetterLabel(JRPG.Game.MainFont, Position + new Vector(0, i * -Offset), HP);
            HPMeter.BorderType = TextBorderType.Thick;
            JRPG.Game.Add(HPMeter);

            string SP = Allies[i].CurrentSP.Value.ToString();
            BetterLabel SPMeter = new BetterLabel(JRPG.Game.MainFont, Position + new Vector(150, i * -Offset), SP);
            SPMeter.BorderType = TextBorderType.Thick;
            JRPG.Game.Add(SPMeter);

            ProgressBar WaitBar = new ProgressBar(104, 12);
            WaitBar.Position = Position + new Vector(280, i * -Offset);
            WaitBar.BindTo(Allies[i].WaitTimeMeter);
            WaitBar.BarImage = Images.HUD.Wait_Full;
            WaitBar.Image = Images.HUD.Wait_Empty;
            JRPG.Game.Add(WaitBar);

            ToDeleteOnExit.Add(HPMeter);
            ToDeleteOnExit.Add(SPMeter);
            ToDeleteOnExit.Add(WaitBar);

            Allies[Index].OnCurrentHPChange = delegate
            {
                HPMeter.Text = Allies[Index].CurrentHP.Value.ToString() + "/" + Allies[Index].CurrentHP.MaxValue.ToString();

                
                if (Allies[Index].CurrentHP.Value == 0)
                {
                    if (SelectedAllyIndex == Allies[Index].Index)
                    {
                        JRPG.Game.ClearControls();

                        IsInMenu = false;
                        AllyNames[SelectedAllyIndex].IsFlashing = false;
                        BattleMenu.Destroy();
                        if (EnemyName != null) EnemyName.Destroy();
                        if (Pointer != null) Pointer.Destroy();
                    }

                    Name.TextColor = Microsoft.Xna.Framework.Color.Gray;
                    HPMeter.TextColor = Microsoft.Xna.Framework.Color.Gray;
                    SPMeter.TextColor = Microsoft.Xna.Framework.Color.Gray;

                    Allies[Index].WaitTimeMeter.Value = 0;

                    Allies[Index].IsDead = true;
                }
            };

            Allies[Index].OnCurrentSPChange = delegate
            {
                SPMeter.Text = Allies[Index].CurrentSP.Value.ToString();
            };
        }
    }

    public void SelectSingleEnemyForAttackTarget(AttackBase ATK)
    {
        JRPG.Game.ClearControls();

        SelectedEnemy = PrevSelectedEnemy;

        EnemyName = new BetterLabel(JRPG.Game.MainFont, Vector.Zero, Enemies[SelectedEnemy].Name);
        EnemyName.IsFlashing = true;
        Pointer = new Pointer(Vector.Zero);
        Pointer.IsFlashing = true;

        JRPG.Game.Add(Pointer);
        JRPG.Game.Add(EnemyName);

        bool Selected = false;
        bool Cancelled = false;

        JRPG.Game.Keyboard.Listen(Key.Z, ButtonState.Pressed,
            delegate
            {
                Selected = true;

                if (!Cancelled)
                {
                    JRPG.Game.ClearControls();
                    PrevSelectedEnemy = SelectedEnemy;

                    double BaseDamage = ATK.BaseDamage(_AllyQueue.Peek().CurrentStats.Str, _AllyQueue.Peek().Level);
                    int TrueDamage = 0;
                    bool Crit = false;

                    int r = RandomGen.NextInt(0, 100);

                    if (r < BattleAlgorithms.CriticalRate(_AllyQueue.Peek().CurrentStats.Luck))
                    {
                        TrueDamage = BattleAlgorithms.DamageFromCriticalHit(BaseDamage, Enemies[SelectedEnemy].Stats.Def);
                        Crit = true;
                    }
                    else TrueDamage = BattleAlgorithms.DamageFromBasicAttack(BaseDamage, Enemies[SelectedEnemy].Stats.Def);

 
                    IsInMenu = false;

                    if (SoundEffects.Menu.Move.IsPlaying)
                    {
                        SoundEffects.Menu.Move.Stop();
                    }
                    SoundEffects.Menu.Move.Play();


                    EnemyName.Destroy();
                    Pointer.Destroy();

                    AllyNames[_AllyQueue.Peek().Index].IsFlashing = false;
                    AllyNames[_AllyQueue.Peek().Index].TextColor = Microsoft.Xna.Framework.Color.White;
                    
                    ActionQueue.Enqueue(delegate
                    {
                        IsAttackAnimationPlaying = false;
                        IsTimerActive = true;

                        DamageHitsplat(EnemiesOnScreen[SelectedEnemy].Position - JRPG.Game.Camera.Position, TrueDamage, Crit);
                        Enemies[SelectedEnemy].Stats.HP -= TrueDamage;

                        if (Enemies[SelectedEnemy].Stats.HP <= 0)
                        {
                            Enemies[SelectedEnemy].EnemyOnScreen.Destroy();
                            Enemies.RemoveAt(SelectedEnemy);
                            EnemiesOnScreen.RemoveAt(SelectedEnemy);
                            PrevSelectedEnemy = 0;

                            if (Enemies.Count == 0)
                            {
                                EndBattle();
                            }
                        }

                        _AllyQueue.Peek().WaitTimeMeter.Value = 0;
                        _AllyQueue.Dequeue().CanMakeAction = false;
                         
                    });
                }
            }
        ,null);
        JRPG.Game.Keyboard.Listen(Key.X, ButtonState.Pressed,
            delegate
            {
                Cancelled = true;

                if (!Selected)
                {

                    JRPG.Game.ClearControls();

                    Pointer.Destroy();
                    EnemyName.Destroy();

                    LoadBattleMenu(_AllyQueue.Peek()).Invoke(_AllyQueue.Dequeue());

                    if (SoundEffects.Menu.Cancel.IsPlaying)
                    {
                        SoundEffects.Menu.Cancel.Stop();
                    }
                    SoundEffects.Menu.Cancel.Play();
                }
            }
        , null);

        JRPG.Game.Keyboard.Listen(Key.Up, ButtonState.Pressed,
            delegate
            {
                if (SelectedEnemy > 0)
                {
                    SelectedEnemy--; SetEnemyPointerPosition(Pointer, EnemyName);
                    if (SoundEffects.Menu.Move.IsPlaying)
                    {
                        SoundEffects.Menu.Move.Stop();
                    }
                    SoundEffects.Menu.Move.Play();
                }
            }
        ,null);
        JRPG.Game.Keyboard.Listen(Key.Down, ButtonState.Pressed,
            delegate
            {
                if (SelectedEnemy < Enemies.Count - 1)
                {
                    SelectedEnemy++; SetEnemyPointerPosition(Pointer, EnemyName);
                    if (SoundEffects.Menu.Move.IsPlaying)
                    {
                        SoundEffects.Menu.Move.Stop();
                    }
                    SoundEffects.Menu.Move.Play();
                }
            }
        , null);

        SetEnemyPointerPosition(Pointer, EnemyName);
    }

    void SetEnemyPointerPosition(Pointer Pointer, BetterLabel EnemyName)
    {
        Pointer.BorderPosition = EnemiesOnScreen[SelectedEnemy].Position + new Vector(0, 20 + EnemiesOnScreen[SelectedEnemy].Height / 2) - JRPG.Game.Camera.Position;
        EnemyName.Text = Enemies[SelectedEnemy].Name;
        EnemyName.FontPosition = VectorConverter.JypeliVectorToXNA(Pointer.BorderPosition + new Vector(0, 25));
        EnemyName.Alignment = TextAlignment.Center;
    }

    void DamageHitsplat(Vector StartingPosition, int Damage, bool Crit)
    {
        BetterLabel DMG = new BetterLabel(JRPG.Game.MainFont, StartingPosition, Damage.ToString(), TextAlignment.Center);
        DMG.Position = StartingPosition;
        if (Crit) DMG.TextColor = Microsoft.Xna.Framework.Color.Gold;
        JRPG.Game.Add(DMG);

        DMG.Hitsplat(350, 0.2f, 2f, delegate {
            DMG.Destroy();
        });
    }

    Action Flee()
    {
        return delegate
        {
            int r = RandomGen.NextInt(0, 100);

            if (r < BattleAlgorithms.FleePercent(_EnemyGroup))
            {
                ActionQueue.Enqueue(delegate
                {

                });
            }
            else
            {

            }
        };
    }

    public CharacterBase SelectRandomAlly()
    {
        int r = RandomGen.NextInt(0, Allies.Count);

        while (Allies[r].CurrentHP.Value == 0)
        {
            r = RandomGen.NextInt(0, Allies.Count);
        }

        return Allies[r];
    }

    void EndBattle()
    {
        Flags.InBattle = false;

        for (int i = 0; i < AllyNames.Count; i++)
        {
            AllyNames[i].Destroy();
        }

        for (int i = 0; i < ToDeleteOnExit.Count; i++)
        {
            ToDeleteOnExit[i].Destroy();
        }

        BattleHUD.Destroy();
        BattleMenu.Destroy();
        Background.Destroy();

        OverworldView.CurrentMapData.InitializeEnemies(OverworldView.CurrentMapData.CurrentMapIndex);

        JRPG.Game.ClearControls();
        

        JRPG.Game.LoadOWControlsKeyboard();
        JRPG.Game.LoadOWControlsXboxController();

        JRPG.Game.Camera.StayInLevel = true;
    }

    Action<CharacterBase> LoadBattleMenu(CharacterBase character)
    {
        return delegate
        {
            if (!character.IsDead)
            {
                SelectedAllyIndex = character.Index;

                IsInMenu = true;

                AllyNames[character.Index].IsFlashing = true;

                BattleMenu = new ScrollingTextMenu();
                BattleMenu.SetTextBases(JRPG.Game.MainFont, TextAlignment.Left);

                for (int i = 0; i < character.LearnedAttacks.Count; i++)
                {
                    int Index = i;

                    BattleMenu.AddMenuElement(character.LearnedAttacks[i].Name);
                    BattleMenu.ActionWhenSelected.Add(
                        delegate
                        {
                            _AllyQueue.Cut(character);
                            IsInMenu = true;
                            AllyNames[character.Index].IsFlashing = true;
                            character.LearnedAttacks[Index].OnUse();
                        }
                        );
                }

                if (character.LearnedSkills.Count > 0)
                {
                    BattleMenu.AddMenuElement("skills");
                    BattleMenu.ActionWhenSelected.Add(delegate { });
                }
                BattleMenu.AddMenuElement("items");
                BattleMenu.ActionWhenSelected.Add(delegate { });
                BattleMenu.AddMenuElement("flee");
                BattleMenu.ActionWhenSelected.Add(Flee());

                BattleMenu.ActionOnExit = delegate
                {
                    IsInMenu = false;
                    AllyNames[character.Index].IsFlashing = false;
                    AllyNames[character.Index].TextColor = Microsoft.Xna.Framework.Color.White;
                };

                BattleMenu.LoadMenuElements();
            }
        };
    }

    void BattleTimer(double deltaTime)
    {
        for (int i = 0; i < Allies.Count; i++)
        {
            if (!Allies[i].CanMakeAction && !Allies[i].IsDead)
            {
                Allies[i].ElapsedTime += deltaTime;
                Allies[i].WaitTimeMeter.Value += deltaTime;
                if (Allies[i].ElapsedTime >= Allies[i].WaitTime)
                {
                    Allies[i].ElapsedTime = 0.0;
                    Allies[i].CanMakeAction = true;
                    _AllyQueue.Enqueue(Allies[i]);
                    AllyQueue.Enqueue(LoadBattleMenu(Allies[i]));
                }
            }
        }

        for (int i = 0; i < Enemies.Count; i++)
        {
            if (!Enemies[i].CanMakeAction)
            {
                Enemies[i].ElapsedTime += deltaTime;
                if (Enemies[i].ElapsedTime >= Enemies[i].WaitTime)
                {
                    Enemies[i].ElapsedTime = 0.0;
                    Enemies[i].CanMakeAction = true;

                    int Index = i;

                    ActionQueue.Enqueue(delegate
                    {
                        Attacker = Enemies[Index];
                        Enemies[Index].PickRandomAttack().OnUse();
                    });
                }
            }
        }
    }

    public override void Update(Time time)
    {
        if (Flags.InBattle)
        {
            if (AllyQueue.Count > 0 && !IsInMenu)
            {
                AllyQueue.Dequeue().Invoke(_AllyQueue.Peek());
            }

            if (ActionQueue.Count > 0 && !IsAttackAnimationPlaying)
            {
                IsAttackAnimationPlaying = true;
                IsTimerActive = false;
                ActionQueue.Dequeue().Invoke();
            }

            if (IsTimerActive)
            {
                double deltaTime = (float)time.SinceLastUpdate.TotalSeconds;
                BattleTimer(deltaTime);
            }
        }

        base.Update(time);
    }
}