Camera.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.Collections.Generic;
 
namespace Jypeli
{
    [Save]
    public class Camera : PositionalRW
    {
        // Huom. tätä käytetään vain jos seurataan useita olioita kerralla
        private List<GameObject> followedObjects = null;
        private Vector _pos = Vector.Zero;
 
        [Save] internal bool _stayInLevel = false;
        [Save] internal double _zoomFactor = 1.0;
 
        [Save]
        public Vector Position
        {
            get { return _pos; }
            set { _pos = value; }
        }
 
        [Save]
        public Vector Velocity { get; set; }
 
        public double X
        {
            get
            {
                return _pos.X;
            }
            set
            {
                _pos.X = value;
            }
        }
 
        public double Y
        {
            get
            {
                return _pos.Y;
            }
            set
            {
                _pos.Y = value;
            }
        }
 
        public double ZoomFactor
        {
            get { return _zoomFactor; }
            set { _zoomFactor = value; }
        }
 
        public bool StayInLevel
        {
            get { return _stayInLevel; }
            set { _stayInLevel = value; }
        }
 
        public GameObject FollowedObject { get; set; }
 
        public bool FollowsX { get; set; }
 
        public bool FollowsY { get; set; }
 
        [Save] public Vector FollowOffset { get; set; }
 
        public double FollowXMargin { get; set; }
 
        public double FollowYMargin { get; set; }
 
        internal Camera()
        {
            FollowsX = true;
            FollowsY = true;
            FollowXMargin = FollowYMargin = 600;
        }
 
        public Vector ScreenToWorld(Vector point)
        {
            return Position + (1 / ZoomFactor) * point;
        }
 
        public Vector WorldToScreen(Vector point)
        {
            return (point - Position) * ZoomFactor;
        }
 
        public Vector ScreenToWorld( Vector point, Layer layer )
        {
            if ( layer == null )
                return ScreenToWorld( point );
            if ( layer.IgnoresZoom )
                return Vector.ComponentProduct( Position, layer.RelativeTransition ) + point;
 
            return Vector.ComponentProduct( Position, layer.RelativeTransition ) + ( 1 / ZoomFactor ) * point;
        }
 
        public Vector WorldToScreen( Vector point, Layer layer )
        {
            if ( layer == null )
                return WorldToScreen( point );
            if ( layer.IgnoresZoom )
                return point - Vector.ComponentProduct( Position, layer.RelativeTransition );
 
            return ( point - Vector.ComponentProduct( Position, layer.RelativeTransition ) ) * ZoomFactor;
        }
 
        public void Move( Vector v )
        {
            Position += new Vector( v.X / ZoomFactor, v.Y / ZoomFactor );
        }
 
        public void Zoom( double zoom )
        {
            ZoomFactor *= zoom;
        }
 
        public void Reset()
        {
            Position = Vector.Zero;
            Velocity = Vector.Zero;
            ZoomFactor = 1.0f;
            StopFollowing();
        }
 
        public void Follow( params GameObject[] gameobjects )
        {
            FollowsX = true;
            FollowsY = true;
 
            if ( gameobjects.Length == 0 ) return;
            if ( gameobjects.Length == 1 )
            {
                FollowedObject = gameobjects[0];
                return;
            }
 
            FollowedObject = new GameObject( 1.0, 1.0 );
            followedObjects = new List<GameObject>( gameobjects );
            updateAvgPoint();
        }
 
        public void FollowX( params GameObject[] gameobjects )
        {
            Follow( gameobjects );
            FollowsX = true;
            FollowsY = false;
        }
 
        public void FollowY( params GameObject[] gameobjects )
        {
            Follow( gameobjects );
            FollowsX = false;
            FollowsY = true;
        }
 
        public void StopFollowing()
        {
            if ( followedObjects != null )
            {
                followedObjects = null;
                FollowedObject.Destroy();
            }
 
            FollowedObject = null;
        }
 
        private void updateAvgPoint()
        {
            FollowedObject.Position = followedObjects.ConvertAll<GameObject, Vector>( ( GameObject o ) => { return o.Position; } ).Average();
 
            double maxDx = followedObjects.ConvertAll<GameObject, double>( ( GameObject o ) => { return Math.Abs( o.X - FollowedObject.X ); } ).Max();
            double maxDy = followedObjects.ConvertAll<GameObject, double>( ( GameObject o ) => { return Math.Abs( o.Y - FollowedObject.Y ); } ).Max();
 
            double zoomX = Game.Screen.Width / ( 2 * maxDx + FollowXMargin );
            double zoomY = Game.Screen.Height / ( 2 * maxDy + FollowYMargin );
 
            ZoomFactor = Math.Min( zoomX, zoomY );
        }
 
