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

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

namespace Rooms
{
    public abstract class Room
    {

        public Vector Position;
        public double width, height, thickness;
        protected List<IPhysicsObject> roomDecorations = new List<IPhysicsObject>();
        protected List<IPhysicsObject> roomObjects = new List<IPhysicsObject>();
        private bool isBuilt = false;
        protected IPhysicsObject[,] insideObjects;
        protected PhysicsObject[] doors = new PhysicsObject[4];
        protected double blockWidth, blockHeight;
        protected double insideWidth, insideHeight;
        protected Vector insidePos;
        protected int bWidth, bHeight;
        public TheDungeonGame Game { get; set; }
        public Vector PosOnGrid { get; set; }
        public PhysicsObject wall;
        public int EntityAmount { get; set; }

        public Room(TheDungeonGame 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(Position, 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 (roomDecorations.Count == 0 && roomObjects.Count == 0) throw new Exception("Cannot build empty room!");

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

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

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


            isBuilt = true;
        }

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

            foreach (IPhysicsObject obj in roomDecorations)
            {
                obj.Destroy();
            }
            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 addBlockAt(IPhysicsObject obj, double x, double y)
        {
            obj.Left = Position.X + x;
            obj.Top = Position.Y + y;
            roomObjects.Add(obj);
        }

        public void addEntityAt(EntityBase ent, 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);
            EntityAmount++;
            ent.Left = insidePos.X + (bx * blockWidth);
            ent.Top = insidePos.Y + (by * blockHeight);
            insideObjects[bx, by] = ent;
        }


        // En vitsinyt käyttää enempää aikaa tämän parantamiseksi. Helppo ja toimiva
        public void addDoors(Image doorTexture)
        {
            for (int i = 0; i < 4; i++)
            {
                Room room = Game.LevelGen.getRoomAt(PosOnGrid + RoomDirection.getOffsetFromDir(i));

                if (room == null) continue;

                PhysicsObject door = null;

                if (i == RoomDirection.North)
                {
                    door = PhysicsObject.CreateStaticObject(thickness, thickness);
                    door.Position = Position + new Vector((width + thickness) / 2, -thickness / 2);
                    door.Image = doorTexture;
                    door.Tag = RoomDirection.North;
                }
                else
                    if (i == RoomDirection.East)
                    {
                        door = PhysicsObject.CreateStaticObject(thickness, thickness);
                        door.Position = Position + new Vector(width + thickness / 2, -(height + thickness) / 2);
                        door.Image = doorTexture;
                        door.Angle = Angle.FromDegrees(270);
                        door.Tag = RoomDirection.East;
                    }
                    else
                        if (i == RoomDirection.South)
                        {
                            door = PhysicsObject.CreateStaticObject(thickness, thickness);
                            door.Position = Position + new Vector((thickness + width) / 2, -height - thickness / 2);
                            door.Image = Image.Flip(doorTexture);
                            door.Tag = RoomDirection.South;
                        }
                        else
                            if (i == RoomDirection.West)
                            {
                                door = PhysicsObject.CreateStaticObject(thickness, thickness);
                                door.Position = Position + new Vector(thickness / 2, -height / 2 - thickness / 2);
                                door.Image = doorTexture;
                                door.Angle = Angle.FromDegrees(90);
                                door.Tag = RoomDirection.West;
                            }
                if (door != null)
                {
                    roomObjects.Add(door);
                    doors[i] = door;
                }

            }
        }

        public PhysicsObject getDoor(int dir)
        {
            PhysicsObject result = null;
            for (int i = 0; i < doors.Length; i++ )
            {
                PhysicsObject door = doors[i];
                if (door != null && (int)door.Tag == dir)
                {
                    result = door;
                    return result;
                }

            }
            return result;
        }

        public void createBorders(Image topBottom, Image leftRight)
        {
            PhysicsObject wallTop = createWall(Position, width + thickness, thickness);
            wallTop.Color = Color.Blue;
            wallTop.Image = topBottom;
            PhysicsObject wallLeft = createWall(VecMath.sub(Position, new Vector(0, thickness)), thickness, height);
            wallLeft.Color = Color.Red;
            wallLeft.Image = leftRight;
            PhysicsObject wallDown = createWall(VecMath.sub(Position, new Vector(0, height)), width + thickness, thickness);
            wallDown.Color = Color.Black;
           if(topBottom != null) wallDown.Image = Image.Flip(topBottom);
            PhysicsObject wallRight = createWall(VecMath.add(Position, new Vector(width, -thickness)), thickness, height - thickness);
            wallRight.Color = Color.Orange;
           if(leftRight != null) wallRight.Image = Image.Mirror(leftRight);
            roomDecorations.Add(wallTop);
            roomDecorations.Add(wallLeft);
            roomDecorations.Add(wallDown);
            roomDecorations.Add(wallRight);
        }

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

            return wall;
        }

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

    public 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;
        }

        public static Vector getOffsetFromWorldDir(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;
        }
    }
}