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 __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
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()
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.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'])
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()
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()
# 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)
