WSHCommon/Common/GameEditorPlugin/Win32/BattleClient/DisplayLayerObject.cs

using System;
using CommonAI.ZoneClient;
using System.Drawing;
using CommonAI.Zone;
using CommonLang;
using CommonAI.Zone.Helper;
using CommonLang.Vector;
using CommonFroms.Drawing;

namespace GameEditorPlugin.Win32.BattleClient
{
    public abstract class DisplayLayerObject : DisplayObject
    {
        readonly private ZoneObject mObj;
        readonly public DisplayLayerWorld world;

        protected Pen pen;
        protected SolidBrush brush;
        protected RectangleF mLocalBounds;

        public DisplayLayerObject(DisplayLayerWorld wd, ZoneObject obj)
        {
            this.world = wd;
            this.mObj = obj;
            this.pen = new Pen(Color.Green);
            this.brush = new SolidBrush(Color.Green);
        }

        public override bool Visible { get { return true; } }
        public override float X { get { return mObj.X; } }
        public override float Y { get { return mObj.Y; } }
        public override float Z { get { return mObj.Z; } }
        public override RectangleF LocalBounds { get { return mLocalBounds; } }

        public string Name { get { return mObj.Name; } }
        public uint ObjectID { get { return mObj.ObjectID; } }
        public ZoneObject ZoneObjectData { get { return mObj; } }


        public override void renderHP(Graphics g) { }

        public override void renderName(Graphics g, Font font, Brush brush)
        {
            SizeF fsize = g.MeasureString(this.Name, font);
            g.DrawString(mObj.DisplayName, font, brush, -fsize.Width / 2, -fsize.Height);
        }

        //-------------------------------------------------------------------------------------------------
        #region Drawing


        public void RenderDirection(Graphics g, Pen pen, float direction, float range)
        {
            g.DrawLine(pen, 0, 0,
                (float)Math.Cos(direction) * range,
                (float)Math.Sin(direction) * range);
        }

        public void RenderAttackShape(
            Graphics g,
            Pen pen,
            AttackShape shape,
            float direction,
            float size,
            float distance,
            float angle,
            float strip_wide,
            float start_offset,
            ZoneObject target)
        {
            System.Drawing.Drawing2D.GraphicsState gs = g.Save();
            try
            {
                if (start_offset != 0)
                {
                    float dx = 0;
                    float dy = 0;
                    MathVector.movePolar(ref dx, ref dy, direction, start_offset);
                    g.TranslateTransform(dx, dy);
                }
                switch (shape)
                {
                    case AttackShape.Round:
                        g.DrawEllipse(pen, new RectangleF(-size, -size, size * 2, size * 2));
                        break;
                    case AttackShape.Circle:
                        g.DrawEllipse(pen, new RectangleF(-size, -size, size * 2, size * 2));
                        float sr = size - strip_wide;
                        g.DrawEllipse(pen, new RectangleF(-sr, -sr, sr * 2, sr * 2));
                        break;
                    case AttackShape.Fan:
                        DrawingUtils.DrawFan(g, pen, direction, size, angle);
                        break;
                    case AttackShape.Strip:
                        {
                            float d_width = strip_wide / 2f;
                            //float d_angle = direction + CMath.PI_DIV_2;
                            float d_distance = distance / 2f;
                            Vector2 p0 = new Vector2(0, 0);
                            Vector2 p1 = new Vector2(0, 0);
                            MathVector.movePolar(p0, direction, -d_distance);
                            MathVector.movePolar(p1, direction, +d_distance);
                            DrawingUtils.DrawLineRoundRect(g, pen, p0.X, p0.Y, p1.X, p1.Y, d_width);
                        }
                        break;
                    case AttackShape.StripRay:
                    case AttackShape.StripRayTouchEnd:
                        {
                            float d_width = strip_wide / 2f;
                            Vector2 p1 = new Vector2(0, 0);
                            MathVector.movePolar(p1, direction, distance);
                            DrawingUtils.DrawLineRoundRect(g, pen, 0, 0, p1.X, p1.Y, d_width);
                        }
                        break;
                    case AttackShape.RectStrip:
                        {
                            float d_width = strip_wide / 2f;
                            //float d_angle = direction + CMath.PI_DIV_2;
                            float d_distance = distance / 2f;
                            Vector2 p0 = new Vector2(0, 0);
                            Vector2 p1 = new Vector2(0, 0);
                            MathVector.movePolar(p0, direction, -d_distance);
                            MathVector.movePolar(p1, direction, +d_distance);
                            DrawingUtils.DrawLineRect(g, pen, p0.X, p0.Y, p1.X, p1.Y, d_width);
                        }
                        break;
                    case AttackShape.RectStripRay:
                        {
                            float d_width = strip_wide / 2f;
                            Vector2 p1 = new Vector2(0, 0);
                            MathVector.movePolar(p1, direction, distance);
                            DrawingUtils.DrawLineRect(g, pen, 0, 0, p1.X, p1.Y, d_width);
                        }
                        break;
                    case AttackShape.WideStrip:
                        {
                            float d_width = strip_wide / 2f;
                            float d_angle = direction + CMath.PI_DIV_2;
                            float d_distance = distance / 2f;
                            Vector2 p0 = new Vector2(0, 0);
                            Vector2 p1 = new Vector2(0, 0);
                            MathVector.movePolar(p0, d_angle, -d_width);
                            MathVector.movePolar(p1, d_angle, +d_width);
                            DrawingUtils.DrawLineRoundRect(g, pen, p0.X, p0.Y, p1.X, p1.Y, d_distance);
                        }
                        break;
                    case AttackShape.LineToTarget:
                    case AttackShape.LineToStart:
                        {
                            Vector2 p1 = new Vector2(0, 0);
                            MathVector.movePolar(p1, direction, distance);
                            g.DrawLine(pen, 0, 0, p1.X, p1.Y);
                            g.DrawEllipse(pen, new RectangleF(-size, -size, size * 2, size * 2));
                        }
                        break;
                }
            }
            finally
            {
                g.Restore(gs);
            }
        }
        #endregion


    }

