GameObjectBase.cs

Siirry tämän tiedoston dokumentaatioon.

using Microsoft.Xna.Framework;
using System;
using System.ComponentModel;
 
namespace Jypeli.GameObjects
{
    public abstract class GameObjectBase : Tagged, Destroyable
    {
        private Layer _layer = null;
        private Brain _brain = Brain.None;
        private TimeSpan _maxLifetime = TimeSpan.MaxValue;
        private bool _rotateImage = true;
 
        public Game Game
        {
            get { return Game.Instance; }
        }
 
        public Layer Layer
        {
            get
            {
                if ( Parent != null ) return Parent.Layer;
                return _layer;
            }
            set
            {
                _layer = value;
            }
        }
 
        public bool RotateImage
        {
            get { return _rotateImage; }
            set { _rotateImage = value; }
        }
 
        public IGameObject Parent { get; set; }
 
        public bool IsUpdated { get; set; }
 
        public object Tag { get; set; }
 
        public virtual Brain Brain
        {
            get
            {
                return _brain;
            }
            set
            {
                _brain.Owner = null;
                _brain = ( ( value != null ) ? value : Brain.None );
                _brain.Owner = (IGameObject)this;
                _brain.AddToGameEvent();
                if ( value != null )
                    IsUpdated = true;
            }
        }
 
        public event Action AddedToGame;
 
        public void OnAddedToGame()
        {
            AddedToGame?.Invoke();
            Brain.AddToGameEvent();
        }
 
        public event Action Removed;
 
        public void OnRemoved()
        {
            if ( Removed != null )
                Removed();
        }
 
        public bool IsDestroyed { get; private set; }
 
        public event Action Destroyed;
 
        protected void OnDestroyed()
        {
            if ( Destroyed != null )
                Destroyed();
        }
 
        public virtual void Destroy()
        {
            if ( IsDestroyed )
                return;
 
            IsDestroyed = true;
            OnDestroyed();
        }
 
        [Save] public abstract Vector Size { get; set; }
 
        [Save] public virtual Vector Position { get; set; }
 
        [Save] public abstract Angle Angle { get; set; }
 
        public TimeSpan CreationTime { get; protected set; }
 
        public TimeSpan Lifetime
        {
            get { return Game.Time.SinceStartOfGame - CreationTime; }
        }
 
        public TimeSpan MaximumLifetime
        {
            get { return _maxLifetime; }
            set
            {
                _maxLifetime = value;
                IsUpdated = true;
            }
        }
 
        [Save]
        public TimeSpan LifetimeLeft
        {
            get { return MaximumLifetime - Lifetime; }
            set
            {
                try
                {
                    MaximumLifetime = Lifetime + value;
                }
                catch ( OverflowException )
                {
                    MaximumLifetime = TimeSpan.MaxValue;
                }
            }
        }
 
        public double Width
        {
            get { return Size.X; }
            set { Size = new Vector( value, Size.Y ); }
        }
 
        public double Height
        {
            get { return Size.Y; }
            set { Size = new Vector( Size.X, value ); }
        }
 
        internal Vector InitialRelativePosition { get; set; }
        internal Angle InitialRelativeAngle { get; set; }
 
        public Vector RelativePosition
        {
            get
            {
                if (Parent != null)
                {
                    Vector diff = Position - Parent.Position;
                    Angle angle = diff.Angle;
                    return Vector.FromLengthAndAngle(diff.Magnitude, angle - Parent.Angle);
                }
                return Position;
            }
            set
            {
                if (Parent != null)
                    Position = value.Transform(Matrix.CreateRotationZ((float)Parent.Angle.Radians) * Matrix.CreateTranslation(Parent.Position));
                else
                    Position = value;
            }
        }
 
        public Vector RelativePositionToMainParent
        {
            get
            {
                if (Parent != null)
                {
                    GameObject mainParent = ((GameObject)this).GetMainParent();
                    Vector diff = Position - mainParent.Position;
                    Angle angle = diff.Angle;
                    return Vector.FromLengthAndAngle(diff.Magnitude, angle - mainParent.Angle);
                }
                return RelativePosition;
            }
            set
            {
                GameObject mainParent = ((GameObject)this).GetMainParent();
                if (Parent != null)
                    Position = value.Transform(Matrix.CreateRotationZ((float)mainParent.Angle.Radians) * Matrix.CreateTranslation(mainParent.Position));
                else
                    Position = value;
            }
        }
 
        public Angle RelativeAngle
        {
            get
            {
                if ( Parent != null )
                    return this.Angle - Parent.Angle;
                return Angle;
            }
            set
            {
                if (Parent != null)
                    Angle = Parent.Angle + value;
                else Angle = value;
            }
        }
 
