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

Revision 3640, 14.0 KB checked in by dezhidki, 9 years ago (diff)

Talletus.

Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using Jypeli;
6using MathHelper;
7using Entity;
8
9namespace Rooms
10{
11    public abstract class Room
12    {
13
14        public Vector Position;
15        public double width, height, thickness;
16        protected List<IPhysicsObject> roomDecorations = new List<IPhysicsObject>();
17        protected List<IPhysicsObject> roomObjects = new List<IPhysicsObject>();
18        public bool isBuilt = false;
19        protected IPhysicsObject[,] insideObjects;
20        public ObjectDoor[] doors = new ObjectDoor[4];
21        protected double blockWidth, blockHeight;
22        protected double insideWidth, insideHeight;
23        protected Vector insidePos;
24        protected int bWidth, bHeight;
25        public TheDungeonGame Game { get; set; }
26        public Vector PosOnGrid { get; set; }
27        public PhysicsObject wall;
28        public int EntityAmount { get; set; }
29        public String roomName;
30
31        public Room(TheDungeonGame game, Vector pos, Vector size, double thickness)
32        {
33            Game = game;
34            Position = VecMath.sub(pos, new Vector(Game.Level.Width / 2, -(Game.Level.Height / 2)));
35            width = size.X;
36            height = size.Y;
37            this.thickness = thickness;
38
39            insidePos = VecMath.add(Position, new Vector(thickness, -thickness));
40            insideWidth = width - thickness;
41            insideHeight = height - thickness;
42            blockWidth = insideWidth / 10;
43            blockHeight = blockWidth;
44            bWidth = (int)(insideWidth / blockWidth);
45            bHeight = (int)(insideHeight / blockHeight);
46
47            insideObjects = new PhysicsObject[bWidth, bHeight];
48            roomName = "Basic Room";
49        }
50
51        public abstract void initRoom();
52
53        public void spawnRandomEntities(int entityAmount)
54        {
55            int entitiesSpawned = 0;
56            while (entitiesSpawned < entityAmount)
57            {
58                EntityBase entity = RoomCreator.getEntity(RandomGen.NextInt(4));
59                if (!addEntityAt(entity, RandomGen.NextInt(bWidth - 2) + 1, RandomGen.NextInt(bHeight - 2) + 1))
60                    continue;
61                entitiesSpawned++;
62            }
63        }
64
65        public void spawnRandomItems(int itemAmount)
66        {
67            int itemsSpawned = 0;
68            while (itemsSpawned < itemAmount)
69            {
70                ItemEntity item = RoomCreator.getItem(RandomGen.NextInt(1)).createWorldObject();
71                if (!addBlock(item, RandomGen.NextInt(bWidth - 2) + 1, RandomGen.NextInt(bHeight - 2) + 1))
72                    continue;
73                itemsSpawned++;
74            }
75        }
76
77        protected void createLevelDecorations()
78        {
79            int level = Game.LevelGen.level;
80            createBorders(Game.getTopBottomWall(level), Game.getLeftRightWall(level));
81            addDoors();
82            roomDecorations.Add(createBackground(Game.getLevelBackground(level)));
83        }
84
85        public void buildLevel()
86        {
87            if (roomDecorations.Count == 0 && roomObjects.Count == 0) throw new Exception("Cannot build empty room!");
88
89            foreach (IPhysicsObject obj in roomDecorations)
90            {
91                Game.Add(obj);
92            }
93
94            foreach (IPhysicsObject obj in roomObjects)
95            {
96                Game.Add(obj, 1);
97            }
98
99            foreach (IPhysicsObject obj in insideObjects)
100            {
101                if (obj != null)
102                {
103                    if (obj.Tag.Equals("Enemy"))
104                        Game.Add(obj, 2);
105                    else Game.Add(obj, 1);
106                }
107
108            }
109
110
111            isBuilt = true;
112        }
113
114        public void destroyLevel()
115        {
116            if (roomDecorations.Count == 0) throw new Exception("Cannot destory empty room!");
117            if (!isBuilt) return;
118
119            foreach (IPhysicsObject obj in roomDecorations)
120            {
121                obj.Destroy();
122            }
123            foreach (IPhysicsObject obj in roomObjects)
124            {
125                obj.Destroy();
126            }
127            foreach (IPhysicsObject obj in insideObjects)
128            {
129                if (obj != null)
130                    obj.Destroy();
131            }
132        }
133
134        public void hideLevel()
135        {
136            if (roomDecorations.Count == 0) throw new Exception("Cannot hide empty room!");
137            if (!isBuilt) return;
138
139            foreach (IPhysicsObject obj in roomDecorations)
140            {
141                obj.IsVisible = false;
142            }
143            foreach (IPhysicsObject obj in roomObjects)
144            {
145                obj.IsVisible = false;
146            }
147            foreach (IPhysicsObject obj in insideObjects)
148            {
149                if (obj != null)
150                    obj.IsVisible = false;
151            }
152        }
153
154        public void restoreLevel()
155        {
156            if (roomDecorations.Count == 0) throw new Exception("Cannot hide empty room!");
157            if (!isBuilt) return;
158
159            foreach (IPhysicsObject obj in roomDecorations)
160            {
161                obj.IsVisible = true;
162            }
163            foreach (IPhysicsObject obj in roomObjects)
164            {
165                obj.IsVisible = true;
166            }
167            foreach (IPhysicsObject obj in insideObjects)
168            {
169                if (obj != null)
170                    obj.IsVisible = true;
171            }
172        }
173
174        public void restoreBrains()
175        {
176            foreach (IPhysicsObject obj in insideObjects)
177            {
178                if (obj != null)
179                {
180                    if (obj.Brain != null)
181                        obj.Brain.Active = true;
182                }
183            }
184        }
185
186        public void killBrains()
187        {
188            foreach (IPhysicsObject obj in insideObjects)
189            {
190                if (obj != null)
191                {
192                    if (obj.Tag.Equals("Enemy"))
193                        obj.Brain.Active = false;
194                    obj.Stop();
195                }
196            }
197        }
198
199        public bool addBlock(IPhysicsObject obj, int bx, int by)
200        {
201            if (bx >= bWidth || bx < 0 || by >= bHeight || by < 0 || insideObjects[bx, by] != null) return false;
202            obj.Left = insidePos.X + (bx * blockWidth);
203            obj.Top = insidePos.Y - (by * blockHeight);
204            insideObjects[bx, by] = obj;
205            return true;
206        }
207
208        public bool addBlock(IPhysicsObject obj, int bx, int by, Vector offset)
209        {
210            obj.Position += offset;
211            return addBlock(obj, bx, by);
212           
213        }
214
215        public void addBlockAt(IPhysicsObject obj, double x, double y)
216        {
217            obj.Left = Position.X + x;
218            obj.Top = Position.Y + y;
219            roomObjects.Add(obj);
220        }
221
222        public bool addEntityAt(EntityBase ent, int bx, int by)
223        {
224            if (bx >= bWidth || bx < 0 || by >= bHeight || by < 0 || insideObjects[bx, by] != null) return false;
225            ++EntityAmount;
226            ent.Left = insidePos.X + (bx * blockWidth);
227            ent.Top = insidePos.Y - (by * blockHeight);
228            insideObjects[bx, by] = ent;
229            return true;
230        }
231
232        public IPhysicsObject getEntityAt(int bx, int by)
233        {
234            if (bx >= bWidth || bx < 0 || by >= bHeight || by < 0) return null;
235            return insideObjects[bx, by];
236        }
237
238        public void deleteBlock(int bx, int by)
239        {
240            insideObjects[bx, by].Destroy();
241            insideObjects[bx, by] = null;
242        }
243
244
245        // En vitsinyt käyttää enempää aikaa tämän parantamiseksi. Helppo ja toimiva
246        public void addDoors()
247        {
248            Image doorTexture = Game.objectTextures[1];
249            for (int i = 0; i < 4; i++)
250            {
251                Room room = Game.LevelGen.getRoomAt(PosOnGrid + RoomDirection.getOffsetFromDir(i));
252
253                if (room == null) continue;
254
255                ObjectDoor door = null;
256
257                if (i == RoomDirection.North)
258                {
259                    door = new ObjectDoor(thickness, thickness);
260                    door.Position = Position + new Vector((width + thickness) / 2, -thickness / 2);
261                    door.Tag = RoomDirection.North;
262                }
263                else if (i == RoomDirection.East)
264                {
265                    door = new ObjectDoor(thickness, thickness);
266                    door.Position = Position + new Vector(width + thickness / 2, -(height + thickness) / 2);
267                    door.Tag = RoomDirection.East;
268                }
269                else if (i == RoomDirection.South)
270                {
271                    door = new ObjectDoor(thickness, thickness);
272                    door.Position = Position + new Vector((thickness + width) / 2, -height - thickness / 2);
273                    door.Tag = RoomDirection.South;
274                }
275                else if (i == RoomDirection.West)
276                {
277                    door = new ObjectDoor(thickness, thickness);
278                    door.Position = Position + new Vector(thickness / 2, -height / 2 - thickness / 2);
279                    door.Tag = RoomDirection.West;
280                }
281                if (door != null)
282                {
283                    roomObjects.Add(door);
284                    doors[i] = door;
285                    setDoorTexture(doorTexture, i);
286                }
287
288            }
289        }
290
291        public void setDoorTexture(Image tex, int dir)
292        {
293            ObjectDoor door = getDoor(dir);
294
295            if (door == null) return;
296
297            Room room = Game.LevelGen.getRoomAt(PosOnGrid + RoomDirection.getOffsetFromDir(dir));
298            if (room.roomName == "Boss Room")
299                door.Image = Game.objectTextures[2];
300            else door.Image = tex;
301            door.Angle = RoomDirection.getAngleFromDir(dir);
302        }
303
304        public ObjectDoor getDoor(int dir)
305        {
306            ObjectDoor result = null;
307            for (int i = 0; i < doors.Length; i++)
308            {
309                ObjectDoor door = doors[i];
310                if (door != null && (int)door.Tag == dir)
311                {
312                    result = door;
313                    return result;
314                }
315            }
316            return result;
317        }
318
319        public void createBorders(Image topBottom, Image leftRight)
320        {
321            PhysicsObject wallTop = createWall(Position, width + thickness, thickness);
322            wallTop.Color = Color.Blue;
323            wallTop.Image = topBottom;
324            PhysicsObject wallLeft = createWall(VecMath.sub(Position, new Vector(0, thickness)), thickness, height - thickness);
325            wallLeft.Color = Color.Red;
326            wallLeft.Image = leftRight;
327            PhysicsObject wallDown = createWall(VecMath.sub(Position, new Vector(0, height)), width + thickness, thickness);
328            wallDown.Color = Color.Black;
329            if (topBottom != null) wallDown.Image = Image.Flip(topBottom);
330            PhysicsObject wallRight = createWall(VecMath.add(Position, new Vector(width, -thickness)), thickness, height - thickness);
331            wallRight.Color = Color.Orange;
332            if (leftRight != null) wallRight.Image = Image.Mirror(leftRight);
333            roomDecorations.Add(wallTop);
334            roomDecorations.Add(wallLeft);
335            roomDecorations.Add(wallDown);
336            roomDecorations.Add(wallRight);
337        }
338
339        public PhysicsObject createWall(Vector pos, double width, double height)
340        {
341            wall = PhysicsObject.CreateStaticObject(width, height);
342            wall.Tag = "Wall";
343            wall.Left = pos.X;
344            wall.Top = pos.Y;
345
346            return wall;
347        }
348
349        public PhysicsObject createBackground(Image background)
350        {
351            PhysicsObject bg = PhysicsObject.CreateStaticObject(insideWidth, insideHeight);
352            bg.Left = Position.X + thickness;
353            bg.Top = Position.Y - thickness;
354            bg.IgnoresCollisionResponse = true;
355            bg.Image = background;
356            bg.Color = Color.Green;
357            bg.IgnoresExplosions = true;
358            return bg;
359        }
360    }
361
362    public class RoomDirection
363    {
364        public const int North = 0;
365        public const int East = 1;
366        public const int South = 2;
367        public const int West = 3;
368
369        public static Angle NorthAngle = Angle.Zero;
370        public static Angle EastAngle = Angle.FromDegrees(270);
371        public static Angle SouthAngle = Angle.FromDegrees(180);
372        public static Angle WestAngle = Angle.FromDegrees(90);
373
374        public static Vector getOffsetFromDir(int dir)
375        {
376            if (dir == North)
377                return new Vector(0, -1);
378            if (dir == East)
379                return new Vector(1, 0);
380            if (dir == South)
381                return new Vector(0, 1);
382            if (dir == West)
383                return new Vector(-1, 0);
384
385            return Vector.Zero;
386        }
387
388        public static Angle getAngleFromDir(int dir)
389        {
390            if (dir == North)
391                return NorthAngle;
392            else if (dir == East)
393                return EastAngle;
394            else if (dir == South)
395                return SouthAngle;
396            else if (dir == West)
397                return WestAngle;
398
399            return Angle.Zero;
400        }
401
402        public static Vector getOffsetFromWorldDir(int dir)
403        {
404            if (dir == North)
405                return new Vector(0, 1);
406            if (dir == East)
407                return new Vector(1, 0);
408            if (dir == South)
409                return new Vector(0, -1);
410            if (dir == West)
411                return new Vector(-1, 0);
412
413            return Vector.Zero;
414        }
415    }
416}
Note: See TracBrowser for help on using the repository browser.