Layers.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using Jypeli.Controls;
 
namespace Jypeli
{
    public partial class Game : GameObjectContainer
    {
        public SynchronousList<Layer> Layers { get; private set; }
 
        public IList<Layer> StaticLayers
        {
            get
            {
#if WINDOWS_STOREAPP
                return Layers.FindAll( l => l.IgnoresZoom && l.RelativeTransition == Vector.Zero );
#else
                return Layers.FindAll( l => l.IgnoresZoom && l.RelativeTransition == Vector.Zero ).AsReadOnly();
#endif
            }
        }
 
        public IList<Layer> DynamicLayers
        {
#if WINDOWS_STOREAPP
            get { return Layers.FindAll( l => !l.IgnoresZoom || l.RelativeTransition != Vector.Zero ); }
#else
            get { return Layers.FindAll( l => !l.IgnoresZoom || l.RelativeTransition != Vector.Zero ).AsReadOnly(); }
#endif
        }
 
        public int MinLayer
        {
            get { return Layers.FirstIndex; }
        }
 
        public int MaxLayer
        {
            get { return Layers.LastIndex; }
        }
 
        public int LayerCount
        {
            get { return Layers.Count; }
        }
 
        internal int ObjectCount
        {
            get
            {
                return Layers.Sum<Layer>( l => l.Objects.Count );
            }
        }
 
        private void InitLayers()
        {
            Layers = new SynchronousList<Layer>( -3 );
            Layers.ItemAdded += OnLayerAdded;
            Layers.ItemRemoved += OnLayerRemoved;
 
            for ( int i = 0; i < 7; i++ )
            {
                Layers.Add( new Layer() );
            }
 
            // This is the widget layer
            Layers.Add( Layer.CreateStaticLayer() );
 
            Layers.UpdateChanges();
        }
 
        protected virtual void OnObjectAdded( IGameObject obj )
        {
            IGameObjectInternal iObj = obj as IGameObjectInternal;
            if ( iObj == null ) return;
            iObj.IsAddedToGame = true;
            iObj.OnAddedToGame();
 
            ControlContexted cObj = obj as ControlContexted;
            if ( cObj != null ) ActivateObject( cObj );
        }
 
        protected virtual void OnObjectRemoved( IGameObject obj )
        {
            IGameObjectInternal iObj = obj as IGameObjectInternal;
            if ( iObj == null ) return;
            iObj.IsAddedToGame = false;
            iObj.OnRemoved();
 
            ControlContexted cObj = obj as ControlContexted;
            if ( cObj != null ) DeactivateObject( cObj );
        }
 
        internal static void OnAddObject( IGameObject obj )
        {
            Debug.Assert( Instance != null );
            Instance.OnObjectAdded( obj );
        }
 
        internal static void OnRemoveObject( IGameObject obj )
        {
            Debug.Assert( Instance != null );
            Instance.OnObjectRemoved( obj );
        }
 
        private void OnLayerAdded( Layer l )
        {
            l.Objects.ItemAdded += this.OnObjectAdded;
            l.Objects.ItemRemoved += this.OnObjectRemoved;
        }
 
        private void OnLayerRemoved( Layer l )
        {
            l.Objects.ItemAdded -= this.OnObjectAdded;
            l.Objects.ItemRemoved -= this.OnObjectRemoved;
        }
 
        public void Add( IGameObject o )
        {
            if ( o.Layer != null && o.Layer.Objects.WillContain( o ) )
            {
                if ( o.Layer == Layers[0] )
                {
                    throw new NotSupportedException( "Object cannot be added twice" );
                }
                else
                    throw new NotSupportedException( "Object cannot be added to multiple layers" );
            }
 
            if ( o is Widget ) Add( o, MaxLayer );
            else Add( o, 0 );
        }
 
        public virtual void Add( IGameObject o, int layer )
        {
            if ( o == null ) throw new NullReferenceException( "Tried to add a null object to game" );
            Layers[layer].Add( o );
        }
 
        internal static IList<IGameObject> GetObjectsAboutToBeAdded()
        {
            List<IGameObject> result = new List<IGameObject>();
 
            foreach ( Layer layer in Game.Instance.Layers )
            {
                layer.GetObjectsAboutToBeAdded( result );
            }
 
            return result;
        }
 
        public void Add( Layer l )
        {
            Layers.Add( l );
            Layers.UpdateChanges();
        }
 
        public void Remove( IGameObject o )
        {
            if ( !o.IsAddedToGame )
                return;
 
            foreach ( Layer l in Layers )
                l.Remove( o );
        }
 
        public void Remove( Layer l )
        {
            Layers.Remove( l );
            Layers.UpdateChanges();
        }
 
