def update(self, gameengine, current_time):
xVelocity, yVelocity = self.get_velocity(self.angle, self.speed)
self.rect.left += xVelocity
self.rect.top -= yVelocity
# Check if the projectile went outside the game map. If so, remove
# it.
if not self.rect.colliderect(gameengine.base.get_rect()):
gameengine.projectiles.remove(self)
# Check if the projectile collided with any characters
collided = self.collide(gameengine.characters, [gameengine.player])
if collided:
# Projectile collided with a player
gameengine.projectiles.remove(self)
else:
# Check if the projectile collided with any tiles
localCameraWidth = gameengine.tileengine.tileSize * 5
localCameraHeight = gameengine.tileengine.tileSize * 5
localCamera = Camera(localCameraWidth, localCameraHeight,
gameengine.camera.worldMapWidth,
gameengine.camera.worldMapWidth)
localCamera.update(gameengine.base, self)
tiles = gameengine.tileengine.get_tiles_pixel(localCamera.window)
#tiles = gameengine.tileengine.get_tiles_pixel(gameengine.camera.window)
collided = self.collide(tiles)
if collided:
gameengine.projectiles.remove(self)
def update(self, gameengine, current_time):
xVelocity, yVelocity = self.get_velocity(self.angle, self.speed)
self.rect.left += xVelocity
self.rect.top -= yVelocity
# Check if the projectile went outside the game map. If so, remove
# it.
if not self.rect.colliderect(gameengine.base.get_rect()):
gameengine.projectiles.remove(self)
# Check if the projectile collided with any characters
collided = self.collide(gameengine.characters, [gameengine.player])
if collided:
# Projectile collided with a player
gameengine.projectiles.remove(self)
else:
# Check if the projectile collided with any tiles
localCameraWidth = gameengine.tileengine.tileSize * 5
localCameraHeight = gameengine.tileengine.tileSize * 5
localCamera = Camera(localCameraWidth,localCameraHeight, gameengine.camera.worldMapWidth, gameengine.camera.worldMapWidth)
localCamera.update(gameengine.base, self)
tiles = gameengine.tileengine.get_tiles_pixel(localCamera.window)
#tiles = gameengine.tileengine.get_tiles_pixel(gameengine.camera.window)
collided = self.collide(tiles)
if collided:
gameengine.projectiles.remove(self)
def __init__(self, winWidth, winHeight):
self.winWidth = winWidth
self.winHeight = winHeight
self.cols = winWidth // constants.TILE_SIZE
self.rows = winHeight // constants.TILE_SIZE
pg.init()
pg.mixer.init()
pg.display.set_caption("dawn-lite")
pg.key.set_repeat(10, 50)
self.stage = Stage(self.cols * 2, self.rows * 2)
self.stage.fillWith(Tiles.wall)
for x in range(1, self.stage.width - 1):
for y in range(1, self.stage.height - 1):
pos = Vec(x, y)
self.stage.setTile(pos, Tiles.floor)
self.font = pg.font.Font(path.join(constants.FONT_PATH,
constants.DEFAULT_FONT),
constants.TILE_SIZE)
self.player = Hero(Vec(60, 3))
self.stage.addActor(self.player)
self.camera = Camera(self, self.stage, self.cols, self.rows)
self.camera.update(self.player)
self.window = pg.display.set_mode((self.winWidth, self.winHeight))
self.clock = pg.time.Clock()
self.running = True
def update(self, gameengine, current_time):
# Move our position up or down by one pixel
if self.xdirection > 0: self.rect.left += self.speed
elif self.xdirection < 0: self.rect.left -= self.speed
# Get the tiles around the character to check for collisions. We
# limit the check to the local character camera to limit unnecessary
# collision detection on tiles not near the character
localCameraWidth = gameengine.tileengine.tileSize * 5
localCameraHeight = gameengine.tileengine.tileSize * 5
localCamera = Camera(localCameraWidth, localCameraHeight,
gameengine.camera.worldMapWidth,
gameengine.camera.worldMapWidth)
localCamera.update(gameengine.base, self)
tiles = gameengine.tileengine.get_tiles_pixel(localCamera.window)
# Do collision detection after moving horizontally
if self.collide(tiles, True):
self.xdirection = 0
#if self.ydirection != 0: self.rect.top += 1*self.jumpspeed
#elif self.ydirection < 0: self.rect.top -= 1*self.speed
if not self.onGround:
# Slow jumping speed due to gravity
self.ydirection = self.ydirection + self.gravity
# Check for max falling speed
if self.ydirection > self.maxFallingSpeed:
self.ydirection = self.maxFallingSpeed
self.rect.top += self.ydirection
# Do collision detection after moving vertically
if self.collide(tiles, False):
self.ydirection = 0
# Check if the character is actually on the ground as it may have
# moved off a cliff. Only necessary if the character moved
# horizontally.
# Temporary move down 1
self.rect.bottom += 1
self.onGround = self.collide(tiles, False)
# Undo the temporary move down 1 if not on the ground
if not self.onGround:
self.rect.bottom -= 1
# Update the sprite image
self.update_image(current_time)
# Update the current item
if self.currentItem:
self.currentItem.update(gameengine, self)
def update(self, gameengine, current_time):
# Move our position up or down by one pixel
if self.xdirection > 0: self.rect.left += self.speed
elif self.xdirection < 0: self.rect.left -= self.speed
# Get the tiles around the character to check for collisions. We
# limit the check to the local character camera to limit unnecessary
# collision detection on tiles not near the character
localCameraWidth = gameengine.tileengine.tileSize * 5
localCameraHeight = gameengine.tileengine.tileSize * 5
localCamera = Camera(localCameraWidth,localCameraHeight, gameengine.camera.worldMapWidth, gameengine.camera.worldMapWidth)
localCamera.update(gameengine.base, self)
tiles = gameengine.tileengine.get_tiles_pixel(localCamera.window)
# Do collision detection after moving horizontally
if self.collide(tiles, True):
self.xdirection = 0
#if self.ydirection != 0: self.rect.top += 1*self.jumpspeed
#elif self.ydirection < 0: self.rect.top -= 1*self.speed
if not self.onGround:
# Slow jumping speed due to gravity
self.ydirection = self.ydirection + self.gravity
# Check for max falling speed
if self.ydirection > self.maxFallingSpeed: self.ydirection = self.maxFallingSpeed
self.rect.top += self.ydirection
# Do collision detection after moving vertically
if self.collide(tiles, False):
self.ydirection = 0
# Check if the character is actually on the ground as it may have
# moved off a cliff. Only necessary if the character moved
# horizontally.
# Temporary move down 1
self.rect.bottom += 1
self.onGround = self.collide(tiles, False)
# Undo the temporary move down 1 if not on the ground
if not self.onGround:
self.rect.bottom -= 1
# Update the sprite image
self.update_image(current_time)
# Update the current item
if self.currentItem:
self.currentItem.update(gameengine, self)
def __init__(self, initialWidth, initialHeight):
self.debugging = True
self.winWidth = initialWidth
self.winHeight = initialHeight
self.clock = pygame.time.Clock()
# Initialize the camera
self.camera = Camera(self.winWidth, self.winHeight,
WORLD_MAP_PIXEL_SIZE[0], WORLD_MAP_PIXEL_SIZE[1])
# Load the base (world surface)
self.base = self.load_base()
# Load the background
self.background = self.load_background()
# Initialize the tile engine
self.tileengine = TileEngine.fromfilename(WORLD_MAP_FILE, TILE_SIZE)
# Initialize the player sprites
self.characters = pygame.sprite.Group()
self.player = Character([255, 0, 0], (1600, 1000))
self.characters.add(self.player)
self.player.equipment.add(item.TileTool(), 1)
self.player.currentItem = self.player.equipment.get(1)
self.player.equipment.add(item.Weapon(), 2)
self.player.equipment.add(item.EnemyTool(), 3)
# Initialize projectiles
self.projectiles = pygame.sprite.Group()
# Initialize different states of the game
self.playState = gamestate.PlayState()
self.menuState = gamestate.MenuState()
self.inventoryState = gamestate.InventoryState(self.player.inventory)
self.currentState = self.playState
from raymarching.scene import Scene
from raymarching.sdfcube import SDFCube
from engine.camera import Camera
from engine.vector import Vector3
import os
scene = Scene()
c = Camera()
c.fov = 90
scene.set_camera(c)
cube = SDFCube(Vector3(2, 2, 1))
cube.transform.position = Vector3(0.0, 0.0, 4.0)
scene.add_objects(cube)
if os.path.exists("/sdcard/Raytracing/"):
render_image = "/sdcard/Raytracing/test"
else:
render_image = 'test'
render_extension = '.jpg'
render_sizex = 50
render_sizey = 50
scene.render(render_sizex, render_sizey, render_image + render_extension)
#Initialize variables
txt = None
with open('engine/testMap.txt', 'r') as file:
txt = file.readlines()
world = World(txt)
world.player.speed = 4
world.player.acts = [attackPlayer, death]
world.player['beard'] = 'mustache'
world.player['right hand'] = 'spear'
world.player['left hand'] = 'arrow'
for i in range(12):
addEnemy()
camera = Camera(background, world, 1)
# profile = cProfile.Profile()
# profile.enable()
#main infinite loop
def main():
# default event loop
for event in pygame.event.get():
# Quit conditions
if event.type == pygame.QUIT or pygame.key.get_pressed()[
pygame.K_ESCAPE]:
return False
# update calls
from engine import game
from engine.net.online import client
game.client = client
#from Box2D import b2World
#game.init(world=b2World(gravity=(0, 0), doSleep=True))
#import rule_connect
#rule_connect.add()
from engine.camera import Camera
Camera().add()
from engine.assets import camera_control
camera_control.add()
#import b2draw
#b2draw.init()
#from engine.assets.firefly import Firefly
import random
for _ in range(100):
pass #Firefly(random.randint(-40, 40), random.randint(-30, 30)).add()
#from engine.assets.tilemap import TileMap, SolidBlock
#tilemap = TileMap((0, 0), (10, 10))
#tilemap.add()
from engine.entity import Entity
from engine.net.online import online, online_entity
import os
import pdf2image
from sys import stdout
app = Flask(__name__)
CORS(app)
UPLOAD_FOLDER = os.path.basename('uploads')
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///user_data.db'
db = SQLAlchemy(app)
app.logger.addHandler(logging.StreamHandler(stdout))
app.config['SECRET_KEY'] = 'secret!'
app.config['DEBUG'] = True
socketio = SocketIO(app)
camera = Camera(Makeup_artist())
class User(db.Model):
"""Model for Users"""
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String)
last_name = db.Column(db.String)
email = db.Column(db.String, unique=True)
password = db.Column(db.String)
country = db.Column(db.String)
db.create_all()
class Engine:
def __init__(self, winWidth, winHeight):
self.winWidth = winWidth
self.winHeight = winHeight
self.cols = winWidth // constants.TILE_SIZE
self.rows = winHeight // constants.TILE_SIZE
pg.init()
pg.mixer.init()
pg.display.set_caption("dawn-lite")
pg.key.set_repeat(10, 50)
self.stage = Stage(self.cols * 2, self.rows * 2)
self.stage.fillWith(Tiles.wall)
for x in range(1, self.stage.width - 1):
for y in range(1, self.stage.height - 1):
pos = Vec(x, y)
self.stage.setTile(pos, Tiles.floor)
self.font = pg.font.Font(path.join(constants.FONT_PATH,
constants.DEFAULT_FONT),
constants.TILE_SIZE)
self.player = Hero(Vec(60, 3))
self.stage.addActor(self.player)
self.camera = Camera(self, self.stage, self.cols, self.rows)
self.camera.update(self.player)
self.window = pg.display.set_mode((self.winWidth, self.winHeight))
self.clock = pg.time.Clock()
self.running = True
def start(self):
while self.running:
self.handleEvents()
self.update()
self.render()
def handleEvents(self):
for event in pg.event.get():
if event.type == pg.QUIT:
self.running = False
if event.type == pg.KEYDOWN:
if event.key == pg.K_w:
if self.stage.rows == self.camera.height:
return
self.stage.moveActor(self.player, Directions.N)
self.player.pos = self.player.pos + Directions.N
if event.key == pg.K_a:
if self.stage.cols == self.camera.width:
return
self.stage.moveActor(self.player, Directions.W)
self.player.pos = self.player.pos + Directions.W
if event.key == pg.K_s:
if self.stage.rows == self.camera.height:
return
self.stage.moveActor(self.player, Directions.S)
self.player.pos = self.player.pos + Directions.S
if event.key == pg.K_d:
if self.stage.cols == self.camera.width:
return
self.stage.moveActor(self.player, Directions.E)
self.player.pos = self.player.pos + Directions.E
self.camera.update(self.player)
print(self.camera.bounds)
def drawGlyphAt(self, glyph, x, y):
self.window.blit(glyph,
(x * constants.TILE_SIZE,
y * constants.TILE_SIZE))
def _drawStage(self):
# Loop through the positions in range of the camera's rect
for pos in self.camera:
tile = self.stage[pos]
actor = self.stage.getActorAt(pos)
if tile.isVisible:
symbol = tile.type.symbol
fore = tile.type.explored[0]
back = tile.type.explored[1]
glyph = self.font.render(symbol, True, fore, back)
self.drawGlyphAt(glyph,
pos.x - self.camera.bounds.x,
pos.y - self.camera.bounds.y)
if tile.isExplored:
symbol = tile.type.symbol
fore = tile.type.explored[0]
back = tile.type.explored[1]
glyph = self.font.render(symbol, True, fore, back)
self.drawGlyphAt(glyph,
pos.x - self.camera.bounds.x,
pos.y - self.camera.bounds.y)
if actor is not None and actor.isVisible:
symbol = actor.symbol
color = actor.color
glyph = self.font.render(symbol, True, color)
self.drawGlyphAt(glyph,
pos.x - self.camera.bounds.x,
pos.y - self.camera.bounds.y)
def update(self):
pass
def render(self):
self._drawStage()
pg.display.flip()
import engine.game as game game.init() #import rule_connect #rule_connect.add() from engine.camera import Camera Camera(zoom=0.02).add() import engine.assets.camera_control as camera_control camera_control.add() from bullet import Bullet from bubble import Bubble import random from engine.physics import Vec2 #Bubble((0, 0), 1).add() import control control.add() from grid import Grid Grid().add() game.start()
def setUp(self):
self.camera = Camera(glm.vec3(0, 0, 0))
self.camera.speed = 2
self.camera.sensitivity = 2
self.projection = helper.getProjection()
class CameraTest(unittest.TestCase):
def setUp(self):
self.camera = Camera(glm.vec3(0, 0, 0))
self.camera.speed = 2
self.camera.sensitivity = 2
self.projection = helper.getProjection()
def testMoveTop(self):
self.camera.moveTop(1)
self.camera.updateVectors()
expectedPos = self.camera.direction * 2
self.assertEqual(expectedPos, self.camera.position)
def testMoveBottom(self):
self.camera.moveBottom(1)
self.camera.updateVectors()
expectedPos = -self.camera.direction * 2
self.assertEqual(expectedPos, self.camera.position)
def testMoveleft(self):
self.camera.moveLeft(1)
self.camera.updateVectors()
expectedPos = -self.camera.right * 2
self.assertEqual(expectedPos, self.camera.position)
def testMoveRight(self):
self.camera.moveRight(1)
self.camera.updateVectors()
expectedPos = self.camera.right * 2
self.assertEqual(expectedPos, self.camera.position)
def testRotateX(self):
self.camera.rotate(3, 0)
self.camera.updateVectors()
self.assertEqual(6, self.camera.yaw)
def testRotateY(self):
self.camera.rotate(0, 3)
self.camera.updateVectors()
self.assertEqual(6, self.camera.pitch)
self.camera.rotate(0, 100)
self.camera.updateVectors()
self.assertEqual(89, self.camera.pitch)
self.camera.rotate(0, -100)
self.camera.updateVectors()
self.assertEqual(-89, self.camera.pitch)
class GameLevel:
""" Level of the game """
def __init__(self,
objects,
player_pos,
limgpar=[],
name='',
parallax=True,
gravity=2100,
music=None): #Gravity is set experimentally for jumps to 2100
""" The player spawn in (0,0) """
assert objects != [] #Empty GameLevel
self.camera = Camera() #Camera
self.camera.set_position(Vector(-12, -12))
self.camera.set_dimension(Vector(25, 25))
self.objects = objects
self.player_pos = player_pos
self.compute_size_level()
self.name = name
self.music = music
#Creation of the gravity
self.gravity = Gravity(
gravity
) #NOTE POUR LES RAGEUX : On a testé et ca marche bien avec cette valeur -> ca permet d'avoir un saut élegant
self.begin_time = 0
self.time = 0 #Time Referential of the level
#Death animation
self.lost = False
self.countdown = 1
#Creation of the player
self.player = Player()
self.player.set_position(0, -16) #Init pos of the player
self.objects.append(self.player)
self.player.link_world(self)
#Camera Y scrolling
self.camera_y_pos = self.player.get_position().y
#To optimise physics
self.sorted_objects = None
self.dynamic_objects = set([self.player])
self.opti_step = 10
self.optimise_data()
self.progression = 0
#Get end platform locations to compute score
self.end_platform_location = None
self.compute_end_platform_location()
#Load Background
self.parallax = parallax
self.load_bg(limgpar)
#Link worlds
for o in objects:
o.link_world(self)
#End the initialisatio
self.end_init()
def load_bg(self, limgpar):
if not self.parallax:
if len(limgpar) >= 6:
limgpar = [limgpar[0]]
elif len(limgpar) >= 2:
limgpar = [limgpar[1]]
lpar = [] #List of Parallax
for (name, index) in limgpar:
p = Parallax(name, index) #Create parallax with given speed
lpar.append(p)
self.background = Background(lpar)
def end_init(self):
""" Call all end_init of objects in the world """
for o in self.objects:
o.end_init()
def get_camera(self):
""" Returns the camera """
return self.camera
def get_objects(self):
""" Returns objects of the level """
return self.objects
def load_inventory(self, inv):
""" Load the inventory of campaign mode in the GameLevel """
self.player.load_inventory(inv)
def add_node(self, n):
""" Adds a new node to the world """
self.objects.append(n)
self.dynamic_objects.add(n)
n.link_world(self)
def compute_end_platform_location(self):
""" Compute the list of platform location """
self.end_platform_location = []
for o in self.get_objects():
if isinstance(o, SolidPlatform):
self.end_platform_location.append(
o.get_hit_box().get_world_rect().get_max_x())
self.end_platform_location.sort()
def get_objects_opti(self):
""" Optimise the data structure """
while self.progression < len(self.sorted_objects):
o = self.sorted_objects[self.progression]
orect = o.get_hit_box().get_world_rect()
crect = self.get_camera().rect
if orect.collidex(crect):
self.dynamic_objects.add(o)
self.progression += 1
else:
break
return self.dynamic_objects
def optimise_data(self):
""" Optimise collisions checks and aff """
#Call it before launching the game of making modification in camera (be carefull it may take a while to execute
def order(o1):
return o1.get_hit_box().get_world_rect().get_min_x()
sorted_objects = self.objects[:]
sorted_objects.sort(key=order)
self.sorted_objects = sorted_objects
def compute_size_level(self):
""" Computes the size of the level """
maxi_x = None
maxi_y = None
mini_x = None
mini_y = None
#Get the rect in which the level is
for o in self.objects:
hit_box = o.get_hit_box()
val_max_x = hit_box.get_world_rect().get_max_x()
val_max_y = hit_box.get_world_rect().get_max_y()
val_min_x = hit_box.get_world_rect().get_min_x()
val_min_y = hit_box.get_world_rect().get_min_y()
if maxi_x is None or val_max_x > maxi_x:
maxi_x = val_max_x
if mini_x is None or val_min_x < mini_x:
mini_x = val_min_x
if maxi_y is None or val_max_y > maxi_y:
maxi_y = val_max_y
if mini_y is None or val_min_y < mini_y:
mini_y = val_min_y
self.size_level = (mini_x, maxi_x, mini_y, maxi_y)
def get_size_level(self):
""" Returns the size of the level as a tuple (minx,maxx,miny,maxy) """
return self.size_level
def play(self, fps):
""" Launches the gameLevel , returns +score if win, -score if lose """
#Starts the music
if self.music != None:
pygame.mixer.music.load(self.music)
pygame.mixer.music.play(-1)
t0 = get_current_time()
tn = t0
try:
while True:
#Get time
now = get_current_time()
#Compute dt from previous iteration
dt = now - tn
#Updates time from the begining
self.time = tn - t0
#Launch the loop
self.main_loop(dt)
#Updates tn for the next iteration
tn = now
except EndGame as e:
#print("--",time.clock()-t0,self.time)
return (e.issue, e.score)
def main_loop(self, dt):
#to = time.clock()
""" Main loop of the game (controllers, physics, ...) """
#Animation of lose
self.animation_end_game(dt)
#Computes opti objects
obj_opti = set(self.get_objects_opti())
#Call controllers
self.compute_controller(obj_opti, dt)
#Computation of physics
self.physics_step(dt, obj_opti)
#Camera set position (3/4)
self.compute_camera_position(obj_opti)
#Show all sprites
self.aff(dt, obj_opti)
#print("aff",time.clock()-t)
#Score
self.compute_score()
#Win / Lose conditions
self.compute_win_lose()
def animation_end_game(self, dt):
""" Waits a bit after the player dies before ending the game """
if self.lost:
if self.countdown > 0:
self.countdown -= dt
else:
raise EndGame(False, self.player.score)
def compute_camera_position(self, obj_opti):
""" Compute the camera position by trying to fix it on the platform below the player and smooth movements """
prect = self.player.get_hit_box().get_world_rect()
#Search for the platform right below the player
mini = None
for o in obj_opti:
if isinstance(o, SolidPlatform):
rect = o.get_hit_box().get_world_rect()
if rect.collidex(prect):
y = rect.get_min_y()
if (
mini is None and prect.get_min_y() < y
or prect.get_min_y() < y < mini
) and abs(
prect.get_min_y() - y
) < 100: #If it's too far it will forget it and fix on the player instead
mini = y
if mini is None: #No platform -> fix on the player
y = self.player.get_position().y
else: #Fix on a platform
y = mini
#Smooth moving of the camera
old_percent = 95 #The percentage of the old value of self.camera_y_pos that will be kept
self.camera_y_pos = self.camera_y_pos * old_percent / 100 + y * (
100 - old_percent
) / 100 #Computation of the new continous Y position of the camera
self.camera.threeforth_on(
Vector(self.player.get_position().x, self.camera_y_pos)
) #Position of the camera (pos X of the player et pos Y previously computed)
def compute_win_lose(self):
""" Compute win / lose conditions (only lose since the commit adding flags)"""
(minx, maxx, miny, maxy) = self.get_size_level()
if self.player.get_position().y > maxy or not (
self.player.alive): #C'est inversé :)
self.lose()
def compute_score(self):
""" Compute score """
while len(self.end_platform_location) > 0 and self.player.get_position(
).x >= self.end_platform_location[0]:
del self.end_platform_location[0]
self.player.add_score(1000)
def compute_controller(self, objects, dt):
""" Compute controllers """
pressed = pygame.key.get_pressed()
#Controller loop
for event in pygame.event.get() + [None]:
for o in set(objects):
if o.get_controller() is not None:
o.get_controller().execute(event, pressed, dt)
#Physics
def win(self):
""" Win the game """
self.player.flush_score()
raise EndGame(True, self.player.score)
def lose(self):
""" Lose the game """
self.player.flush_score()
self.lost = True
def physics_step(self, dt, obj_opti):
""" Compute collisions """
for i, o in enumerate(obj_opti):
if True: #not(isinstance(o,SolidPlatform)): #On peut se permettre d'integrer les plateformes au calcul suite a de nombreux gains de performance
o.compute_speed(dt)
o.move(dt)
if o == self.player and self.player.alive:
#Reposition the player
pos = o.get_position()
new_pos = Vector(self.player_pos(self.time), pos.y)
o.translate(new_pos - pos)
#Cut X speed (for MAXSPEED)
speed = self.player.get_speed()
self.player.set_speed(Vector(
1, speed.y)) #Player needs to have a str pos speed
for j, o2 in enumerate(obj_opti):
if o.get_collide() and o2.get_collide():
coll = o.get_hit_box().collide_sides(o2.get_hit_box())
#print("--",o,o2,coll)
if o != o2 and coll:
o.collide(o2, coll, (coll + 2) % 4)
o2.collide(o, (coll + 2) % 4, coll)
while o.get_rigid_body() and o2.get_rigid_body(
) and o.get_rigid_hit_box().collide(
o2.get_rigid_hit_box(
)) and o.get_speed() != Vector(0, 0):
#print("rigid")
o.apply_solid_reaction(o2)
def load_camera(self, fen):
""" Loads the actual camera of the Level """
self.background.load(fen) #Loads the background too
self.camera.set_fen(fen)
self.camera.link_world(self)
def get_background(self):
""" Returns the background """
return self.background
def set_background(self, v):
""" Set the background """
self.background = v
def aff(self, dt, objects):
""" Aff all objects that are in the camera of this """
self.camera.aff(objects, self.get_background(),
self.player.get_score(), dt)
pygame.display.flip()
from engine.base.program import getLinkedProgram
from engine.renderable.model import Model
from engine.buffer.texture import *
from engine.buffer.hdrbuffer import HDRbuffer
from engine.buffer.blurbuffer import Blurbuffer
from engine.effect.shadow import Shadow
from engine.effect.bloom import Bloom
from engine.generator import generateVoxelPositions
from engine.camera import Camera
from engine.config import config
cube, hdrbuffer, blurbuffer, lastPosX, lastPosY = None, None, None, None, None
firstTime = True
width, height = config['window_width'], config['window_height']
camera = Camera(
glm.vec3(config['world_width'] / 2, config['world_height'] + 1,
config['world_depth'] / 2))
def main():
global hdrbuffer, blurbuffer, cube
if not glfw.init():
print('Failed to initialize GLFW.')
return
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE)
glfw.window_hint(glfw.SAMPLES, config['sampling_level'])
def __init__(self,
objects,
player_pos,
limgpar=[],
name='',
parallax=True,
gravity=2100,
music=None): #Gravity is set experimentally for jumps to 2100
""" The player spawn in (0,0) """
assert objects != [] #Empty GameLevel
self.camera = Camera() #Camera
self.camera.set_position(Vector(-12, -12))
self.camera.set_dimension(Vector(25, 25))
self.objects = objects
self.player_pos = player_pos
self.compute_size_level()
self.name = name
self.music = music
#Creation of the gravity
self.gravity = Gravity(
gravity
) #NOTE POUR LES RAGEUX : On a testé et ca marche bien avec cette valeur -> ca permet d'avoir un saut élegant
self.begin_time = 0
self.time = 0 #Time Referential of the level
#Death animation
self.lost = False
self.countdown = 1
#Creation of the player
self.player = Player()
self.player.set_position(0, -16) #Init pos of the player
self.objects.append(self.player)
self.player.link_world(self)
#Camera Y scrolling
self.camera_y_pos = self.player.get_position().y
#To optimise physics
self.sorted_objects = None
self.dynamic_objects = set([self.player])
self.opti_step = 10
self.optimise_data()
self.progression = 0
#Get end platform locations to compute score
self.end_platform_location = None
self.compute_end_platform_location()
#Load Background
self.parallax = parallax
self.load_bg(limgpar)
#Link worlds
for o in objects:
o.link_world(self)
#End the initialisatio
self.end_init()
# final point, final line, connects back to first point
elif idx == len(polygon) - 1:
lineDef.asLeaf(lineDefs[-1], lineDefs[0], polygon[idx][2],
polygon[idx][3])
lineDefs.append(lineDef)
allLineDefs.append(lineDef)
solidBsp = SolidBSPNode(allLineDefs)
#print(solidBsp.toText())
# TESTING WALL DRAWING
wallTest = allLineDefs[4]
# camPoint = [90, 150]
# camDirRads = 0
# camDir = engine.mathdef.toVector(camDirRads)
camera = Camera()
camera.worldX = 150
camera.worldY = 60
camera.angle = -math.pi / 2
# testPoint = [60, 20]
# for lineDef in allLineDefs:
# isBehind = lineDef.isPointBehind(testPoint[0], testPoint[1])
# print(lineDef.start, lineDef.end, lineDef.facing, isBehind)
# print(solidBsp.inEmpty(testPoint))
display = Display(1920, 1080)
listener = EventListener()
pygame.mouse.set_visible(False)
pygame.event.set_grab(True)
font = pygame.font.Font(None, 36)
