def initWindow(self, size = None):
if (size == None):
self.size = Config.screen_size
display.init()
font.init()
self.screen = display.set_mode(
self.size,
flags.FULLSCREEN if Config.fullscreen else flags.RESIZABLE
)
display.set_caption(Config.screen_caption)
#Initializing bachground surface
self.background = Surface(self.size).convert()
self.background.fill(Config.background_color)
#Initializing raycast engine
self.raycast = Raycast(self.size)
self.loadTextures()
self.default_font = font.SysFont('Arial', 15)
class Display:
screen = None
size = None
background = None
minimap_surface = None
minimap_scale = 10
texture_size = 64
main_wall_texture = None
wall_textures = None
textures_count = None
texture_types_count = None
main_sprite_texture = None
sprites_count = None
sprites = None
raycast = None
default_font = None
def __init__(self):
self.screen = None
self.size = None
self.background = None
self.minimap_surface = None
def loadTextures(self):
self.main_wall_texture = image.load(os.path.join('data', 'walls.png')).convert()
main_texture_size = self.main_wall_texture.get_size()
self.textures_count = round(main_texture_size[1]/self.texture_size)
self.texture_types_count = round(main_texture_size[0]/self.texture_size)
self.wall_textures = []
for i in range(self.textures_count):
texture_types = []
for t in range(self.texture_types_count-1):
texture_type = []
x = t * self.texture_size
y = i * self.texture_size
for strip in range(self.texture_size):
texture_type.append(
self.main_wall_texture.subsurface((x, y, 1, self.texture_size)).convert()
)
x = x + 1
texture_types.append(texture_type)
self.wall_textures.append(texture_types)
pass
self.main_sprite_texture = image.load(os.path.join('data', 'sprites.png')).convert()
self.sprites_count = self.main_sprite_texture.get_size()[0]//self.texture_size
self.sprites = []
for i in range(self.sprites_count):
sprite = []
x = i * self.texture_size
y = 0
for strip in range(self.texture_size):
sprite.append(
self.main_sprite_texture.subsurface((x, y, 1, self.texture_size)).convert()
)
x = x + 1
self.sprites.append(sprite)
pass
def initWindow(self, size = None):
if (size == None):
self.size = Config.screen_size
display.init()
font.init()
self.screen = display.set_mode(
self.size,
flags.FULLSCREEN if Config.fullscreen else flags.RESIZABLE
)
display.set_caption(Config.screen_caption)
#Initializing bachground surface
self.background = Surface(self.size).convert()
self.background.fill(Config.background_color)
#Initializing raycast engine
self.raycast = Raycast(self.size)
self.loadTextures()
self.default_font = font.SysFont('Arial', 15)
def close(self):
display.quit()
#TODO:use
def drawRaycastedView(self,rays):
default_texture = 1
default_type = 0
strip_no = 0
strip_width = self.raycast.strip_width
x = 0
last_slice_meta = (None, None, None, None)
last_slice = None
for ray in rays:
this_slice_meta = (default_texture, default_type, ray['texture_x'], ray['distance'])
if (this_slice_meta != last_slice_meta):
last_slice_meta = this_slice_meta
strip_height = round(self.raycast.distance_to_plane / ray['distance'])
y = round((self.size[1]-strip_height)/2)
required_slice = round((self.texture_size/strip_width)*ray['texture_x']) - 1
try:
last_slice = transform.scale(self.wall_textures[default_texture][default_type][required_slice], (strip_width, strip_height))
except Exception as e:
pass
try:
self.screen.blit(last_slice,(x,y))
except Exception as e:
pass
x += strip_width
strip_no = strip_no + 1
def draw(self,game):
self.clearScreen()
rays = self.raycast.castRays(game.player, game.world)
self.drawRaycastedView(rays)
self.drawUpdatedMinimap(game.world, game.player, rays, (0,0))
self.drawFPS(game.fps)
self.finishDrawing()
def clearScreen(self):
self.screen.blit(self.background, (0, 0))
def initMinimap(self, world):
size = ((world.width+2) * self.minimap_scale,(world.height+2) * self.minimap_scale)
self.minimap_surface = Surface(size).convert()
self.prenderMinimap(world)
def prenderMinimap(self, world):
self.minimap_surface.fill((0, 0, 0))
scale = self.minimap_scale
y = scale # margin
for row in world.world:
x = scale
for item in row:
draw.rect(
self.minimap_surface,
item.map_color,
(x,y,scale,scale)
)
x = x + scale
y = y + scale
def drawUpdatedMinimap(self, world, player, rays, coords):
scale = self.minimap_scale
player_coords = ((player.coords+1) * scale).rounded().toInt().toTuple()
player_direction = player.direction * scale
player_direction = (player_direction + player_coords).rounded().toInt().toTuple()
minimap = self.minimap_surface.copy()
draw.circle(
minimap,
player.map_color,
player_coords,
round(player.size*scale)
)
for ray in rays:
draw.line(
minimap,
(0,255,0),
player_coords,
((ray['coords'][0]+1)*scale, (ray['coords'][1]+1)*scale)
)
draw.line(
minimap,
player.map_color,
player_coords,
player_direction
)
self.screen.blit(minimap, coords)
def finishDrawing(self):
display.flip()
def drawFPS(self, fps):
fps = round(fps)
if (fps >= 40):
fps_color = (0,102,0)
elif(fps >= 20):
fps_color = (255, 153, 0)
else:
fps_color = (204, 0, 0)
self.screen.blit(
self.default_font.render('FPS: '+str(fps), False, fps_color),
(self.size[0]-70, 5)
)