        public void ClearGameObjects()
        {
            foreach (var layer in Layers)
            {
                layer.Clear();
            }
 
            // Layer.Clear on synkronoitu operaatio, joten viestinäyttöä ei ole vielä poistettu.
            // Siksi viestinäytön palauttaminen on lisättävä operaatiojonoon pakotetusti.
            addMessageDisplay(force: true);
        }
 
        public void ResetLayers()
        {
            foreach (var layer in Layers)
            {
                layer.Clear();
 
                // Jos muutoksia ei päivitetä, niin taso ei ehdi oikeasti hävittää
                // olioitaan, koska InitLayers luo uudet tasot ja sen jälkeen
                // vanhat tasot muuttuvat roskaksi - siten esim. peliolioiden
                // OnRemoved-metodia ei kutsuta ilman tätä ApplyChanges()-kutsua
                layer.ApplyChanges();
            }
 
            InitLayers();
        }
 
        public void RemoveAllLayers()
        {
            ClearGameObjects();
            Layers.Clear();
        }
 
        #region GetObject methods
        public List<GameObject> GetObjects( Predicate<GameObject> condition )
        {
            List<GameObject> objs = new List<GameObject>();
 
            for ( int i = MaxLayer; i >= MinLayer; i-- )
            {
                foreach ( var obj in Layers[i].Objects )
                {
                    GameObject gobj = obj as GameObject;
 
                    if ( gobj != null && condition( gobj ) )
                        objs.Add( gobj );
                }
            }
 
            return objs;
        }
 
        public List<GameObject> GetAllObjects()
        {
            return GetObjects(g => true);
        }
        
        public List<GameObject> GetObjectsWithTag( params string[] tags )
        {
            return GetObjects( o => tags.Contains<string>( o.Tag as string ) );
        }
 
        public GameObject GetFirstObject( Predicate<GameObject> condition )
        {
            for ( int i = MaxLayer; i >= MinLayer; i-- )
            {
                foreach ( var obj in Layers[i].Objects )
                {
                    GameObject gobj = obj as GameObject;
 
                    if ( gobj != null && condition( gobj ) )
                        return gobj;
                }
            }
 
            return null;
        }
 
        public List<GameObject> GetObjectsAt( Vector position )
        {
            return GetObjects( obj => obj.IsInside( position ) );
        }
 
        public List<GameObject> GetObjectsAt( Vector position, double radius )
        {
            Predicate<GameObject> isInsideRadius = delegate( GameObject obj )
            {
                if ( IsJypeliWidget<GameObject>( obj ) ) return false;
 
                Vector positionUp = new Vector( position.X, position.Y + radius );
                Vector positionDown = new Vector( position.X, position.Y - radius );
                Vector positionLeft = new Vector( position.X - radius, position.Y );
                Vector positionRight = new Vector( position.X + radius, position.Y );
 
                if ( obj.IsInside( position ) ) return true;
                if ( obj.IsInside( positionUp ) ) return true;
                if ( obj.IsInside( positionDown ) ) return true;
                if ( obj.IsInside( positionLeft ) ) return true;
                if ( obj.IsInside( positionRight ) ) return true;
 
                return false;
            };
 
            return GetObjects( isInsideRadius );
        }
 
        public GameObject GetObjectAt( Vector position )
        {
            return GetFirstObject( obj => obj.IsInside( position ) && !IsJypeliWidget<GameObject>( obj ) );
        }
 
        public GameObject GetObjectAt( Vector position, double radius )
        {
            var objs = GetObjectsAt( position, radius );
            return objs.Count > 0 ? objs[0] : null;
        }
 
        public List<GameObject> GetObjectsAt( Vector position, object tag )
        {
            return GetObjectsAt( position ).FindAll( obj => obj.Tag == tag );
        }
 
        public GameObject GetObjectAt( Vector position, object tag )
        {
            return GetObjectsAt( position ).Find( obj => obj.Tag == tag );
        }
 
        public List<GameObject> GetObjectsAt( Vector position, object tag, double radius )
        {
            return GetObjectsAt( position, radius ).FindAll<GameObject>( obj => obj.Tag == tag );
        }
 
        public GameObject GetObjectAt( Vector position, object tag, double radius )
        {
            return GetObjectsAt( position, radius ).Find( obj => obj.Tag == tag );
        }
 
        public List<GameObject> GetObjectsBetween(Vector pos1, Vector pos2)
        {
            return GetObjects(palikka => !(palikka is Widget) && palikka.IsBetween(pos1, pos2));
        }
 
        public Widget GetFirstWidget( Predicate<Widget> condition )
        {
            return (Widget)GetFirstObject( obj => obj is Widget && condition( (Widget)obj ) );
        }
 
        public Widget GetWidgetAt( Vector position )
        {
            return (Widget)GetFirstObject( obj => obj is Widget && obj.IsInside( position ) && !IsJypeliWidget<IGameObject>( obj ) );
        }
#endregion
    }
}