    public class DisplayGameUnit : DisplayLayerObject
    {
        readonly public ZoneUnit Data;
        readonly public UnitInfo Info;

        private static HashMap<UnitActionStatus, SolidBrush> status_bursh = new HashMap<UnitActionStatus, SolidBrush>();
        static DisplayGameUnit()
        {
            status_bursh[UnitActionStatus.Spawn] = new SolidBrush(Color.FromArgb(0xff, 0x40, 0x40, 0x40));
            status_bursh[UnitActionStatus.Idle] = new SolidBrush(Color.FromArgb(0, 0, 0, 0));
            status_bursh[UnitActionStatus.Damage] = new SolidBrush(Color.FromArgb(0x80, 0xFF, 0, 0));
            status_bursh[UnitActionStatus.Dead] = new SolidBrush(Color.FromArgb(0x80, 0x40, 0x40, 0x40));
            status_bursh[UnitActionStatus.Move] = new SolidBrush(Color.FromArgb(0x80, 0, 0, 0xFF));
            status_bursh[UnitActionStatus.Skill] = new SolidBrush(Color.FromArgb(0x80, 0xFF, 0xFF, 0));
            status_bursh[UnitActionStatus.Stun] = new SolidBrush(Color.FromArgb(0x80, 0xFF, 0xFF, 0xFF));
            status_bursh[UnitActionStatus.Chaos] = new SolidBrush(Color.FromArgb(0x80, 0xFF, 0x80, 0x80));
            status_bursh[UnitActionStatus.Escape] = new SolidBrush(Color.FromArgb(0x80, 0xFF, 0x80, 0x80));
            status_bursh[UnitActionStatus.Pause] = new SolidBrush(Color.FromArgb(0x80, 0x80, 0x80, 0x80));
            status_bursh[UnitActionStatus.Pick] = new SolidBrush(Color.FromArgb(0x80, 0, 0xFF, 0xFF));
        }

        protected Brush brush_dead = new SolidBrush(Color.FromArgb(128, 255, 255, 255));
        
