public WalksOnFurni(RoomItem item, Room room)
 {
     Item = item;
     Room = room;
     ToWork = new Queue();
     Items = new List<RoomItem>();
 }

 public override void Update(Room room, Player player)
 {
     Vector2 offset = player.position - position;
     Vector2 range = Main.instance.Size();
     if (Math.Abs(offset.X) > range.X / 2f || Math.Abs(offset.Y) > range.Y / 2f)
     {
         shootTimer = 0;
     }
     else
     {
         shootTimer++;
         if (shootTimer >= maxShootTimer)
         {
             Vector2 direction = offset;
             if (direction != Vector2.Zero)
             {
                 direction.Normalize();
             }
             direction *= shootSpeed;
             PositionalBullet bullet = new PositionalBullet(position, direction, 10f, bulletTexture, bulletTime);
             room.bullets.Add(bullet);
             shootTimer = 0;
         }
     }
 }

        public Room AddRoom(Enum id)
        {
            var room = new Room(this, id.ToString());
            _rooms.Add(id, room);

            return room;
        }

    public static void BuildLevel()
    {
        Room room00 = new Room("room 00", "It's clearly a room");

        Room room01 = new Room("room 01", "It's clearly a room");
        Room room02 = new Room("room 02", "It's clearly a room");
        Room room10 = new Room("room 10", "It's clearly a room");
        Room room11 = new Room("room 11", "It's clearly a room");
        Room room12 = new Room("room 12", "It's clearly a room");
        //Room room20 = new Room("room 20", "room description");
        //Room room21 = new Room("room 21", "room description");
        Room room22 = new Room("room 22", "It's clearly a room");

        Item key = new Item("Key", "A brass object used to unlock a specific lock. Commonly known as a 'Key'", room11, null, Action.OpenDoor, room11);
        room11.AddItem(key);

        Door door = new Door("Door", "A wooden board with hinges on one side, usually used to block a passage way. Commonly known as a 'Door'", room12, room22, key, null, Action.None);
        door.locked = true;
        room12.doorSouth = door;
        room12.AddObject(door);
        room22.doorNorth = door;
        room22.AddObject(door);

        dungeon[0, 0] = room00;
        dungeon[0, 1] = room01;
        dungeon[0, 2] = room02;
        dungeon[1, 0] = room10;
        dungeon[1, 1] = room11;
        dungeon[1, 2] = room12;
        //dungeon[2, 0] = room20;
        //dungeon[2, 1] = room21;
        dungeon[2, 2] = room22;

        startingRoom = room00;
    }

 public UserIsWearingBadge(RoomItem item, Room room)
 {
     Item = item;
     Room = room;
     Items = new List<RoomItem>();
     OtherString = string.Empty;
 }

        public RoomImage(Room room, Wall wall, Point source)
        {
            if(!room.Walls.Contains(wall) || !room.Sources.Contains(source)) throw new ArgumentException("Room elements are non-existent");
            ImageWalls = new Wall[room.Walls.Count];
            ImageWalls[0] = wall;

            int i = 1;
            foreach (Wall roomWall in room.Walls)
            {
                if (roomWall == wall) continue;
                Point startVector = Geometry.ParallelProjection(wall, roomWall.Start,true);
                startVector.X -= roomWall.Start.X;
                startVector.Y -= roomWall.Start.Y;

                Point endVector = Geometry.ParallelProjection(wall, roomWall.End, true);
                endVector.X -= roomWall.End.X;
                endVector.Y -= roomWall.End.Y;

                Point newStart = new Point(roomWall.Start.X+2*startVector.X,roomWall.Start.Y+2*startVector.Y);
                Point newEnd = new Point(roomWall.End.X + 2 * endVector.X, roomWall.End.Y + 2 * endVector.Y);
                ImageWalls[i] = new Wall(newStart,newEnd,roomWall.WallMaterial);
                i++;
            }
            Point sourceVector = Geometry.ParallelProjection(wall, source, true);
            sourceVector.X -= source.X;
            sourceVector.Y -= source.Y;
            Source = new Point(source.X+2*sourceVector.X,source.Y+2*sourceVector.Y);
        }

        public Stu(Point position, Room.Room room)
            : base(room)
        {
            Stats = new CharacterStats
            {
                MinimumDamage = 10,
                MaximumDamage = 15,
                BaseHealth = 100,
                DamageReduction = 0.04,
                Dexterity = 15
            };

            Position = position;

            /*Drinks.Add(new OrangeJuice());
            Drinks.Add(new RedBull());
            Drinks.Add(new Coffee());
            FoodItems.Add(new Pizza());
            FoodItems.Add(new Burger());
            FoodItems.Add(new Taco());*/

            ResourceImage = "Resources/stu.jpg";
            Name = "Stu";

            ResetHealth();
        }

    public void OnJoinRoom(BaseEvent evt)
    {
        Room room = (Room)evt.Params["room"];
        currentActiveRoom = room;

        Debug.Log("onjoinroom = " + currentActiveRoom.Name);

        if (room.Name == "The Lobby")
            Application.LoadLevel(room.Name);
        else if (room.IsGame)
        {
            //Debug.Log("is game!!!!");
            //store my own color on server as user data
            List<UserVariable> uData = new List<UserVariable>();
            uData.Add(new SFSUserVariable("playerID", GameValues.playerID));
            smartFox.Send(new SetUserVariablesRequest(uData));
            Application.LoadLevel("testScene");
        }
        else
        {
            Debug.Log("GameLobby- OnJoinRoom: joined " + room.Name);
            Application.LoadLevel("Game Lobby");
            Debug.Log("loading Game Lobby");
            //smartFox.Send(new SpectatorToPlayerRequest());
        }
    }

 public Session(Slot slot, Room room, Speaker speaker, string title)
 {
     Slot = slot;
     Room = room;
     Speaker = speaker;
     Title = title;
 }

 public LessThanTimer(int timeout, Room room, RoomItem item)
 {
     this.timeout = timeout;
     this.room = room;
     this.isDisposed = false;
     this.item = item;
 }

        private static void Distribute(IDictionary<int, Person> people, Room room, int maxIterations)
        {
            var index = 0;
            var peopleByNumberFriends = people.Values.OrderBy(x => x.NumberOfFriends).ToArray();
            var spotsByNumberNeighbours = room.OrderBy(x => x.Neighbours.Keys.Count).ToArray();

            foreach (var spot in spotsByNumberNeighbours) {
                spot.Person = peopleByNumberFriends[index++];
            }

            var iterations = 0;
            var changeMade = false;
            do {
                var awfulSpots = room.OrderBy(x => x.Score).ToList();
                var spot1 = awfulSpots.First();
                foreach (var spot2 in awfulSpots.Skip(1)) {
                    var currentScore = spot1.Score + spot2.Score;
                    var p1 = spot1.Person;
                    var p2 = spot2.Person;
                    spot1.Person = p2;
                    spot2.Person = p1;

                    if (spot1.Score + spot2.Score > currentScore) {
                        changeMade = true;
                        break;
                    }

                    // restore
                    spot1.Person = p1;
                    spot2.Person = p2;
                }
                iterations++;
            } while (changeMade && iterations < maxIterations);
        }

 public WalksOffFurni(RoomItem Item, Room Room)
 {
     this.mItem = Item;
     this.mRoom = Room;
     this.mUsers = new Queue();
     this.mItems = new List<RoomItem>();
 }

        private Hashtable roomMatrix; //Coord | List<IWiredCondition>

        #endregion Fields

        #region Constructors

        public ConditionHandler(Room room)
        {
            this.room = room;
            this.roomMatrix = new Hashtable();
            this.addQueue = new Queue();
            this.removeQueue = new Queue();
        }

 public SaysKeyword(RoomItem item, Room room)
 {
     Item = item;
     Room = room;
     OtherString = string.Empty;
     OtherBool = false;
 }

 public Soccer(Room room)
 {
     this._room = room;
     this.gates = new Item[4];
     this._balls = new ConcurrentDictionary<int, Item>();
     this._gameStarted = false;
 }

 //private List<InteractionType> mBanned;
 public JoinTeam(RoomItem item, Room room)
 {
     Item = item;
     Room = room;
     _mDelay = 0;
     //this.mBanned = new List<InteractionType>();
 }

    private void LinkRoom(Room StartRoom, Room DestinationRoom, string Direction)
    {
        if (StartRoom == null) return;

        switch (Direction.ToLower())
        {
            case "west":
                StartRoom.West = DestinationRoom;
                if (DestinationRoom.East == null) { DestinationRoom.East = StartRoom; }
                break;
            case "east":
                StartRoom.East = DestinationRoom;
                if (DestinationRoom.West == null) { DestinationRoom.West = StartRoom; }
                break;
            case "north":
                StartRoom.North = DestinationRoom;
                if (DestinationRoom.South == null) { DestinationRoom.South = StartRoom; }
                break;
            case "south":
                StartRoom.West = DestinationRoom;
                if (DestinationRoom.North == null) { DestinationRoom.North = StartRoom; }
                break;
            default:
                if (StartRoom.AdditionalLink[Direction] == null)
                {
                    StartRoom.AdditionalLink[Direction] = DestinationRoom;
                }
                break;
        }
    }

        internal bool HasAllRequiredFurnis(Room room)
        {
            if (room == null)
                return false;

            return RequiredFurnis.All(furni => room.GetRoomItemHandler().HasFurniByItemName(furni));
        }

        public override Room[,] GenerateRooms(int maxRooms)
        {
            Directions[] directions = (Directions[])Enum.GetValues(typeof(Directions));
            List<Room> rooms = new List<Room>();
            rooms.Add(new Room(new Point(0, 0)));

            while (rooms.Count < maxRooms)
            {
                Room targetRoom = rooms[Randomizer.GetRandomNumber(rooms.Count)];
                Directions direction = Randomizer.GetRandomDirection();
                Exit targetExit = targetRoom.GetExit(direction);

                if (targetExit != null)
                    continue;

                targetExit = new Exit(direction);
                targetRoom.AddExit(direction);
                Room neighbor = GetRoomAtPoint(targetRoom.GetNeighborCoordinates(direction), rooms);
                Directions neighborDirection = ReverseDirection(direction);

                if (neighbor != null)
                    neighbor.AddExit(neighborDirection);
                else
                {
                    Room newRoom = new Room(targetRoom.GetNeighborCoordinates(direction));
                    newRoom.AddExit(neighborDirection);
                    rooms.Add(newRoom);
                }
            }
            Room[,] roomArray = ConvertListToMap(MarkSpecialRooms<Room>(rooms));

            return roomArray;
        }

        public bool addRoom(Room room)
        {
            try
            {
                int param = 3;

                string[] name = new string[param];
                object[] value = new object[param];

                name[0] = "@name"; value[0] = room.Name;
                name[1] = "@statusid"; value[1] = room.StatusID;
                name[2] = "@roomtypeid"; value[2] = room.RoomType;

                int result = this.Update("Room_Insert", name, value, param);
                if (result != 0)
                {
                    return true;
                }
            }
            catch (System.Exception ex)
            {
                Console.WriteLine("Message = {1}", ex.Message);
            }

            return false;
        }