initial init, moved rendering and generating tiles to /map_new

main.py

@@ -7,6 +7,8 @@ from map import *
 # from house import House
 from sprites import *
 from settings import *
+from map_new import map_new
+from map_new import map_utils
 import math
 
 class Game():
@@ -31,9 +33,14 @@ class Game():
         self.wall_img = pg.image.load(path.join(img_folder, WALL_IMG)).convert_alpha()
         self.wall_img = pg.transform.scale(self.wall_img, (TILESIZE, TILESIZE))
 
+        # self.new_map = map_new.getMap()
+        
+
     def new(self):
         # initialize all variables and do all the setup for a new game
 
+        self.roadTiles, self.wallTiles = map_new.getTiles()
+
         self.all_sprites = pg.sprite.Group()
         self.walls = pg.sprite.Group()
 
@@ -43,11 +50,9 @@ class Game():
             if tile_object.name == 'wall':
                 Obstacle(self, tile_object.x, tile_object.y, tile_object.width, tile_object.height)
 
-        # self.screen.blit(self.map_img, (0,0))
         self.camera = Camera(self.map.width, self.map.height)
         self.draw_debug = False
         
-        #self.screen.blit(self.map_img, self.camera.apply_rect(self.map_rect))
 
     def run(self):
         # game loop - set self.playing = False to end the game 
@@ -74,23 +79,19 @@ class Game():
         for y in range(0, HEIGHT, TILESIZE):
             pg.draw.line(self.screen, LIGHTGREY, (0, y), (WIDTH, y))
 
-
-    # def draw(self, drawable_object, pos):
-    #     # pos => (x, y)
-    #     # drawable object must have .image field inside class
-    #     self.screen.blit(drawable_object.image, pos )
-
     def draw(self):
         pg.display.set_caption("{:.2f}".format(self.clock.get_fps()))
-        self.screen.blit(self.map_img, self.camera.apply_rect(self.map_rect))
+        # self.screen.blit(self.new_surface, self.camera.apply_rect(self.map_rect))
+        map_new.renderTiles(self.roadTiles, self.screen, self.camera)
+        map_new.renderTiles(self.wallTiles, self.screen, self.camera, self.draw_debug)
         
         for sprite in self.all_sprites:
             self.screen.blit(sprite.image, self.camera.apply(sprite))
             if self.draw_debug:
                 pg.draw.rect(self.screen, CYAN, self.camera.apply_rect(sprite.hit_rect), 1)
-        if self.draw_debug:
+        # if self.draw_debug:
-            for wall in self.walls:
+        #     for wall in self.walls:
-                pg.draw.rect(self.screen, CYAN, self.camera.apply_rect(wall.rect), 1)
+        #         pg.draw.rect(self.screen, CYAN, self.camera.apply_rect(wall.rect), 1)
         
         pg.display.flip()
 
@@ -113,10 +114,6 @@ class Game():
 
     def show_go_screen(self):
         pass
-
-    # def reloadMap(self):
-    #      #self.screen.fill(pygame.Color(self.BACKGROUND_COLOR))
-    #      self.screen.blit(self.map_img, (0,0))
         
 # def main():
 #     game = WalleGame()

map_new/map_new.py

@@ -0,0 +1,22 @@
+from map_new import map_utils
+from map_new import map_pattern
+import pygame as pg
+from settings import *
+
+# def getMap():
+#     array = map_utils.getBlankMapArray()
+#     pattern = map_pattern.getPattern()
+#     surface = map_utils.makeSurfaceMap(array, pattern)
+#     return surface
+
+def getTiles():
+    array = map_utils.getBlankMapArray()
+    pattern = map_pattern.getPattern()
+    tiles = map_utils.getSprites(array, pattern)
+    return tiles
+
+def renderTiles(tiles, screen, camera, debug=False):
+    for tile in tiles:
+        screen.blit(tile.image, camera.apply_rect(tile.rect))
+        if debug:
+            pg.draw.rect(screen, RED, camera.apply_rect(tile.rect), 1)

