def __init__(self, screen, size):
self.size = size
self.verticies = []
self.edges = []
self.surfaces = []
# generate map
# zuerst die Distribution ermitteln
dist = MapGen.Dist_Function(size, 0.8)
dist.calcdist()
dist.clean(4, 1)
# seed generieren
seedmap = MapGen.Seedmap(size)
seedmap.drawfromdist(dist)
# nun die heightmap zeichnen
self.heightmap = MapGen.Heightmap(size, 2)
self.heightmap.gen2_prep(seedmap)
self.heightmap.slopedown()
self.heightmap.cleanup()
# setting up verticies
for y in range(0, self.size):
for x in range(0, self.size):
if self.heightmap.map[x][y] < 0:
z = 0
else:
z = self.heightmap.map[x][y] * 0.5
self.verticies.append((x, y, z))
#setting up edges
for j in range(0, self.size):
for i in range(0, self.size):
if i - 1 >= 0:
self.edges.append(
(j * self.size + i, j * self.size + i - 1))
if j - 1 >= 0:
self.edges.append(
(j * self.size + i, (j - 1) * self.size + i))
if i - 1 >= 0 and j - 1 >= 0:
self.edges.append(
((j - 1) * self.size + i - 1, j * self.size + i))
#setting up surfaces
for j in range(0, self.size):
for i in range(0, self.size):
if i - 1 >= 0 and j - 1 >= 0:
self.surfaces.append(
((j - 1) * self.size + i - 1, j * self.size + i - 1,
j * self.size + i, (j - 1) * self.size + i))
self.deepwater = Texture('Images/WasserTief.png')
self.shallwater = Texture('Images/WasserSeicht.png')
self.sand = Texture('Images/Sand.png')
self.grass = Texture('Images/Grasmitte.png')
self.mountain = Texture("Images/DunklerSand.png")
self.screen = screen
def __init__(self, flags=None):
global mp
mp = gen.init()
if flags == 'debug':
for y in range(gui.MAPHEIGHT):
for x in range(gui.MAPWIDTH):
mp[x][y].explored = True
debug_mode = True
gui.message('You hear zombies all around you.', pygame.Color(0,0,255))
gen.render_all()
mainloop()
def InitializeNextCustomLevel(self, previousLevelSeed):
next = MapGen.PopNextSeed()
if next == None:
self.won = True
else:
self.width = next.width
self.height = next.height
self.mode = next.mode
self.progress = next.progress
self.timedMode = next.timedMode
self.minutes = next.minutes
self.map = next.map
self.citizens = 0
self.police = 0
def InitializeSpecialLevel(self, special, previousLevelSeed,
previousLevel):
self.progress = True
self.timedMode = False
self.citizens = 0
self.police = 0
self.specialName = special
if special == 'testlevel':
self.progress = False
self.width = 32
self.height = 24
elif special == 'level1':
self.width = 20
self.height = 15
elif special == 'level2':
self.width = 29
self.height = 33
elif special == 'level3':
self.width = 64
self.height = 64
elif special == 'level4':
self.width = 150
self.height = 100
elif special == 'level5':
self.width = 250
self.height = 180
elif special == 'level6':
self.mode = 'crowd'
self.width = 20
self.height = 15
elif special == 'level7':
self.mode = 'crowd'
self.width = 40
self.height = 30
elif special == 'level8':
self.mode = 'crowd'
self.width = 80
self.height = 60
elif special == 'level9':
self.mode = 'crowd'
self.width = 160
self.height = 120
self.map = MapGen.BuildMap(special, self.width, self.height,
previousLevelSeed, previousLevel, None)
def display_map_canvas(keyword):
map_frame = tk.Frame(master=root, bg='grey')
canvas_size = 1200
resolution = 10
gps_points = gpsPoint.read_drone_csv(r'Data Files/Feb-26th-2021-05-57PM-Flight-Airdata.csv')
stella_points = StellaPoint.make_stella_list(r'Data Files/data.txt')
stella_points = StellaPoint.get_batch(stella_points, "1.X")
map_points,width,height = MapPoint.set_xy(gps_points, stella_points, canvas_size)
height = round(height/10) * 10
width = round(width/10) * 10
map_canvas = tk.Canvas(map_frame, width = width, height = height)
map_canvas.pack()
poly_fill = MapGen.get_poly(height, width)
filled = MapGen.draw_data(map_points, poly_fill, keyword, resolution, width)
MapGen.fill_all(filled, poly_fill, width, height, resolution)
for t in poly_fill:
t.draw(map_canvas)
MapGen.draw_flight_path(map_points, map_canvas)
map_canvas.pack()
map_frame.place(x=10, y=10)
def GenerateCustomMap(self, width, height, isUrban, isCrowd):
generator = MapGen.Generator(width, height, isUrban, isCrowd)
while not generator.IsDone():
generator.DoNextTask()
commands = generator.commands
return MapGen.BuildMapFromCommands(commands, width, height, None, None)
for i in range(5):
walkList.append(spriteList[1][i])
#Put all idle momevemt frames into a list
idleList = []
for i in range(2):
idleList.append(spriteList[0][i])
#Create new projectiles
testBullet = Projectile(bullet, 500, 2000, None, None)
# Create new test weapons
HEMG_weapon = Weapon(gun, testBullet, 95, 7, None, 75, None, 60, 2000)
nav_weapon = MeleeWeapon(bat, 0, 0, None, None, None, None, None, None)
#Create Map
map1 = MapGen(16, 3.2)
MapGen.mrGenny(map1)
map1.mrClassy()
pprint(map1.level)
#Set up camera
cspeed = 400
#Make camera start in middle of start room
for i in range(len(map1.level)):
for n in range(len(map1.level[i])):
if map1.level[i][n] == 5:
playerX, playerY = n * roomScale + roomScale / 2, i * roomScale + roomScale / 2
#create character instance
susano = Player('martialArtist', playerX, playerY, 1000)
def GetPlayScene(self):
global _registeredSeeds
_registeredSeeds = None
levels = []
width = 28
height = 24
if self.mapSize == 2:
width = 42
height = 36
elif self.mapSize == 3:
width = 64
height = 48
swidth = width
sheight = height
for i in range(9):
if i == 5:
width = swidth
height = sheight
levels.append((width, height))
width = int(width * 1.6)
height = int(height * 1.6)
if self.startZoom < 5:
levels = levels[:5]
else:
levels = levels[5:]
isCrowd = self.args['isCrowd']
lastWidth = levels[-1][0]
lastHeight = levels[-1][1]
lastLevel = MapGen.Generator(lastWidth, lastHeight, True, isCrowd)
while not lastLevel.IsDone():
lastLevel.DoNextTask()
commands = lastLevel.commands
lastLevel = MapGen.BuildMapFromCommands(commands, width, height, None,
None, None)
# Generate tiles for big map
# generate empty maps for smaller maps
maps = []
for level in levels:
#print level
mp = MapGen.BuildMapFromCommands([], level[0], level[1], None,
None, None)
#print 'map instance:', len(mp.grid), len(mp.grid[0])
maps.append(mp)
maps[-1] = lastLevel
# determine top left coordinate of smaller map where it is in big map
offsets = []
for level in levels:
x = (lastWidth - level[0]) // 2
y = (lastHeight - level[1]) // 2
offsets.append((x, y))
# blit big map onto smaller maps
for i in range(len(offsets) - 1):
x = offsets[i][0] - offsets[i + 1][0]
y = offsets[i][1] - offsets[i + 1][1]
maps[i + 1].spriteCarryOver = (x, y)
for i in range(len(levels) - 1):
offset = offsets[i]
xOffset = offset[0]
yOffset = offset[1]
level = maps[i]
size = levels[i]
width = size[0]
height = size[1]
#print i, width,height
y = 0
while y < height:
x = 0
while x < width:
level.grid[x][y] = lastLevel.grid[x + xOffset][y + yOffset]
x += 1
y += 1
addTheseSprites = []
# blast out a bunch of sprites. PlayScene will automatically move sprites if they aren't standing in a valid place (like on a roof)
for i in range(100):
rx = int(random.random() * lastWidth - 4) + 2
ry = int(random.random() * lastHeight - 4) + 2
addTheseSprites.append((rx, ry))
# sprites in previous level zone move to previous level
for i in range(len(levels)):
size = levels[i]
offset = offsets[i]
level = maps[i]
newSpriteList = []
for sprite in addTheseSprites:
if sprite[0] < offset[0] or sprite[
0] >= offset[0] + size[0] or sprite[1] < offset[
1] or sprite[1] >= offset[1] + size[1]:
newSpriteList.append(sprite)
else:
x = sprite[0] - offset[0]
y = sprite[1] - offset[1]
level.citizens.append((x, y, random.random() < .5,
random.choice([1, 2, 3, 4]), x, y))
addTheseSprites = newSpriteList
# add a sprite to each border region of each level
for level in maps:
level.citizens.append((1, 1, True, 1, 1, 1))
levels = levels[self.startZoom:]
maps = maps[self.startZoom:]
offsets = offsets[self.startZoom:]
seeds = []
for i in range(len(levels)):
#print 'level',i,levels[i][0], levels[i][1], len(maps[i].grid), len(maps[i].grid[0])
seeds.append(
GamePlay.LevelSeed(
None, {
'map': maps[i],
'width': levels[i][0],
'height': levels[i][1],
'isCrowd': isCrowd,
'mode': ('individual', 'crowd')[isCrowd],
'progress': True,
'minutes': self.minutes
}))
_registeredSeeds = seeds
first = _registeredSeeds[0]
_registeredSeeds = _registeredSeeds[1:]
if not self.doProgress:
_registeredSeeds = []
return GamePlay.PlayScene(first)
#Scale Variables
mapScale = 256
#Init calls
p.init()
MapGen.initGraphics(mapScale)
#Set up screen
tscreenX, tscreenY = 800, 600
screenX, screenY = 200, 150
screen = p.display.set_mode((tscreenX, tscreenY))
centerX, centerY = int(tscreenX / 2), int(tscreenY / 2)
#Create Objects
#Generate the map
map1 = MapGen(16, 3.2)
map1.mrGenny()
map1.mrClassy()
map1.mrRoomy()
pprint(map1.layoutMap)
#Create clock
clock = p.time.Clock()
#Move function for testing
def move(cameraX, cameraY, speed, currentTimeDelta):
POFFX, POFFY = 0, 0 #Camera direction variables
#Determine direction of movement
if p.key.get_pressed()[p.K_d]: #Right
p.init()
MapGen.initGraphics(mapScale) #Load map images
#Set up screen
screenX, screenY = Setup.screenX, Setup.screenY
screen = p.display.set_mode((screenX, screenY))
centerX, centerY = Setup.centerX, Setup.centerY
#Set up window
p.display.set_icon(p.image.load('assets/ui/logo.png'))
p.display.set_caption("Dungeon")
#Object Setups =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#Create Map
numOfElements = 16
map1 = MapGen(numOfElements,3.2) #Create level map
map1.mrGenny() #Generate the room layout
map1.mrClassy() #Determine the type of room depending on the amount of exits has
map1.mrRoomy() #Generate the room layout of each room
map1.mrCollidey() #Merge the collsion data of the room and room layout
map1.mrDoory(scale) #Create all the doors
#Make a 2d array with all the collision data of all the rooms
for i in range(len(map1.level)): #Iterate through each room of map
for n in range(len(map1.level[i])):
rawMapCollide = Collider.importCollisionMap(n,i,numOfElements,map1.roomCollide[i][n],scale) #Create actual rect collision objects
mapCollide = Collider.convertCollisionGrid(n,i,rawMapCollide,scale,numOfElements)
map1.mrCollisionData[i][n] = mapCollide
pprint(map1.level)
def BuildMapFromCommands(commands, mapwidth, mapheight, previousLevelSeed,
previousLevel, spriteCarryOver):
items = []
citizens = []
police = []
tileOverrides = []
carryover = None
isCrowdLevel = False
for line in commands:
parts = _trim(line).split(' ')
if parts[0] == 'ROAD':
item = MapGen.Road(int(parts[1]), int(parts[2]), int(parts[3]),
int(parts[4]))
items.append(item)
elif parts[0] == 'CROAD':
isCrowdLevel = True
item = MapGen.CRoad(int(parts[1]), int(parts[2]), int(parts[3]),
int(parts[4]))
items.append(item)
elif parts[0] == 'BUILDING':
item = MapGen.Building(int(parts[1]), int(parts[2]), int(parts[3]),
int(parts[4]), int(parts[5]), int(parts[6]))
items.append(item)
elif parts[0] == 'CITIZEN':
x = int(parts[1])
y = int(parts[2])
male = parts[3].upper() == 'M'
variety = int(parts[4])
if len(parts) > 5:
tx = int(parts[5])
ty = int(parts[6])
else:
tx = x
ty = y
citizens.append((x, y, male, variety, tx, ty))
elif parts[0] == 'POLICE':
x = int(parts[1])
y = int(parts[2])
variety = int(parts[3])
police.append((x, y, variety))
elif parts[0] == 'BUSH':
x = int(parts[1])
y = int(parts[2])
widthIhatePython = int(parts[3])
items.append(MapGen.Bush(x, y, widthIhatePython))
elif parts[0] == 'TREE':
x = int(parts[1])
y = int(parts[2])
type = parts[3].lower()
items.append(MapGen.Tree(x, y, type))
elif parts[0] == 'CARRYOVER':
colorize_center = len(parts) >= 4 and parts[3] == 'COLOR'
carryover = (int(parts[1]), int(parts[2]), previousLevelSeed,
colorize_center)
elif parts[0] == 'TILE':
tileOverrides.append((parts[1], int(parts[2]), int(parts[3])))
elif parts[0] == 'HOUSE':
x = int(parts[1])
y = int(parts[2])
items.append(MapGen.House(x, y, int(parts[3])))
elif parts[0] == 'RECT':
type = parts[1]
left = int(parts[2])
top = int(parts[3])
width = int(parts[4])
height = int(parts[5])
x = left
endX = left + width - 1
endY = top + height - 1
while x <= endX:
y = top
while y <= endY:
tileOverrides.append((parts[1], x, y))
y += 1
x += 1
return Map(mapwidth, mapheight, items, citizens, police, carryover,
tileOverrides, previousLevel, isCrowdLevel, spriteCarryOver)
def _StartGame(self):
gameBuilder = MapGen.CustomGameBuilder(self._args)
self.next = gameBuilder.GetPlayScene()
from MapGen import *
from pygame import *
scale = 64
#Generate the map
map1 = MapGen(16, 2)
MapGen.mrGenny(map1)
pprint(map1.level)
#Initate graphics
screen = display.set_mode((1600, 1200))
MapGen.initGraphics()
for i in range(len(map1.level)): #For each room
for n in range(len(map1.level[i])):
if map1.level[i][n] != 0 and map1.level[i][n] != 2: #Draw rooms
#Determine the type of room
room = map1.levelMap[i][n][1]
for p in MapGen.roomDict:
for q in MapGen.roomDict[p]:
if map1.levelMap[i][n][1] == MapGen.roomDict[p][q]:
roomType = roomTypeList[p][q]
screen.blit(roomType, (n * scale, i * scale))
elif map1.level[i][n] == 2: #Draw hallways
#Determine the type of room
def main():
# Pygame init()-----------------------------------
pygame.init()
pygame.mixer.init(44100, -16, 2, 2048)
pygame.mixer.set_num_channels(12)
clock = pygame.time.Clock()
screen = pygame.display.set_mode((1920, 1080), pygame.FULLSCREEN)
pygame.display.set_caption("Scary Game")
titleFont = pygame.font.SysFont("arial", 50)
smallFont = pygame.font.SysFont("arial", 15)
# Main Vars --------------------------------------
mainMenu = [True]
gameover = [False]
pause = [False]
player = Player()
hud = HUD(screen, titleFont, 0)
offSet = [0, 0, 0, 0]
music = pygame.mixer.music.load("sounds/music.wav")
pygame.mixer.music.set_volume(.4)
pygame.mixer.music.play(-1)
gunSound = pygame.mixer.Sound("sounds/gunsound1.wav"), \
pygame.mixer.Sound("sounds/gunsound2.wav"), \
pygame.mixer.Sound("sounds/shotgunsound.wav"), \
pygame.mixer.Sound("sounds/machinegunsound.wav")
hurt = pygame.mixer.Sound("sounds/collide.wav")
hit = pygame.mixer.Sound("sounds/hit1.wav"), pygame.mixer.Sound(
"sounds/hit2.wav")
hit[0].set_volume(.5)
hit[1].set_volume(.5)
gunSound[0].set_volume(settings.gunShotVolume)
gunSound[1].set_volume(settings.gunShotVolume)
gunSound[2].set_volume(settings.gunShotVolume)
gunSound[3].set_volume(settings.gunShotVolume)
# lists and gamespace ------------------------------
gameoverScreen = GameOver()
pauseScreen = Pause()
mainMenuScreen = MainMenu()
removeList = []
enemies = []
shots = []
textBoxes = [hud]
particles = []
walls = []
MapGen.generateWalls(walls)
pickups = [Pickup((100, 600), "smg"), Pickup((1800, 400), "shotgun")]
gameMap = []
zombiesKilled = 0
mapSize = MapGen.generateMap(gameMap)
gameSpace = (1920, 1080 - hud.getHeight())
timer = -20
totalTimer = 115
# FPS STUFF CAN BE REMOVEDs
avgFPS = []
count = 0
while True:
if mainMenu[0]:
pause[0] = False
gameover[0] = False
gf.mainMenu(mainMenuScreen, mainMenu)
mainMenuScreen.blit(screen)
pygame.display.flip()
screen.fill(colors["BLACK"])
elif pause[0]:
mainMenu[0] = False
gameover[0] = False
choice = gf.pauseMenu(pauseScreen, pause)
if choice == 2:
mainMenu[0] = [True]
gameover[0] = [False]
pause[0] = [False]
mapSize = MapGen.generateMap(gameMap)
offSet = [0, 0, 0, 0]
player.resetAll()
removeList.clear()
enemies.clear()
shots.clear()
particles.clear()
walls.clear()
MapGen.generateWalls(walls)
pickups = [
Pickup((100, 600), "smg"),
Pickup((1800, 400), "shotgun")
]
zombiesKilled = 0
timer = -20
totalTimer = 130
pauseScreen.blit(screen)
pygame.display.flip()
screen.fill(colors["BLACK"])
elif gameover[0]:
mainMenu[0] = False
pause[0] = False
choice = gf.gameOver(gameoverScreen)
if choice == 1:
mainMenu[0] = [False]
gameover[0] = [False]
pause[0] = [False]
mapSize = MapGen.generateMap(gameMap)
offSet = [0, 0, 0, 0]
player.resetAll()
removeList.clear()
enemies.clear()
shots.clear()
particles.clear()
walls.clear()
MapGen.generateWalls(walls)
pickups = [
Pickup((100, 600), "smg"),
Pickup((1800, 400), "shotgun")
]
zombiesKilled = 0
timer = -20
totalTimer = 130
gameoverScreen.blit(screen)
pygame.display.flip()
screen.fill(colors["BLACK"])
else:
timer += 1
tickSpeed = clock.tick(80)
count += 1
if count > 160:
count = 0
gf.getAvgFPS(clock.get_fps(), avgFPS)
# print(tickSpeed)
gf.updateEvents(player, pickups, pause)
gf.checkCollision(player, walls)
gf.getMapOffset(player, offSet, gameSpace, mapSize)
gf.setMapOffset(player, enemies, offSet, gameMap, pickups, walls,
particles)
for particle in particles:
particle.blit(screen)
# Update and Blit Map ---------------------------------------------------------------------
for block in gameMap:
if block.type == "wall":
gf.checkCollision(player, block)
block.blit(screen)
if MapGen.spawningEnemies(timer, totalTimer, enemies):
timer = 0
for i, enemy in enumerate(enemies, 0):
if pygame.Rect.colliderect(enemy.rect, player):
hurt.play()
player.hp -= 1
enemies.pop(i)
# Player Update and mouse clicks ------------------------------------------------------------
player.update(tickSpeed)
# player.melee(screen)
if player.rightAttack(tickSpeed,
player.inv[player.weaponEquipped].attSpeed):
if player.inv[player.weaponEquipped].ammo > 0:
player.inv[player.weaponEquipped].ammo -= 1
player.shot(shots, gunSound)
else:
player.createPistol()
player.leftAttack(tickSpeed)
# pickup blit ----------------------------------
for item in pickups:
item.blit(screen)
# Bullet update and blit --------------------------------------------------------------------
for i, bullet in enumerate(shots, 0):
if bullet.distance > 0:
bullet.distance -= int(tickSpeed / 10 + bullet.speed / 10)
bullet.update()
pygame.draw.line(screen, colors["YELLOW"], bullet.pos,
bullet.getSecondPoint(), 2)
else:
removeList.append(i)
gf.cleanList(removeList, shots)
# Enemy Update and Blit ---------------------------------------------------------------------
for i, enemy in enumerate(enemies, 0):
for j, bullet in enumerate(shots, 0):
if gf.getDistance(bullet.getMid(), enemy.rect.center) < 20:
point2 = bullet.getSecondPoint()
if pygame.Rect.collidepoint(
enemy.rect, bullet.pos[0],
bullet.pos[1]) or pygame.Rect.collidepoint(
enemy.rect, point2[0], point2[1]):
hit[random.randint(0, 1)].play()
enemy.hp -= bullet.damage
shots.pop(j)
break
if enemy.hp > 0:
enemy.update(player, tickSpeed)
enemy.blit(screen, player)
else:
zombiesKilled += 1
if random.randint(1, 50) <= 2:
item = Pickup(enemy.rect.center,
gf.getRandomDrop(random.randint(0, 5)))
pickups.append(item)
removeList.append(i)
gf.cleanList(removeList, enemies)
# Player Blit -----------------------------------------------------------------------------
player.resetMovement()
player.blit(screen)
# Text updates and Blit ---------------------------------------------------------------------
hud.update(titleFont, zombiesKilled)
for i, text in enumerate(textBoxes, 0):
if text.life != 999:
text.life -= int(tickSpeed / 10)
if text.life < 0:
removeList.append(i)
else:
text.blit(screen)
gf.cleanList(removeList, textBoxes)
gf.drawInv(screen, player)
gf.drawHP(screen, player)
# ------------------------------------delete-------------------------------------------------------------------------------
# for wall in walls:
# wall.blit(screen)
if player.hp <= 0:
gameover[0] = True
pygame.display.flip()
screen.fill(colors["BLACK"])
def handle_keys():
global playerx, playery, game_state
turnkeys = (pygame.K_UP, pygame.K_DOWN, pygame.K_LEFT, pygame.K_RIGHT, pygame.K_1, pygame.K_2, pygame.K_3, pygame.K_4, pygame.K_5, pygame.K_6, pygame.K_7, pygame.K_8, pygame.K_9)
for event in pygame.event.get():
if event.type == QUIT or (event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE):
quit()
elif event.type == pygame.KEYUP and pygcurse.interpretkeyevent(event) == '`' and ait.game_state == 'menu':
gui.win.setscreencolors(None, None, True)
ait.game_state = 'normal'
game = Game(flags = 'debug')
break
elif event.type == pygame.KEYUP and event.key == pygame.K_BACKSLASH:
if gui.win.fullscreen == True:
gui.win.fullscreen = False
else:
gui.win.fullscreen = True
gen.render_all()
if ait.game_state == 'normal':
if event.type == pygame.KEYUP and event.key in turnkeys:
if event.key == pygame.K_UP: gen.player.check(0, -1)
if event.key == pygame.K_DOWN: gen.player.check(0, 1)
if event.key == pygame.K_LEFT: gen.player.check(-1, 0)
if event.key == pygame.K_RIGHT: gen.player.check(1, 0)
if event.key == pygame.K_7: gen.player.check(-1, -1)
if event.key == pygame.K_8: gen.player.check(0, -1)
if event.key == pygame.K_9: gen.player.check(1, -1)
if event.key == pygame.K_4: gen.player.check(-1, 0)
if event.key == pygame.K_6: gen.player.check(1, 0)
if event.key == pygame.K_1: gen.player.check(-1, 1)
if event.key == pygame.K_2: gen.player.check(0, 1)
if event.key == pygame.K_3: gen.player.check(1, 1)
gui.msgs_updated = False
gen.ai_go()
gen.render_all()
elif event.type == pygame.KEYUP and pygcurse.interpretkeyevent(event) == '>':
for stairs in gen.down_stairs:
if gen.player.x == stairs.x and gen.player.y == stairs.y:
gen.level += 1
gen.area = 'dungeon'
gen.create_mp()
elif event.type == pygame.KEYUP and pygcurse.interpretkeyevent(event) == '<':
for stairs in gen.up_stairs:
if gen.player.x == stairs.x and gen.player.y == stairs.y:
if gen.level > 0:
gen.area = 'dungeon'
gen.create_mp()
else:
gen.area == 'city'
gen.create_mp()
elif event.type == pygame.KEYUP and pygcurse.interpretkeyevent(event) == '`':
for y in range(gui.MAPHEIGHT):
for x in range(gui.MAPWIDTH):
gen.mp[x][y].explored = True
for Object in gen.objects:
gui.win.putchar(Object.char, Object.x, Object.y, fgcolor=pygame.Color(170, 0, 170))
gui.win.update()
gui.win.blittowindow()
elif event.type == pygame.KEYUP and pygcurse.interpretkeyevent(event) == '?':
gui.win.setscreencolors(None, None, True)
gui.list(('7 8 9', '4 5 6 Movement Keys', '1 2 3', '', 'Arrow Keys:', ' UP', 'LEFT DOWN RIGHT', '', '\ : fullscreen', 'ESC: Quit', '', 'press any key to return'))
gui.win.update()
gui.win.blittowindow()
gui.win.setscreencolors(None, None, True)
elif ait.game_state == 'dead':
gen.render_all()
elif ait.game_state == 'menu':
if event.type == pygame.KEYUP:
return pygcurse.interpretkeyevent(event)
# elif ait.game_state == 'test':
else:
return 'didnt-take-turn'
chestPics[curChest] += 1
#Limit chest frames
if chestPics[curChest] >= 5:
chestPics[curChest] = 5
#Load map =-=-=-=-=-=-=-=-=-=
if descend == True:
#Loading screen
screen.fill((0, 0, 0))
p.display.flip()
#Create new floor
floor += 1 #Update floor name
curFloor = 'map' + str(floor)
complexityScale += 0.2 #Make new floor slightly larger and more complex
descend = False #Generate new map
curMap[curFloor] = MapGen(
numOfElements, complexityScale) #Create the map for the new floor
curMap[curFloor].mrGenny() #Generate the room layout
curMap[curFloor].mrClassy(
) #Determine the type of room depending on the amount of exits has
curMap[curFloor].mrRoomy() #Generate the room layout of each room
curMap[curFloor].mrCollidey(
) #Merge the collsion data of the room and room layout
curMap[curFloor].mrObby(scale) #Create all the doors
#Make a 2d array with all the collision data of all the rooms
for i in range(len(
curMap[curFloor].level)): #Iterate through each room of map
for n in range(len(curMap[curFloor].level[i])):
rawMapCollide = Collider.importCollisionMap(
n, i, numOfElements, curMap[curFloor].roomCollide[i][n],