        protected Pen pen_attack = new Pen(Color.FromArgb(0x80, 0xff, 0x00, 0x00));
        protected Pen pen_guard = new Pen(Color.FromArgb(0x80, 0xff, 0xff, 0x00));
        protected Pen pen_path = new Pen(Color.FromArgb(0xff, 0x80, 0xff, 0x80));
        protected Pen pen_hit = new Pen(Color.FromArgb(0xff, 0x80, 0xff, 0x80));
        
        protected Brush brush_hp = new SolidBrush(Color.FromArgb(0xff, 0, 0xff, 0));
        protected Brush brush_mp = new SolidBrush(Color.FromArgb(0xff, 0x80, 0x80, 0xff));
        protected Brush brush_black = new SolidBrush(Color.FromArgb(0xff, 0, 0, 0));
        protected Brush brush_attack = new SolidBrush(Color.FromArgb(0x80, 0xff, 0x00, 0x00));

        private SkillTemplate mBaseSkill;

        Pen[] pens = new Pen[]
        {
            new Pen(Color.LightBlue),
            new Pen(Color.Red),
            new Pen(Color.Green),
            new Pen(Color.Magenta),
        };


        public DisplayGameUnit(DisplayLayerWorld wd, ZoneUnit unit)
            : base(wd, unit)
        {
            this.Data = unit;
            this.Info = unit.Info;
            this.brush = new SolidBrush(Color.FromArgb(0x80, 0x80, 0x80, 0x80));
            if (unit.Force == 0)
            {
                this.pen = new Pen(Color.Blue);
                this.brush = new SolidBrush(Color.Blue);
            }
            else
            {
                this.pen = new Pen(Color.Red);
                this.brush = new SolidBrush(Color.Red);
            }
            if (Info != null)
            {
                this.mLocalBounds = new RectangleF(
                        -Info.BodySize,
                        -Info.BodySize,
                       Info.BodySize * 2,
                       Info.BodySize * 2);
            }
            else
            {
                this.mLocalBounds = new RectangleF(-1, -1, 2, 2);
            }
            this.pen = CUtils.GetMinOrMax<Pen>(pens, Data.Force);
            if (Info.BaseSkillID != null)
            {
                ZoneUnit.SkillState ss = unit.GetSkillState(Info.BaseSkillID.SkillID);
                if (ss != null)
                {
                    mBaseSkill = ss.Data;
                }
            }
            this.Data.OnDoEvent += doEvent;
        }

        private void doEvent(ZoneObject obj, ObjectEvent e)
        {
            if (e is UnitLaunchSkillEvent)
            {
                UnitLaunchSkillEvent me = (UnitLaunchSkillEvent)e;
            }
            else if (e is UnitHitEvent)
            {
                UnitHitEvent me = (UnitHitEvent)e;
                world.showLog(me.hp.ToString(), X, Y);
            }
            else if (e is UnitDeadEvent)
            {
                UnitDeadEvent me = (UnitDeadEvent)e;
            }
        }


