GameObjectBase.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
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 IntPoint PosInLevel;
        public List<Object> Data;


        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()
        {
            if ( AddedToGame != null )
                AddedToGame();
            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 ); }
        }

        public Vector AbsolutePosition
        {
            get
            {
                if ( Parent != null )
                    return Parent.AbsolutePosition + Parent.UnitX * Position.X + Parent.UnitY * Position.Y;

                return Position;
            }
            set
            {
                if ( Parent != null )
                    Position = value - Parent.AbsolutePosition;
                else
                    Position = value;
            }
        }

        public Angle AbsoluteAngle
        {
            get
            {
                if ( Parent != null )
                    return Parent.AbsoluteAngle + this.Angle;
                return Angle;
            }
            set
            {
                if ( Parent != null )
                    Angle = value - Parent.AbsoluteAngle;
                else
                    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 AbsLeft
        {
            get { return AbsolutePosition.X - 0.5 * ( Size.Y * Math.Abs( Angle.Sin ) + Size.X * Math.Abs( Angle.Cos ) ); }
        }

        public double AbsRight
        {
            get { return AbsolutePosition.X + 0.5 * ( Size.Y * Math.Abs( Angle.Sin ) + Size.X * Math.Abs( Angle.Cos ) ); }
        }

        public double AbsTop
        {
            get { return AbsolutePosition.Y + 0.5 * ( Size.X * Math.Abs( Angle.Sin ) + Size.Y * Math.Abs( Angle.Cos ) ); }
        }

        public double AbsBottom
        {
            get { return AbsolutePosition.Y - 0.5 * ( Size.X * Math.Abs( Angle.Sin ) + Size.Y * Math.Abs( Angle.Cos ) ); }
        }

        public double X
        {
            get
            {
                return Position.X;
            }
            set
            {
                Position = new Vector( value, Position.Y );
            }
        }

        public double Y
        {
            get
            {
                return 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 AbsoluteUnitX
        {
            get { return Vector.FromAngle( AbsoluteAngle ); }
        }

        public Vector AbsoluteUnitY
        {
            get { return AbsoluteUnitX.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 );
        }
    }
}