source: 2011/23/hniemi/Pallospeli/Pallospeli/Pallospeli/Playfield.cs @ 1861

using System;
using System.Collections.Generic;
using Jypeli;
using Jypeli.Assets;
using Jypeli.Controls;
using Jypeli.Effects;
using Jypeli.Widgets;
using AdvanceMath;

namespace Pallospeli
{
    /// <summary>
    /// Playfield manages gamelogic
    /// 
    /// </summary>
    /// <example>
    /// Playfield logic = new Playfield(10,10);
    /// logic.Balls = null;
    /// 
    /// logic.Destroy(new location(4,5));
    /// </example>
    public class Playfield
    {
        private int width;
        private int height;

        private Color[] colorset;
        /// <summary>
        /// Colors used in game
        /// </summary>
        public Color[] Colorset { get { return colorset; } }

        private Location[][] directions = new Location[2][];
        private Location[] directionseteven = {
                                    new Location(-1 , 0),
                                    new Location( 1 , 0),
                                    new Location( -1 , -1),
                                    new Location( -1 , 1),
                                    new Location( 0 , 1),
                                    new Location( 0 , -1)};
        private Location[] directionsetuneven = {
                                    new Location(-1 , 0),
                                    new Location( 1 , 0),
                                    new Location( 0 , -1),
                                    new Location( 0 , 1),
                                    new Location( 1 , 1),
                                    new Location( 1 , -1)};

        /// <summary>
        /// Balls.Length is height, Balls[0].Length is width.
        /// </summary>
        private Ball[][] balls;
        /// <summary>
        /// Balls used in game.
        /// 
        /// Is value is null, RandomBalls is used.
        /// </summary>
        public Ball[][] Balls
        {
            get { return balls; }
            set 
            {
                if (value == null)
                { RandomBalls(); }
                else balls = value;
            }
        }

        /// <summary>
        /// Creates playfield from given width and height
        /// 
        /// Doesn't fill playfield with balls.
        /// </summary>
        /// <param name="width"></param>
        /// <param name="height"></param>
        public Playfield(int width, int height)
        {
            this.width = width;
            this.height = height;

            directions[0] = directionseteven;
            directions[1] = directionsetuneven;
        }

        /// <summary>
        /// Creates playfield from given balls
        /// </summary>
        /// <param name="balls"></param>
        public Playfield(Ball[][] balls)
        {
            Balls = balls;
            width = balls[0].Length;
            height = balls.Length;
            directions[0] = directionseteven;
            directions[1] = directionsetuneven;
        }

        /// <summary>
        /// Fills playfield with balls
        /// </summary>
        public void RandomBalls()
        {
            balls = new Ball[height][];
            for (int i = 0; i < balls.Length; i++)
            {
                balls[i] = new Ball[width - (i % 2)];
                for (int j = 0; j < balls[i].Length; j++)
                {
                    balls[i][j] = new Ball(i, j, colorset[RandomGen.NextInt(colorset.Length)]);
                }
            }
        }

        /// <summary>
        /// Destroys ball at location and neighbouring balls of same color.
        /// 
        /// If location is invalid, nothing happens.
        /// </summary>
        /// <param name="location">Location to be destroyed</param>
        public void Destroy(Location location)
        {
            Ball ball = Get(location);
            if (ball == null) return;
            ball.Presentation.Destroy();

            balls[location.Y][location.X] = null;

            List<Ball> near = GetNear(location);
            foreach (Ball item in near)
            {
                if (item.Color == ball.Color) Destroy(item.Location);
            }
        }

        /// <summary>
        /// Checks if balls are stabile. Destroys unstabile.
        /// </summary>
        public void StabilityCheck()
        {
            
            for (int i = 0; i < balls.Length; i++)
            {
                for (int j = 0; j < balls[i].Length; j++)
                {
                    if (balls[i][j] != null && !IsStabile(balls[i][j].Location))
                    {
                        Destroy(balls[i][j].Location);
                    }
                }
            }
        }

        /// <summary>
        /// Checks if ball in location is stabile.
        /// </summary>
        /// <param name="location">Location to of ball</param>
        /// <returns>True, is stabile</returns>
        public bool IsStabile(Location location)
        {
            if (location.Y < 0) return true;
            if (Get(location) == null) return false;
            return IsStabile(location + new Location(0, -1)) || IsStabile(location + new Location((location.Y%2 == 0 ? -1: 1), -1));
        }

        /// <summary>
        /// Returns list of balls near location.
        /// 
        /// If location has no neighbours, empty list is returned.
        /// </summary>
        /// <param name="location">Location</param>
        /// <returns>List of balls near location</returns>
        public List<Ball> GetNear(Location location)
        {
            List<Ball> list = new List<Ball>();
            for (int i = 0; i < directions[0].Length; i++)
            {
                Ball ball = Get(location + directions[location.Y%2][i] );
                if (ball != null) list.Add(ball);
            }
            return list;
        }

        /// <summary>
        /// Returns ball from coordinates
        /// 
        /// If coordinates has no balls, null is returned.
        /// </summary>
        /// <param name="x">X-coordinate of ball</param>
        /// <param name="y">Y-coordinate of ball</param>
        /// <returns></returns>
        public Ball Get(int x, int y)
        {
            if (x < 0 || y < 0 || y >= height || x >= width - (y % 2)) return null;
            if (balls[y][x] == null) return null;
            return balls[y][x];
        }

        /// <summary>
        /// Returns ball from given location
        /// 
        /// If location has no balls, null is returned.
        /// </summary>
        /// <param name="location">Location</param>
        /// <returns>Ball at location</returns>
        public Ball Get(Location location)
        { 
            return Get(location.X, location.Y);
        }

        public void FillColorset(int colors)
        {
            colorset = new Color[colors];
            for (int i = 0; i < colorset.Length; i++)
            {
                colorset[i] = RandomGen.NextColor();
            }
        }

        /// <summary>
        /// Repairs Balls[x][x].Locations
        /// </summary>
        public void RepairBallLocations()
        {
            for (int i = 0; i < balls.Length; i++)
            {
                for (int j = 0; j < balls[i].Length; j++)
                {
                    if (balls[i][j] != null)
                    {
                        balls[i][j].Location.X = j;
                        balls[i][j].Location.Y = i;
                    }
                }
            }
        }
    }
}