source: 2012/27/DenisZ/TheDungeonGame/TheDungeonGame/TheDungeonGame/Room.cs @ 3515

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Jypeli;
using MathHelper;

namespace Rooms
{
    abstract class Room
    {
        
       public Vector Position;
        public double width, height, thickness;
        protected List<IPhysicsObject> roomObjects = new List<IPhysicsObject>();
        private bool isBuilt = false;
        protected IPhysicsObject[,] insideObjects;
        protected double blockWidth, blockHeight;
        protected double insideWidth, insideHeight;
        protected Vector insidePos;
        protected int bWidth, bHeight;
        public Game Game { get; set; }
        public Vector PosOnGrid { get; set; }

        public Room(Game game, Vector pos, Vector size, double thickness)
        {
            Game = game;
            Position = VecMath.sub(pos, new Vector(Game.Level.Width / 2, -(Game.Level.Height / 2)));
            width = size.X;
            height = size.Y;
            this.thickness = thickness;

            insidePos = VecMath.add(pos, new Vector(thickness, -thickness));
            insideWidth = width - thickness;
            insideHeight = height - thickness;
            blockWidth = insideWidth / 10;
            blockHeight = blockWidth;
            bWidth = (int)(insideWidth / blockWidth);
            bHeight = (int)(insideHeight / blockHeight);

            insideObjects = new PhysicsObject[bWidth, bHeight];
        }

        public abstract void initRoom();

        public void buildLevel()
        {
            if (roomObjects.Count == 0) throw new Exception("Cannot build empty room!");

            foreach (IPhysicsObject obj in roomObjects)
            {
                Game.Add(obj);
            }

            foreach (IPhysicsObject obj in insideObjects)
            {
                if (obj != null)
                    Game.Add(obj);
            }


            isBuilt = true;
        }

        public void destroyLevel()
        {
            if (roomObjects.Count == 0) throw new Exception("Cannot destory empty room!");
            if (!isBuilt) throw new Exception("Cannot destroy unbuilt room!");

            foreach (IPhysicsObject obj in roomObjects)
            {
                obj.Destroy();
            }
            foreach (IPhysicsObject obj in insideObjects)
            {
                if (obj != null)
                    obj.Destroy();
            }
        }

        public void addBlock(IPhysicsObject obj, int bx, int by)
        {
            if (bx > bWidth || bx < 0 || by > bHeight || by < 0 || insideObjects[bx, by] != null) throw new Exception("Can't put block to " + bx + " , " + by);
            obj.Left = insidePos.X + (bx * blockWidth);
            obj.Top = insidePos.Y + (by * blockHeight);
            insideObjects[bx, by] = obj;
        }

        public void createBorders()
        {
            PhysicsObject wallTop = createWall(Position, width + thickness, thickness);
            PhysicsObject wallLeft = createWall(VecMath.sub(Position, new Vector(0, thickness)), thickness, height);
            PhysicsObject wallDown = createWall(VecMath.sub(Position, new Vector(0, height)), width + thickness, thickness);
            wallDown.Color = Color.Black;
            PhysicsObject wallRight = createWall(VecMath.add(Position, new Vector(width, -thickness)), thickness, height - thickness);
            roomObjects.Add(wallTop);
            roomObjects.Add(wallLeft);
            roomObjects.Add(wallDown);
            roomObjects.Add(wallRight);
        }

        public PhysicsObject createWall(Vector pos, double width, double height)
        {
            PhysicsObject wall = PhysicsObject.CreateStaticObject(width, height);
            wall.Left = pos.X;
            wall.Top = pos.Y;

            return wall;
        }

        public PhysicsObject createBackground()
        {
            PhysicsObject bg = PhysicsObject.CreateStaticObject(insideWidth, insideHeight);
            bg.Left = Position.X + thickness;
            bg.Top = Position.Y - thickness;
            bg.IgnoresCollisionResponse = true;
            bg.Color = Color.Green;
            bg.IgnoresExplosions = true;
            return bg;
        }

    }

    class RoomDirection
    {
        public const int North = 0;
        public const int East = 1;
        public const int South = 2;
        public const int West = 3;

        public static Vector getOffsetFromDir(int dir)
        {
            if (dir == North)
                return new Vector(0, -1);
            if (dir == East)
                return new Vector(1, 0);
            if (dir == South)
                return new Vector(0, 1);
            if (dir == West)
                return new Vector(-1, 0);

            return Vector.Zero;
        }
    }
}