        public override void render(Graphics g)
        {
            float penscale = 1f / world.getCameraScale();
            pen.Width = penscale;
            pen_path.Width = penscale;
            pen_attack.Width = penscale;
            pen_guard.Width = penscale;
            pen_hit.Width = penscale;
            DisplayLayerWorld.pen_write.Width = penscale;
            float bs = Info.BodySize;

            if (bs > 0)
            {
                SolidBrush sbursh;
                if (status_bursh.TryGetValue(Data.CurrentState, out sbursh))
                {
                    g.FillPie(sbursh, -bs, -bs, bs * 2, bs * 2, 0, 360);
                }

                // render body
                g.DrawArc(pen, -bs, -bs, bs * 2, bs * 2, 0, 360);
                // render direction
                RenderDirection(g, pen, Data.Direction, bs);
            }

            // render hit body
            if (world.ShowDamageRange)
            {
                if (Info.BodyHitSize > 0)
                {
                    g.DrawArc(pen_hit, -Info.BodyHitSize, -Info.BodyHitSize, Info.BodyHitSize * 2, Info.BodyHitSize * 2, 0, 360);
                }
            }

            // render attack angle
            if (world.ShowAttackRange && mBaseSkill != null)
            {
                float rg = Data.GetSkillAttackRange(mBaseSkill);
                DrawingUtils.DrawFan(g, pen_attack, Data.Direction, rg, mBaseSkill.AttackAngle);
                if (Data is ZoneActor)
                {
                    ZoneActor actor = Data as ZoneActor;
                    if (actor.CurrentSkillActionData != null && actor.CurrentSkillActionData.OverrideAttackShape != null)
                    {
                        UnitActionData.AttackShape shape = actor.CurrentSkillActionData.OverrideAttackShape;
                        RenderAttackShape(g, pen_attack,
                            (AttackShape)shape.AShape,
                            Data.Direction,
                            shape.AttackRange,
                            shape.AttackRange,
                            shape.AttackAngle,
                            shape.StripWide,
                            shape.OffsetRadius,
                            null);
                    }
                }
            }
            if (world.ShowGuardRange)
            {
                if (Info.GuardRange > 0)
                    g.DrawArc(pen_guard, -Info.GuardRange, -Info.GuardRange, Info.GuardRange * 2, Info.GuardRange * 2, 0, 360);
                if (Info.GuardRangeLimit > 0)
                    g.DrawArc(pen_guard, -Info.GuardRangeLimit, -Info.GuardRangeLimit, Info.GuardRangeLimit * 2, Info.GuardRangeLimit * 2, 0, 360);
            }
            if (world.SelectedObject == this)
            {
                g.DrawRectangle(DisplayLayerWorld.pen_write, -bs, -bs, bs * 2, bs * 2);
            }
            if (OnRender != null)
            {
                OnRender.Invoke(g, this);
            }
        }

        public override void renderHP(Graphics g)
        {
            float r = 20;
            float sx = -r - 2;
            float sy = -r - 8;
            float sw = r * 2 + 4;
            float sh = 6;

            g.FillRectangle(brush_black, sx, sy, sw, sh);
            g.FillRectangle(brush_hp, sx + 1, sy + 1,
                (sw - 2) * Data.HP / Data.MaxHP, sh - 2);

            g.FillRectangle(brush_black, sx, sy + sh, sw, sh);
            g.FillRectangle(brush_mp, sx + 1, sy + 1 + sh,
                (sw - 2) * Data.MP / Data.MaxMP, sh - 2);

            if (Data.GetDeadTimeCD() > 0)
            {
                g.FillRectangle(brush_dead, sx + 1, sy + 1, (sw - 2) * Data.GetDeadTimeCD(), sh - 2);
            }

            if (OnRenderHP != null)
            {
                OnRenderHP.Invoke(g, this);
            }
        }



        public delegate void OnRenderHandler(Graphics g, DisplayGameUnit unit);
        public delegate void OnRenderHPHandler(Graphics g, DisplayGameUnit unit);
        public event OnRenderHandler OnRender;
        public event OnRenderHPHandler OnRenderHP;
    }

    public class DisplayGameSpell : DisplayLayerObject
    {
        readonly public ZoneSpell Data;
        readonly public SpellTemplate Info;
        private float mSize;

        public DisplayGameSpell(DisplayLayerWorld wd, ZoneSpell spell)
            : base(wd, spell)
        {
            this.Data = spell;
            this.Info = spell.Info;
            this.pen = new Pen(Color.Yellow);
            this.brush = new SolidBrush(Color.Yellow);
            if (Info != null)
            {
                this.mLocalBounds = new RectangleF(
                        -Info.BodySize,
                        -Info.BodySize,
                       Info.BodySize * 2,
                       Info.BodySize * 2);
                this.mSize = Info.BodySize;
            }
            else
            {
                this.mLocalBounds = new RectangleF(-1, -1, 2, 2);
            }
        }

