__GameObject.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion

/*
 * Authors: Tero Jäntti, Tomi Karppinen, Janne Nikkanen.
 */

using System;
using System.IO;
using System.Collections.Generic;
using System.ComponentModel;

#if !XBOX && !WINDOWS_PHONE
using System.Runtime.Serialization.Formatters.Binary;
#endif

using Microsoft.Xna.Framework;
using Jypeli.Controls;
using System.Reflection;


namespace Jypeli
{
#if !XBOX && !WINDOWS_PHONE
    [Serializable]
#endif
    [Save]
    public class GameObject : GameObjects.GameObjectBase, IGameObjectInternal
    {
        #region Fields

#if !XBOX && !WINDOWS_PHONE
        [NonSerialized]
#endif
        private Color color = Color.White;
        private Vector size;
        private Shape shape;
        private Vector textureWrapSize = new Vector( 1, 1 );

        internal List<IGameObject> childObjects = null;
        private Queue<IGameObject> childObjectsToRemove = null;

        public List<Listener> AssociatedListeners { get; private set; }

        private bool textureFillsShape = false;
        private bool isAddedToGame = false;

        protected Timer moveTimer = null;
        protected Vector? moveTarget = null;
        protected double moveSpeed;

        #endregion

        public IEnumerable<IGameObject> Objects
        {
            get { InitializeObjectLists(); return childObjects; } 
        }

        [Save] public bool IsVisible { get; set; }

        public override Vector Size
        {
            get { return size; }
            set
            {
                if ( value.X < 0.0 || value.Y < 0.0 )
                    throw new ArgumentException( "The size must be positive." );

                // TODO: this doesn't work properly.

                Vector oldSize = size;
                Vector newSize = value;
                size = value;

                double xFactor = newSize.X / oldSize.X;
                double yFactor = newSize.Y / oldSize.Y;
                if (childObjects != null)
                {
                    foreach (var o in childObjects)
                    {
                        Vector oldChildSize = o.Size;
                        o.Size = new Vector(oldChildSize.X * xFactor, oldChildSize.Y * yFactor);

                        //                    Vector direction = o.Position.Normalize();
                        //                    double distance = o.Position.Magnitude;
                        Vector oldChildPosition = o.Position;
                        o.Position = new Vector(oldChildPosition.X * xFactor, oldChildPosition.Y * yFactor);
                    }
                }
            }
        }

        public override Angle Angle { get; set; }

        public override Animation Animation { get; set; }

        public Vector TextureWrapSize
        {
            get { return textureWrapSize; }
            set { textureWrapSize = value; }
            }

        public Color Color
        {
            get { return color; }
            set { color = value; }
        }

        public bool TextureFillsShape
        {
            get { return textureFillsShape; }
            set { textureFillsShape = value; }
        }

        public virtual Shape Shape
        {
            get { return shape; }
            set { shape = value; }
        }

        internal string ShapeString
        {
            get { return Shape.GetType().Name; }
            set { Shape = Shape.FromString( value ); }
        }

        [Obsolete("Käytä Game.Instance ja IsAddedToGame")]
        public Game Game
        {
            get { return isAddedToGame ? Game.Instance : null; }
        }

        public bool IsAddedToGame
        {
            get { return isAddedToGame; }
            set
            {
                isAddedToGame = value;
                if ( childObjects != null )
                {
                    foreach ( var o in childObjects )
                        o.IsAddedToGame = value;
                }
            }
        }

        [Obsolete("Käytä mieluummin Arrived-tapahtumaa (ottaa parametriksi IGameObject pelkän GameObjectin sijaan)")]
        public event Action<GameObject, Vector> ArrivedAt;

        [Obsolete( "Käytä mieluummin Arrived-tapahtumaa (ottaa parametriksi IGameObject pelkän GameObjectin sijaan)" )]
        public void OnArrivedAt( Vector location )
        {
            if ( ArrivedAt != null )
                ArrivedAt( this, location );
        }

        #region Destroyable

        public override void Destroy()
        {
            this.MaximumLifetime = TimeSpan.Zero;

            if ( childObjects != null )
            {
                foreach ( GameObject child in childObjects )
                {
                    child.Destroy();
                }
            }

            if ( AssociatedListeners != null )
            {
                foreach ( Listener listener in AssociatedListeners )
                {
                    listener.Destroy();
                }
            }

            base.Destroy();
        }

        #endregion

        public GameObject( double width, double height )
            : this( width, height, Shape.Rectangle )
        {
        }

        public GameObject(Image image)
            : this( image.Width, image.Height, Shape.Rectangle )
        {
            this.Image = image;
        }

