def loadGame(self):
self.exitStartMenu()
print("Loading game")
self.state = 'Loading'
if(self.debug == False):
self.hide_cursor
self.setLights()
self.terrain.load()
self.hud = Hud()
self.hud.show()
self.loadEntities()
#positionate the camera
if(self.debug == False):
self.camera.lookAt(self.slime.model)
# Load Skybox
Skybox(self.render)
#register events
self.ydelta = 300
self.zdelta = 60
self.accept("wheel_up", self.camzoom,[True])
self.accept("wheel_down", self.camzoom,[False])
#register tasks
self.task_mgr.add(self.mainLoop, "MainTask")
if(self.debug == False):
self.task_mgr.add(self.updateCamera, "CameraTask")
self.startGame()
def __init__(self):
log.debug('Starting Client')
#open a window... but first set all the needed props
wp = self.loadWindoProperites()
#open the window
base.openMainWindow(props=wp)
#base.setBackgroundColor(0.06, 0.1, 0.12, 1)
base.setBackgroundColor(0.0, 0.0, 0.0, 1)
base.disableMouse()
base.enableParticles()
#needed to determine what window event fired
self.window_focused = base.win.getProperties().getForeground()
self.window_x = base.win.getXSize()
self.window_y = base.win.getYSize()
self.window_minimized = base.win.getProperties().getMinimized()
#filter manager, post process
self.filters = Filters()
#audio sound effects (sfx) + music
self.audio = Audio()
self.audio.setMusic('background')
self.audio.playMusic()
#light manager
self.lights = LightManager()
#setup the user interface (gui+key/mouse bind)
self.ui = UserInterface()
#skybox
self.sun_and_sky = Skybox(self.lights)
#player (character) droid
self.droid = PCDroid(self.ui)
#some vars used later
self.map_name = None
self.loading_status = set()
self.level_root = render.attachNewNode('level_root')
self.level_root.hide()
self.is_in_game = False
#events
base.win.setCloseRequestEvent('exit-event')
self.accept('exit-event', self.onClientExit)
self.accept('window-event', self.onWindowEvent)
self.accept('window-reset', self.onWindowReset)
self.accept('client-mouselock', self.setMouseLock)
self.accept('load-level', self.onLevelLoad)
self.accept('loading-done', self.onLoadingDone)
self.accept('reload-shaders', self.onShaderReload)
self.accept('client-set-team', self.onTeamCahnge)
self.accept('client-quit', self.onQuit)
# Task
taskMgr.add(self.update, 'client_update')
log.debug('Client started')
def game(window: Window, ctx: Context):
"""Run game."""
# load assets in the default vao
ctx.use_vao("default")
entities = []
textbox = Text(ctx, [-0.25, 7, -9], "<score>")
cam = GameCamera()
player = Player()
skybox = Skybox(ctx, "assets/skybox")
# mainloop
old_time = glfw.get_time()
spawn_timer = 0.0
spawn_delay = 4.0
while window and player:
hits = [0, 0, 0]
new_time = glfw.get_time()
dt = new_time - old_time
cam.wobble(dt)
cam.set_target_y(player.pos[1] * 0.2 + 5)
skybox.rot[2] += dt * 0.01
spawn_timer += dt
if spawn_timer > spawn_delay:
# Spawn new Obstacle
spawn_timer = 0.0
entities.append(Obstacle([0, 0, 200]))
if spawn_delay > 0.8:
spawn_delay -= dt * 0.1
for e in entities:
e.update(dt, ctx, window)
if e and abs(e.pos[2] - player.pos[2]) < 1.0:
hits = list(map(max, zip(hits, e.hitogram)))
entities = [e for e in entities if e]
player.update(dt, ctx, window, hits)
old_time = new_time
# Render
ctx.clear()
ctx.use_vao("default")
for entity in entities:
entity.draw(ctx, cam)
player.draw(ctx, cam)
skybox.draw(ctx, cam)
textbox.draw(ctx, cam)
textbox.update(
str(new_time)[:str(new_time).find(".") + 2] + f"\n hp{player.hp}")
window.swap_buffers()
ctx.clear()
return str(new_time)[:str(new_time).find(".") + 2]
def __init__(self):
if Window.__instance is None:
Window.__instance = self
super().__init__()
self.bind = {}
self.load_bind()
self.option = {}
self.load_option()
self.properties()
self.setFrameRateMeter(True)
self.skybox = Skybox()
self.accept(self.bind[Bind.EXIT.value], sys.exit)
self.world = BulletWorld()
self.world_node = None
self.debug_node_path = None
self.setup_world()
def load_new_level(self, level, areas=True):
if self.in_intro:
self.in_intro = False
self.exclusive_mouse = True
self.set_exclusive_mouse(self.exclusive_mouse)
self.pop_handlers()
self.push_handlers(self.camera.input_handler)
self.current_level = level
self.set_start_pos()
self.level_batch = self.level_geometry.load_level(level)
## Reset camera position to the new start_pos.
self.camera.position = self.start_pos
self.camera.yaw = self.start_yaw
self.camera.pitch = 0.0
if self.skybox_dict[level]:
self.skybox = Skybox(self.skybox_dict[level],
self.mario_graphics_dir)
self.skybox.skybox_set_fov(self.fov)
self.skybox_present = True
else:
self.skybox_present = False
def __init__(self, width=1000, height=1000, skybox=None):
self.y_angle = 0
self.x_angle = 0
self.fill_modes = cycle([GL.GL_LINE, GL.GL_POINT, GL.GL_FILL])
# version hints: create GL window with >= OpenGL 3.3 and core profile
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL.GL_TRUE)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.RESIZABLE, False)
self.win = glfw.create_window(width, height, 'Viewer', None, None)
# make win's OpenGL context current; no OpenGL calls can happen before
glfw.make_context_current(self.win)
# register event handl ers
glfw.set_key_callback(self.win, self.on_key)
self.trackball = GLFWTrackball(self.win)
# useful message to check OpenGL renderer characteristics
print(
'OpenGL',
GL.glGetString(GL.GL_VERSION).decode() + ', GLSL',
GL.glGetString(GL.GL_SHADING_LANGUAGE_VERSION).decode() +
', Renderer',
GL.glGetString(GL.GL_RENDERER).decode())
# initialize GL by setting viewport and default render characteristics
GL.glClearColor(0.1, 0.1, 0.1, 0.1)
GL.glEnable(GL.GL_CULL_FACE)
GL.glEnable(GL.GL_DEPTH_TEST)
self.skybox = Skybox("skybox2.jpg")
# initially empty list of object to draw
self.drawables = []
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# environment node
environment = Node()
# set skybox
shader = Shader("./shaders/skybox.vert", "./shaders/skybox.frag")
environment.add(Skybox(shader, "./../assets/skybox/underwater/"))
# set seabed
shader = Shader("./shaders/texture.vert", "./shaders/texture.frag")
src = './../assets/models/seabed/seabed.fbx'
texFile = './../assets/models/seabed/seabed.jpg'
seabed = Node(transform=scale(0.008, 0.01, 0.008) @ translate(0, -100, 0))
model = Model(src, shader)
for m in model.load_phong_textured_skinned(texFile):
seabed.add(m)
# plants node
plants = Node()
# add seaweed
shader = Shader("./shaders/texture.vert", "./shaders/texture.frag")
src = './../assets/models/plants/seaweed/seaweed.fbx'
texFile = './../assets/models/plants/seaweed/seaweed.png'
seaweed = Node(transform=scale(2, 2, 2))
seaweed_density = 80
for i in range(seaweed_density):
model = Model(src, shader)
temp = Node(
transform=translate(randrange(-50, 50), 3.5, randrange(-50, 50)))
temp2 = Node(
transform=translate(randrange(-20, 20), 15, randrange(-20, 0)))
for m in model.load_textured(texFile):
temp.add(m)
if (i % 2 == 0):
temp2.add(m)
seaweed.add(temp)
if (i % 2 == 0):
seaweed.add(temp2)
plants.add(seaweed)
# add coral
coral_count = 7
src = './../assets/models/plants/coral/coral.obj'
texFile = './../assets/models/plants/coral/coral.jpg'
coral = Node(transform=scale(0.1, 0.1, 0.1))
for i in range(coral_count):
model = Model(src, shader)
temp = Node(transform=translate(randrange(-300, 300), 350,
randrange(-300, -100)))
for m in model.load_textured(texFile):
temp.add(m)
coral.add(temp)
plants.add(coral)
seabed.add(plants)
environment.add(seabed)
# add fish models
shader = Shader("./shaders/phong_texture_skinning.vert",
"./shaders/phong_texture_skinning.frag")
fishes = []
fish_count = 20
fish_no = randint(1, 24)
src = './../assets/models/fish/%d/model.fbx' % fish_no
texFile = './../assets/models/fish/%d/texture.png' % fish_no
fish = Node(transform=scale(0.0001, 0.0001, 0.0001))
model = Model(src, shader)
control_node = ControlNode(KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT, 30)
for m in model.load_phong_textured_skinned(texFile):
control_node.add(m)
fish.add(control_node)
fishes.append(fish)
for i in range(0, fish_count + 1):
fish_no = randint(1, 24)
src = './../assets/models/fish/%d/model.fbx' % fish_no
texFile = './../assets/models/fish/%d/texture.png' % fish_no
fish = Node(transform=scale(0.0001, 0.0001, 0.0001))
model = Model(src, shader)
for m in model.load_phong_textured_skinned(texFile):
fish.add(m)
fishanimation = FishAnimation()
animated_node = KeyFrameControlNode(fishanimation.get_translate_keys(),
fishanimation.get_rotate_keys(), {
0: 1,
2: 1,
4: 1
},
loop=True)
animated_node.add(fish)
fishes.append(animated_node)
for fish in fishes:
environment.add(fish)
scene = Node()
scene.add(environment)
viewer.add(scene)
print(
"Controls : Use the mouse to change the scene view. Press spacebar to restart the scene animations. Press W to see polygons and ESC or Q to Quit."
)
# start rendering loop
viewer.run()
def __init__(self, showbase):
# Initialise Window
self.showbase = showbase
# total time since start of game, to keep ticks updating on time (rather, not before)
self.total_time = 0
# packets queue
self.incoming = deque()
# this is unnecessary lol but meh ill comment it anyway
self.hp = OnscreenText(text="HP: " + str(100.0),
pos=(0.95, -0.95),
scale=0.07,
fg=(1, 1, 1, 1),
align=TextNode.ACenter,
mayChange=1)
# Keys array (down if 1, up if 0)
self.keys = {"left": 0, "right": 0, "up": 0, "down": 0, "c": 0, "x": 0}
self.skybox = Skybox(self.showbase)
self.ch = CameraHandler()
# maybe this shit too, or this can stay here and just pass in an array of spells
self.showbase.spell_man = SpellManager(
self.showbase.num_warlocks
) # until the Game() class is created in here which i think it should
for i in self.showbase.spells:
self.showbase.spell_man.add_spell(i)
self.game = Game(self.showbase, game_tick)
self.warlock = self.game.warlock[self.showbase.which]
self.warlock.attach_ring(self.showbase)
self.tick = 0
self.temp_tick = 0
# Set event handlers for keys
self.showbase.accept("escape", sys.exit)
# holding c will focus the camera on clients warlock
self.showbase.accept("c", set_value, [self.keys, "c", 1])
self.showbase.accept("c-up", set_value, [self.keys, "c", 0])
# variable to track which spell has been requested
self.current_spell = -1
# keys to change spell
self.showbase.accept("q", self.set_spell, [0])
self.showbase.accept("w", self.set_spell, [1])
self.showbase.accept("e", self.set_spell, [2])
self.showbase.accept("r", self.set_spell, [3])
# mouse 1 is for casting the spell set by the keys
self.showbase.accept("mouse1", self.cast_spell)
# mouse 3 is for movement, or canceling keys for casting spell
self.showbase.accept("mouse3", self.update_destination)
# sets the camera up behind clients warlock looking down on it from angle
follow = self.warlock.model
self.ch.setTarget(follow.getPos().getX(),
follow.getPos().getY(),
follow.getPos().getZ())
self.ch.turnCameraAroundPoint(follow.getH(), 0)
# Add the game loop procedure to the task manager.
self.showbase.taskMgr.add(self.game_loop, "Game Loop")
def __init__(self, window, camera, options):
''' Constructor '''
# Options
self.options = options
# Register the renderer for control input
self.keys = key.KeyStateHandler()
self.pressedKeys = {}
self.window = window
self.window.push_handlers(self.on_key_press)
self.window.push_handlers(self.on_key_release)
self.window.push_handlers(self.on_mouse_motion)
self.window.push_handlers(self.keys)
# Window size
(szx, szy) = self.window.get_size()
self.windowWidth = szx
self.windowHeight = szy
self.camera = camera
self.time = 0.0
# Ocean Render Parameters
self.wireframe = False
self.oceanDepth = self.options.getfloat('Scene', 'oceandepth')
self.enableUpdates = True
self.oceanWind = Vector2(self.options.getfloat('Scene', 'oceanwindx'),
self.options.getfloat('Scene', 'oceanwindy'))
self.oceanWaveHeight = self.options.getfloat('Scene',
'oceanwaveheight')
self.oceanTileSize = self.options.getint('Scene', 'oceantilesize')
self.oceanTiles = Vector2(self.options.getint('Scene', 'oceantilesx'),
self.options.getint('Scene', 'oceantilesy'))
self.period = self.options.getfloat('Scene', 'period')
self.env_path = self.options.get('Scene', 'env_path')
self.frame = 0
self.skyboxScale = 640.0
self.skyboxOffset = Vector3(0.0, 0.0, 0.0)
# Compile the shader
self.skyboxShader = shader.openfiles('shaders/skybox.vertex',
'shaders/skybox.fragment')
# Renderables
self.scene = []
self.skybox = Skybox(
self.skyboxShader,
self.camera,
self.skyboxScale,
self.skyboxOffset,
xpos_path=self.env_path + '/xpos.tga',
ypos_path=self.env_path + '/ypos.tga',
zpos_path=self.env_path + '/zpos.tga',
xneg_path=self.env_path + '/xneg.tga',
yneg_path=self.env_path + '/yneg.tga',
zneg_path=self.env_path + '/zneg.tga',
)
self.scene.append(self.skybox)
self.ocean = Ocean(self.camera,
cubemap=self.skybox,
depth=self.oceanDepth,
waveHeight=self.oceanWaveHeight,
wind=self.oceanWind,
tileSize=self.oceanTileSize,
tilesX=self.oceanTiles.x,
tilesZ=self.oceanTiles.y,
period=self.period)
self.scene.append(self.ocean)