        public override void render(Graphics g)
        {
            float penscale = 1f / world.getCameraScale();
            pen.Width = penscale;
            RenderAttackShape(g, pen, (AttackShape)Info.BodyShape, Data.Direction, Data.BodySize, Data.Distance, Data.Info.FanAngle, Data.Info.RectWide, 0, Data.Target);
            // 
            //             switch (Info.BodyShape)
            //             {
            //                 case SpellTemplate.Shape.Round:
            //                     {
            //                         g.DrawLine(pen, 0, 0, (float)Math.Cos(Data.Direction) * mSize, (float)Math.Sin(Data.Direction) * mSize);
            //                         g.DrawEllipse(pen, new RectangleF(-mSize, -mSize, mSize * 2, mSize * 2));
            //                     }
            //                     break;
            //                 case SpellTemplate.Shape.Fan:
            //                     {
            //                         RenderFan(g, pen, Data.Direction, mSize, Data.Info.FanAngle);
            //                     }
            //                     break;
            //                 case SpellTemplate.Shape.Strip:
            //                     {
            //                         float d_angle = Data.Direction + CMath.PI_DIV_2;
            //                         float d_width = Info.RectWide / 2f;
            //                         float d_distance = Data.Distance / 2f;
            //                         Vector2 p0 = new Vector2(0, 0);
            //                         Vector2 p1 = new Vector2(0, 0);
            //                         MathVector.movePolar(p0, d_angle, -d_distance);
            //                         MathVector.movePolar(p1, d_angle, d_distance);
            //                         RenderLineRoundRect(g, pen, p0.x, p0.y, p1.x, p1.y, Info.RectWide);
            //                     }
            //                     break;
            //                 case SpellTemplate.Shape.StripRay:
            //                 case SpellTemplate.Shape.StripRayTouchEnd:
            //                     {
            //                         float d_width = Info.RectWide / 2f;
            //                         Vector2 p1 = new Vector2(0, 0);
            //                         MathVector.movePolar(p1, Data.Direction, Data.Distance);
            //                         RenderLineRoundRect(g, pen, 0, 0, p1.x, p1.y, Info.RectWide);
            //                     }
            //                     break;
            //                 case SpellTemplate.Shape.LineToTarget:
            //                     if (Data.Target != null && CMath.includeRoundPoint(Data.X, Data.Y, Data.Distance, Data.Target.X, Data.Target.Y))
            //                     {
            //                         g.DrawLine(pen, 0, 0, Data.Target.X - Data.X, Data.Target.Y - Data.Y);
            //                     }
            //                     break;
            //             }
        }
        public override void renderName(Graphics g, Font font, Brush brush)
        {
            //base.renderName(g, font, brush);
        }
    }

    public class DisplayGameItem : DisplayLayerObject
    {
        readonly public ZoneItem Data;
        readonly public ItemTemplate Info;

        public DisplayGameItem(DisplayLayerWorld wd, ZoneItem spell)
            : base(wd, spell)
        {
            this.Data = spell;
            this.Info = spell.Info;
            this.pen = new Pen(Color.Red);
            this.pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom;
            this.pen.DashPattern = new float[] { Info.BodySize / 8, Info.BodySize / 8 };
            this.pen.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;
            this.brush = new SolidBrush(Color.Red);
            if (Info != null)
            {
                this.mLocalBounds = new RectangleF(
                        -Info.BodySize,
                        -Info.BodySize,
                       Info.BodySize * 2,
                       Info.BodySize * 2);
            }
            else
            {
                this.mLocalBounds = new RectangleF(-1, -1, 2, 2);
            }
        }

        public override void render(Graphics g)
        {
            if (world.Layer.Actor != null)
            {
                if (world.Layer.IsPickableItem(world.Layer.Actor, this.Data))
                {
                    SolidBrush brush = new SolidBrush(Color.FromArgb(0x80, 0xFF, 0xFF, 0));
                    g.FillEllipse(brush, mLocalBounds);
                }
            }
            float penscale = 1f / world.getCameraScale();
            pen.Width = penscale;
            g.DrawEllipse(pen, mLocalBounds);
            // render direction
            RenderDirection(g, pen, Data.Direction, Data.Info.BodySize);
        }
    }
    
    
}