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)