        public void ZoomTo( Vector bottomLeft, Vector topRight )
        {
            ZoomTo( bottomLeft.X, bottomLeft.Y, topRight.X, topRight.Y );
        }
 
        public void ZoomTo( BoundingRectangle rectangle )
        {
            ZoomTo( rectangle.Left, rectangle.Bottom, rectangle.Right, rectangle.Top );
        }
 
        public void ZoomTo( BoundingRectangle rectangle, double borderSize )
        {
            ZoomTo( rectangle.Left, rectangle.Bottom, rectangle.Right, rectangle.Top, borderSize );
        }
 
        public void ZoomToAllObjects()
        {
            ZoomToAllObjects( 0 );
        }
 
        public void ZoomToAllObjects( double borderSize )
        {
            // Do the real zoom next update so all objects waiting to be added are added before that
            Game.DoNextUpdate( doZoomToAllObjects, borderSize );
        }
 
        private void doZoomToAllObjects( double borderSize )
        {
            if ( Game.Instance.ObjectCount > 0 )
                ZoomTo( Game.Instance.Level.FindObjectLimits(), borderSize );
        }
 
        public void ZoomTo( double left, double bottom, double right, double top )
        {
            ZoomTo( left, bottom, right, top, 0 );
        }
 
        internal void ZoomTo( double left, double bottom, double right, double top, double borderSize )
        {
            double screenWidth = (double)Game.Screen.Width;
            double screenHeight = (double)Game.Screen.Height;
            double width = right - left;
            double height = top - bottom;
 
            Position = new Vector( left + width / 2, bottom + height / 2 );
 
            if ( ( width / height ) >= ( screenWidth / screenHeight ) )
                this.ZoomFactor = screenWidth / ( width + borderSize );
            else
                this.ZoomFactor = screenHeight / ( height + borderSize );
        }
 
        public void ZoomToLevel()
        {
            ZoomToLevel( 0 );
        }
 
        public void ZoomToLevel( double borderSize )
        {
            FollowedObject = null;
            Level level = Game.Instance.Level;
            ZoomTo( level.Left, level.Bottom, level.Right, level.Top, borderSize );
        }
 
        internal void Update( Time time )
        {
            Position += Velocity * time.SinceLastUpdate.TotalSeconds;
 
            if ( FollowedObject != null )
            {
                Vector center = ScreenToWorld( Vector.Zero );
                Vector worldOffset = ScreenToWorld( FollowOffset );
 
                // Update the average point if following multiple objects
                if ( followedObjects != null ) updateAvgPoint();
 
                if ( FollowsX && FollowsY )
                    Position = FollowedObject.Position + ( worldOffset - center );
                else if ( FollowsX )
                    X = FollowedObject.X + ( worldOffset.X - center.X );
                else if ( FollowsY )
                    Y = FollowedObject.Y + ( worldOffset.Y - center.Y );
            }
 
            if ( StayInLevel )
            {
                double screenWidth = (double)Game.Screen.Width;
                double screenHeight = (double)Game.Screen.Height;
                Level level = Game.Instance.Level;
 
                double screenAspectRatio = screenWidth / screenHeight;
                double levelAspectRatio = level.Width / level.Height;
 
                double zoomedWidth = level.Width * ZoomFactor;
                double zoomedHeight = level.Height * ZoomFactor;
 
                double viewAreaWidth = screenWidth / ZoomFactor;
                double viewAreaHeight = screenHeight / ZoomFactor;
 
                if ( zoomedWidth < screenWidth || zoomedHeight < screenHeight )
                {
                    ZoomFactor = Math.Max( screenWidth / level.Width, screenHeight / level.Height );
                }
 
                if ( ( Position.X - ( viewAreaWidth / 2 ) ) < level.Left )
                {
                    _pos.X = level.Left + ( viewAreaWidth / 2 );
                }
                else if ( Position.X + ( viewAreaWidth / 2 ) > level.Right )
                {
                    _pos.X = level.Right - ( viewAreaWidth / 2 );
                }
 
                if ( Position.Y - ( viewAreaHeight / 2 ) < level.Bottom )
                {
                    _pos.Y = level.Bottom + ( viewAreaHeight / 2 );
                }
                else if ( Position.Y + ( viewAreaHeight / 2 ) > level.Top )
                {
                    _pos.Y = level.Top - ( viewAreaHeight / 2 );
                }
            }
        }
    }
}