        public GameObject( double width, double height, Shape shape )
            : base()
        {
            this.IsVisible = true;
            this.size = new Vector( width, height );
            this.shape = shape;
            this.AssociatedListeners = new List<Listener>();
            this.Arrived += delegate( IGameObject obj, Vector location ) { OnArrivedAt( location ); };
        }

#if !XBOX && !WINDOWS_PHONE
        public object Clone()
        {
            MemoryStream ms = new MemoryStream();
            BinaryFormatter bf = new BinaryFormatter();

            bf.Serialize( ms, this );
            ms.Position = 0;

            object obj = bf.Deserialize( ms );
            ms.Close();

            // Copy nonserializable data
            ( (GameObject)obj ).Animation = new Animation( this.Animation );

            return obj;
        }
#endif

        public bool IsInside(Vector point)
        {
            Vector p = this.AbsolutePosition;

            if ( AbsoluteAngle == Angle.Zero )
            {
                // A special (faster) case of the general case below
                if ( point.X >= ( p.X - Width / 2 )
                    && point.X <= ( p.X + Width / 2 )
                    && point.Y >= ( p.Y - Height / 2 )
                    && point.Y <= ( p.Y + Height / 2 ) ) return true;
            }
            else
            {
                Vector unitX = Vector.FromLengthAndAngle( 1, this.AbsoluteAngle );
                Vector unitY = unitX.LeftNormal;
                double pX = p.ScalarProjection( unitX );
                double pY = p.ScalarProjection( unitY );
                double pointX = point.ScalarProjection( unitX );
                double pointY = point.ScalarProjection( unitY );

                if ( pointX >= ( pX - Width / 2 )
                    && pointX <= ( pX + Width / 2 )
                    && pointY >= ( pY - Height / 2 )
                    && pointY <= ( pY + Height / 2 ) ) return true;
            }

            if ( childObjects == null ) return false;

            for ( int i = 0; i < childObjects.Count; i++ )
            {
                if ( childObjects[i].IsInside( point ) ) return true;
            }

            return false;
        }

        public void Add( IGameObject childObject )
        {
            var childObjectInt = (IGameObjectInternal)childObject;

            InitializeObjectLists();

            if ( childObjects.Contains( childObject ) )
                throw new ArgumentException( "The child object has already been added" );
            if ( childObject is PhysicsObject )
                throw new NotImplementedException( "Having a PhysicsObject as a child object is not supported." );

            childObjects.Add( childObject );
            childObject.Parent = this;

            if ( IsAddedToGame )
            {
                childObject.IsAddedToGame = true;
                childObjectInt.OnAddedToGame();
            }
            else
                AddedToGame += childObjectInt.OnAddedToGame;


            // Let's keep it simple and assume that child objects need updating,
            // even if that is not the case.
            if ( !IsUpdated )
                IsUpdated = true;
        }

        private void InitializeObjectLists()
        {
            if ( childObjects == null )
            {
                childObjects = new List<IGameObject>();
                childObjectsToRemove = new Queue<IGameObject>();
            }
        }

        public void Remove( IGameObject childObject )
        {
            childObjectsToRemove.Enqueue( childObject );
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        public virtual void Update( Time time )
        {
            base.Update( time );

            if (childObjects != null)
            {
                foreach (GameObject child in childObjects)
                {
                    child.Update(time);
                    if (child.IsDestroyed)
                    {
                        childObjectsToRemove.Enqueue(child);
                    }
                }

                while (childObjectsToRemove.Count > 0)
                {
                    IGameObject o = childObjectsToRemove.Dequeue();
                    childObjects.Remove(o);
                    this.AddedToGame -= ( (IGameObjectInternal)o ).OnAddedToGame;
                    o.IsAddedToGame = false;
                }
            }
        }

        public void SetImage( StorageFile file )
        {
            this.Image = Image.FromStream( file.Stream );
        }

        public virtual void Move( Vector movement )
        {
            Position += movement;
        }

        public virtual void MoveTo( Vector location, double speed )
        {
            if ( moveTimer == null )
            {
                moveTimer = new Timer();
                moveTimer.Timeout += MoveToTarget;
                moveTimer.Interval = 0.01;
            }
            else if ( moveTimer.Enabled )
                moveTimer.Stop();

            moveSpeed = speed;
            moveTarget = location;
            moveTimer.Start();
        }

        protected virtual void MoveToTarget()
        {
            if ( !moveTarget.HasValue )
            {
                moveTimer.Stop();
                return;
            }

            Vector d = moveTarget.Value - Position;
            double vt = moveSpeed * moveTimer.Interval;

            if ( d.Magnitude < vt )
            {
                Vector targetLoc = moveTarget.Value;
                moveTimer.Stop();
                Position = moveTarget.Value;
                moveTarget = null;
                OnArrived( targetLoc );
            }
            else
                //Position += d.Normalize() * moveSpeed * sender.Interval;
                Position += Vector.FromLengthAndAngle( vt, d.Angle );
        }
    }
}