def loadLayers(self, data):
levely = []
for layer in data['level']['layers']:
for y in range(*layer['ranges']['y']):
levelx = []
for x in range(*layer['ranges']['x']):
if layer['spritename'] == 'sky':
levelx.append(
Tile(
self.sprites.spriteCollection.get(
layer['spritename']), None))
else:
levelx.append(
Tile(
self.sprites.spriteCollection.get(
layer['spritename']),
pygame.Rect(x * 32, (y - 1) * 32, 32, 32)))
levely.append(levelx)
self.level = levely
def loadObjects(self, data):
for x, y in data["level"]["objects"]["bush"]:
self.addBushSprite(x, y)
for x, y in data["level"]["objects"]["cloud"]:
self.addCloudSprite(x, y)
for x, y, z in data["level"]["objects"]["pipe"]:
self.addPipeSprite(x, y, z)
for x, y in data["level"]["objects"]["sky"]:
self.level[y][x] = Tile(self.sprites.spriteCollection.get("sky"),
None)
def loadLayers(self, data):
layers = []
for x in range(*data["level"]["layers"]["sky"]["x"]):
layers.append(
(
[
Tile(self.sprites.spriteCollection.get("sky"), None)
for y in range(*data["level"]["layers"]["sky"]["y"])
]
+ [
Tile(
self.sprites.spriteCollection.get("ground"),
pygame.Rect(x * 32, (y - 1) * 32, 32, 32),
)
for y in range(*data["level"]["layers"]["ground"]["y"])
]
)
)
self.level = list(map(list, zip(*layers)))
def addCloudSprite(self,x,y):
try:
for yOff in range(0,2):
for xOff in range(0,3):
self.level[y+yOff][x+xOff] = Tile(
self.sprites.spriteCollection.get("cloud{}_{}".format(yOff+1,xOff+1)),
None
)
except IndexError:
return
def addRandomBox(self, x, y):
self.level[y][x] = Tile(None, pygame.Rect(x * 32, y * 32 - 1, 32, 32))
self.entityList.append(
RandomBox(
self.screen,
self.sprites.spriteCollection,
x,
y,
self.sound,
self.dashboard,
))
def loadObjects(self, data):
for obj in data['level']['objects']:
for position in obj['positions']:
if (obj['name'] == "bush"):
self.addBushSprite(position[0], position[1])
elif (obj['name'] == "cloud"):
self.addCloudSprite(position[0], position[1])
elif (obj['name'] == "randomBox"):
self.addRandomBox(position[0], position[1])
elif (obj['name'] == "pipe"):
self.addPipeSprite(position[0], position[1], position[2])
elif (obj['name'] == "coin"):
self.addCoin(position[0], position[1])
elif (obj['name'] == "sky"):
self.level[position[1]][position[0]] = Tile(
self.sprites.spriteCollection.get(obj['name']), None)
else:
self.level[position[1]][position[0]] = Tile(
self.sprites.spriteCollection.get(obj['name']),
pygame.Rect(position[0] * 32, position[1] * 32, 32,
32))
def addPipeSprite(self, x, y, length=2):
try:
# add Pipe Head
self.level[y][x] = Tile(
self.sprites.spriteCollection.get("pipeL"),
pygame.Rect(x * 32, y * 32, 32, 32),
)
self.level[y][x + 1] = Tile(
self.sprites.spriteCollection.get("pipeR"),
pygame.Rect((x + 1) * 32, y * 32, 32, 32),
)
# add pipe Body
for i in range(1, length + 20):
self.level[y + i][x] = Tile(
self.sprites.spriteCollection.get("pipe2L"),
pygame.Rect(x * 32, (y + i) * 32, 32, 32),
)
self.level[y + i][x + 1] = Tile(
self.sprites.spriteCollection.get("pipe2R"),
pygame.Rect((x + 1) * 32, (y + i) * 32, 32, 32),
)
except IndexError:
return
def loadLayers(self, data):
levely = {}
for layer in data['level']['layers']:
for y in range(layer['ranges']['y'][0], layer['ranges']['y'][1]):
if y not in levely:
levely[y] = {}
for x in range(layer['ranges']['x'][0],
layer['ranges']['x'][1]):
if (layer['spritename'] == 'sky'):
levely[y][x] = Tile(None, None)
elif (layer['spritename'] == 'ground'):
levely[y][x] = Tile(
None, pygame.Rect(x * 32, (y - 1) * 32, 32, 32))
self.groundList.append([x, y])
else:
levely[y][x] = Tile(
None, pygame.Rect(x * 32, (y - 1) * 32, 32, 32))
# print(levely)
level_setup = [[levely[key2][key1] for key1 in sorted(levely[key2])]
for key2 in sorted(levely)]
self.level = level_setup
import json
import pygame
from classes.Constants import *
from classes.Dashboard import Dashboard
from classes.Input import get
from classes.Tile import Tile
tiles = Tile().tiles
def load_json():
with open('./settings/menu.json') as jsonData:
map_data = json.load(jsonData)
bg_colors = map_data['color']
ground = map_data['object']["ground"]
background = map_data['object']["background"]
return background, ground, bg_colors
def load_setting():
with open('./settings/setting.json') as jsonData:
data = json.load(jsonData)
music = data['music']
return music
def load_level_name():
files = []
for file in os.listdir("./levels"):
def checkForKeyboardInput(self, makermode=False, level=None, player=None):
pressedKeys = pygame.key.get_pressed()
if pressedKeys[K_LEFT] or pressedKeys[
K_h] and not pressedKeys[K_RIGHT] and self.allowMovement:
self.entity.traits["goTrait"].direction = -1
elif pressedKeys[K_RIGHT] or pressedKeys[
K_l] and not pressedKeys[K_LEFT] and self.allowMovement:
self.entity.traits["goTrait"].direction = 1
elif pressedKeys[K_s]:
self.entity.stunned = False
elif pressedKeys[K_DOWN] and not pressedKeys[
K_LEFT] and not pressedKeys[K_RIGHT]:
if level.level[int(self.entity.rect.y / 32) + 1][int(
self.entity.rect.x /
32)].sprite == level.sprites.spriteCollection.get(
"pipeL") and level.level[int(self.entity.rect.y / 32) +
1][int(self.entity.rect.x /
32)].canUse:
# TODO
print "Coming soon!"
else:
self.entity.traits['goTrait'].direction = 0
isJumping = pressedKeys[K_SPACE] or pressedKeys[
K_UP] or pressedKeys[K_k] and self.allowMovement
self.entity.traits['jumpTrait'].jump(isJumping)
self.entity.traits['goTrait'].boost = pressedKeys[K_LSHIFT]
if makermode and not level == None:
x_offset = int(player.camera.x / 32) * -1
if pressedKeys[K_b]:
level.level[self.mouseY /
32][(self.mouseX / 32) + x_offset] = Tile(
level.sprites.spriteCollection.get("ground"),
pygame.Rect((self.mouseX / 32) + x_offset,
self.mouseY, 32, 32))
elif pressedKeys[K_c]:
level.addCloudSprite((self.mouseX / 32) + x_offset,
self.mouseY / 32)
elif pressedKeys[K_y]:
level.addBushSprite((self.mouseX / 32) + x_offset,
self.mouseY / 32)
elif pressedKeys[K_p]:
level.addPipeSprite((self.mouseX / 32) + x_offset,
self.mouseY / 32, 14)
elif pressedKeys[K_f]:
level.level[self.mouseY /
32][(self.mouseX / 32) + x_offset] = Tile(
level.sprites.spriteCollection.get("sky"),
None)
elif pressedKeys[K_o]:
level.addCoin((self.mouseX / 32) + x_offset, self.mouseY / 32)
sleep(0.5)
elif pressedKeys[K_r]:
level.addRandomBox((self.mouseX / 32) + x_offset,
self.mouseY / 32)
elif pressedKeys[K_g]:
level.addGoomba((self.mouseX / 32) + x_offset,
self.mouseY / 32)
sleep(0.5)
elif pressedKeys[K_k]:
level.addKoopa((self.mouseX / 32) + x_offset, self.mouseY / 32)
sleep(0.5)
elif pressedKeys[K_s]:
print "Saving level..."
idFile = str(randint(0, 999))
data = {
"id": int(idFile),
"length": 60,
"level": {
"layers": {
"sky": {
"x": [0, 60],
"y": [0, 13]
},
"ground": {
"x": [0, 60],
"y": [14, 16]
}
},
"objects": {
"bush": [],
"sky": [],
"cloud": [],
"pipe": [],
"ground": []
},
"entities": {
"randomBox": [],
"coin": [],
"Goomba": [],
"Koopa": []
}
}
}
for item in level.entityList:
print "Found " + item.__class__.__name__ + " at " + str(
int(item.rect.x / 32)) + "," + str(
int(item.rect.y / 32))
if not item.__class__.__name__ == "Coin":
if item.__class__.__name__ == "RandomBox":
data["level"]["entities"]["randomBox"].append(
[int(item.rect.x / 32),
int(item.rect.y / 32)])
else:
data["level"]["entities"][
item.__class__.__name__].append([
int(item.rect.x / 32),
int(item.rect.y / 32)
])
else:
data["level"]["entities"][
item.__class__.__name__.lower()].append(
[int(item.rect.x / 32),
int(item.rect.y / 32)])
for x in range(level.levelLength):
for y in range(15):
if level.level[y][
x].sprite == level.sprites.spriteCollection.get(
"pipeL"):
print "Found pipe at " + str(x) + "," + str(y)
data["level"]["objects"]["pipe"].append([x, y, 14])
elif level.level[y][
x].sprite == level.sprites.spriteCollection.get(
"bush_1"):
print "Found bush at " + str(x) + "," + str(y)
data["level"]["objects"]["bush"].append([x, y])
elif level.level[y][x].sprite == None:
print "Found box at " + str(x) + "," + str(y)
data["level"]["entities"]["randomBox"].append(
[x, y])
elif level.level[y][
x].sprite == level.sprites.spriteCollection.get(
"cloud1_1"):
print "Found cloud at " + str(x) + "," + str(y)
data["level"]["objects"]["cloud"].append([x, y])
elif level.level[y][
x].sprite == level.sprites.spriteCollection.get(
"ground"):
print "Found ground at " + str(x) + "," + str(y)
data["level"]["objects"]["ground"].append([x, y])
with open("level_" + str(randint(0, 999)) + ".json",
"w") as write_file:
json.dump(data, write_file)
sleep(1)
def addRandomBox(self, x, y):
self.level[y][x] = Tile(None, pygame.Rect(x * 32, y * 32 - 1, 32, 32))
self.entityList.append(RandomBox(
x,
y,
))
def make_map():
"""fill map with "unblocked" tiles"""
#the list of objects with just the player
var.game_objects = [var.player]
var.game_map = [[Tile(True)\
for y in range(var.MAP_HEIGHT)]\
for x in range(var.MAP_WIDTH)]
rooms = []
num_rooms = 0
for _ in range(var.MAX_ROOMS):
#random width and height
width = libtcod.random_get_int(0, var.ROOM_MIN_SIZE, var.ROOM_MAX_SIZE)
height = libtcod.random_get_int(0, var.ROOM_MIN_SIZE,
var.ROOM_MAX_SIZE)
#random position without going out of the boundaries of the map
x = libtcod.random_get_int(0, 0, var.MAP_WIDTH - width - 1)
y = libtcod.random_get_int(0, 0, var.MAP_HEIGHT - height - 1)
#"Rect" class makes rectangles easier to work with
new_room = Rect(x, y, width, height)
#run through the other rooms and see if they intersect with this one
failed = False
for other_room in rooms:
if new_room.intersect(other_room):
failed = True
break
if not failed:
#this means there are no intersections, so this room is valid
#"paint" it to the map's tiles
create_room(new_room)
#center coordinates of new room, will be useful later
(new_x, new_y) = new_room.center()
new_x = int(new_x)
new_y = int(new_y)
if num_rooms == 0:
#this is the first room, where the player starts at
var.player.x = new_x
var.player.y = new_y
else:
#all rooms after the first:
#connect it to the previous room with a tunnel
#center coordinates of the previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
prev_x = int(prev_x)
prev_y = int(prev_y)
#draw a coin (random number that is either 0 or 1)
if libtcod.random_get_int(0, 0, 1) == 1:
#first move horizontally, then vertically
create_h_tunnel(prev_x, new_x, prev_y)
create_v_tunnel(prev_y, new_y, new_x)
else:
#first move vertically, then horizontally
create_v_tunnel(prev_y, new_y, prev_x)
create_h_tunnel(prev_x, new_x, new_y)
#add some contents to this room, such as monsters
place_objects(new_room)
#finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
#create stairs at the center of the last room
var.stairs = Object(new_x,
new_y,
var.STAIRSDOWN_TILE,
'stairs',
libtcod.white,
always_visible=True)
var.game_objects.append(var.stairs)
var.stairs.send_to_back() #so it's drawn below the monsters