map_new/map_pattern.py

@@ -0,0 +1,17 @@
+import os
+import pygame as pg
+
+HERE_DIR = os.path.abspath(os.path.dirname(__file__))
+TEXTURES_DIR = HERE_DIR.rpartition(os.sep)[0]+"\\resources\\textures"
+
+ROAD_DIR = TEXTURES_DIR+"\\road\\"
+BUILDING_DIR = TEXTURES_DIR+"\\buliding\\"
+
+def loadImg(path):
+    return pg.image.load(path)
+
+def getPattern():
+    return {
+        0: loadImg(ROAD_DIR+"GTA2_TILE_257.bmp"),
+        1: loadImg(BUILDING_DIR+"GTA2_TILE_187.bmp"),
+    }

map_new/map_utils.py

@@ -0,0 +1,51 @@
+import pygame as pg
+from map_new.tile import Tile
+
+MAP_WIDTH = 5
+MAP_HEIGHT = 5
+
+TILE_SIZE_PX = 64
+
+# tworzenie pustego arraya o podanych wymiarach
+def getBlankMapArray():
+    map = [[0 for x in range(0,MAP_WIDTH)] for y in range (0,MAP_HEIGHT)]
+
+    map[0][1] = 1
+    map[0][2] = 1
+
+    return map
+
+# tworzenie surface poprzed czytanie arraya i wedle niego wypelnianie konkretnymi tile'ami
+# def makeSurfaceMap(map, pattern):
+#     surface = pg.Surface((MAP_WIDTH * TILE_SIZE_PX, MAP_HEIGHT * TILE_SIZE_PX))
+
+#     for i in range(len(map)):
+#         offsetY = i * TILE_SIZE_PX
+#         for j in range(len(map[i])):
+#             offsetX = j * TILE_SIZE_PX
+#             surface.blit(pattern[map[i][j]], (offsetX, offsetY))
+#     return surface
+
+# tworzenie grup sprite'ow
+def getSprites(map, pattern):
+    roadTiles = pg.sprite.Group()
+    wallTiles = pg.sprite.Group()
+
+    for i in range(len(map)):
+        offsetY = i * TILE_SIZE_PX
+        for j in range(len(map[i])):
+            offsetX = j * TILE_SIZE_PX
+            tileId = map[i][j]
+            tile = Tile(pattern[tileId], offsetX, offsetY, TILE_SIZE_PX, TILE_SIZE_PX)
+            if tileId == 0:
+                roadTiles.add(tile)
+            else:
+                wallTiles.add(tile)
+    return roadTiles, wallTiles
+
+
+
+
+
+
+

map_new/tile.py

@@ -0,0 +1,16 @@
+from re import X
+import pygame as pg
+
+class Tile(pg.sprite.Sprite):
+    def __init__(self, img, x, y, width, height):
+        super().__init__()
+
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+
+        self.image = pg.Surface([width, height])
+        self.image.blit(img, (0,0))
+
+        self.rect = pg.Rect(x, y, width, height)

settings.py

@@ -5,6 +5,7 @@ vec = pg.math.Vector2
 #colors
 LIGHTGREY = (100, 100, 100)
 CYAN = (0, 255, 255)
+RED = (255, 0, 0)
 
 
 #game settings

sprites.py

@@ -64,9 +64,9 @@ class Player(pg.sprite.Sprite):
         self.rect.center = self.pos
         self.pos += self.vel * self.game.dt
         self.hit_rect.centerx = self.pos.x
-        collide_with_walls(self, self.game.walls, 'x')
+        collide_with_walls(self, self.game.wallTiles, 'x')
         self.hit_rect.centery = self.pos.y
-        collide_with_walls(self, self.game.walls, 'y')
+        collide_with_walls(self, self.game.wallTiles, 'y')
         self.rect.center = self.hit_rect.center
 
 class Dump(pg.sprite.Sprite):