        public Angle RelativeAngleToMainParent
        {
            get
            {
                if (Parent != null)
                {
                    GameObject mainParent = ((GameObject)this).GetMainParent();
                    return this.Angle - mainParent.Angle;
                }
                return RelativeAngle;
            }
            set
            {
                if (Parent != null)
                {
                    GameObject mainParent = ((GameObject)this).GetMainParent();
                    Angle = mainParent.Angle + value;
                }
                else
                    Angle = value;
            }
        }
 
        public Vector AbsolutePosition
        {
            get => Position;
            set => Position = value;
        }
 
        public Angle AbsoluteAngle
        {
            get => Angle;
            set => Angle = value;
        }
 
        public double Left
        {
            get { return Position.X - 0.5 * ( Size.Y * Math.Abs( Angle.Sin ) + Size.X * Math.Abs( Angle.Cos ) ); }
            set { Position = new Vector( value + Size.X / 2, Position.Y ); }
        }
 
        public double Right
        {
            get { return Position.X + 0.5 * ( Size.Y * Math.Abs( Angle.Sin ) + Size.X * Math.Abs( Angle.Cos ) ); }
            set { Position = new Vector( value - Size.X / 2, Position.Y ); }
        }
 
        public double Top
        {
            get { return Position.Y + 0.5 * ( Size.X * Math.Abs( Angle.Sin ) + Size.Y * Math.Abs( Angle.Cos ) ); }
            set { Position = new Vector( Position.X, value - Size.Y / 2 ); }
        }
 
        public double Bottom
        {
            get { return Position.Y - 0.5 * ( Size.X * Math.Abs( Angle.Sin ) + Size.Y * Math.Abs( Angle.Cos ) ); }
            set { Position = new Vector( Position.X, value + Size.Y / 2 ); }
        }
 
        public double RelativeLeft
        {
            get { return RelativePosition.X - (0.5 * (Size.Y * Math.Abs(RelativeAngle.Sin) + Size.X * Math.Abs(RelativeAngle.Cos))); }
            set { RelativePosition = new Vector(value + (Size.X / 2), RelativePosition.Y); }
        }
 
        public double RelativeRight
        {
            get { return RelativePosition.X + (0.5 * (Size.Y * Math.Abs(RelativeAngle.Sin) + Size.X * Math.Abs(RelativeAngle.Cos))); }
            set { RelativePosition = new Vector(value - (Size.X / 2), RelativePosition.Y); }
        }
 
        public double RelativeTop
        {
            get { return RelativePosition.Y + 0.5 * (Size.X * Math.Abs(RelativeAngle.Sin) + Size.Y * Math.Abs(RelativeAngle.Cos)); }
            set { RelativePosition = new Vector(RelativePosition.X, value - Size.Y / 2); }
        }
 
        public double RelativeBottom
        {
            get { return RelativePosition.Y - (0.5 * (Size.X * Math.Abs(RelativeAngle.Sin) + Size.Y * Math.Abs(RelativeAngle.Cos))); }
            set { RelativePosition = new Vector(RelativePosition.X, value + (Size.Y / 2)); }
        }
 
        public double X
        {
            get
            {
                return Position.X; // TODO: Nämä voisi joskus muuttaa tähän nätimpään nuolisyntaksiin.
            }
            set
            {
                Position = new Vector( value, Position.Y );
            }
        }
 
        public double Y
        {
            get
            {
                return Position.Y;
            }
            set
            {
                Position = new Vector( Position.X, value );
            }
        }
 
        public double AbsoluteX
        {
            get => Position.X;
            set => Position = new Vector(value, Position.Y);
        }
 
        public double AbsoluteY
        {
            get => Position.Y;
            set => Position = new Vector(Position.X, value);
        }
 
        public Vector UnitX
        {
            get { return Vector.FromAngle( Angle ); }
        }
 
        public Vector UnitY
        {
            get { return UnitX.LeftNormal; }
        }
 
        public Vector RelativeUnitX
        {
            get { return Vector.FromAngle( RelativeAngle ); }
        }
 
        public Vector RelativeUnitY
        {
            get { return RelativeUnitX.LeftNormal; }
        }
 
        public abstract Animation Animation { get; set; }
 
        public Image Image
        {
            get
            {
                if ( Animation != null )
                    return Animation.CurrentFrame;
                return null;
            }
            set
            {
                Animation = value;
            }
        }
 
        protected GameObjectBase()
        {
            this.CreationTime = Game.Time.SinceStartOfGame;
            this.Tag = "";
        }
 
        public abstract void MoveTo( Vector location, double speed, Action doWhenArrived );
 
        public void MoveTo( Vector location, double speed )
        {
            MoveTo( location, speed, null );
        }
 
        [EditorBrowsable( EditorBrowsableState.Never )]
        public virtual void Update( Time time )
        {
            if ( IsDestroyed )
                return;
 
            if ( Lifetime > MaximumLifetime )
            {
                Destroy();
                return;
            }
 
            Brain.DoUpdate( time );
        }
    }
}