def __init__(self):
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
base.disableMouse() # Allow manual positioning of the camera
camera.setPos(0, -10, 1) # Set the cameras' position
camera.setHpr(0, 0, 0) # and orientation
self.keyMap = {"left": 0, "right": 0, "up": 0, "down": 0}
taskMgr.add(self.startCarousel, "moveTask")
imageObject = OnscreenImage(image='env_sky.jpg', pos=(-10, 0, -10))
imageObject.setImage('env_sky.jpg')
imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.loadModels() # Load and position our models
self.setupLights() # Add some basic lighting
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["up", True])
self.accept("arrow_down", self.setKey, ["down", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["up", False])
self.accept("arrow_down-up", self.setKey, ["down", False])
def __init__(self):
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
base.disableMouse() # Allow manual positioning of the camera
camera.setPos(0, -10, 1) # Set the cameras' position
camera.setHpr(0, 0, 0) # and orientation
self.keyMap = {
"left": 0, "right": 0, "up": 0, "down": 0}
taskMgr.add(self.startCarousel, "moveTask")
imageObject = OnscreenImage(image = 'env_sky.jpg', pos = (-10,0,-10))
imageObject.setImage('env_sky.jpg')
imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.loadModels() # Load and position our models
self.setupLights() # Add some basic lighting
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["up", True])
self.accept("arrow_down", self.setKey, ["down", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["up", False])
self.accept("arrow_down-up", self.setKey, ["down", False])
class minimap: #a strategic minimap to display on screen
image = None #the PNMImage
onscreen = None #the OnscreenImage to show mini-map on
texture = None # the texture image is saved to
map = None #the map as represented by a multi-dimensional array of many '1' and '2'.
def __init__(self, map = None):
if map == None: #if no map given, default image size
self.image = PNMImage(256,256)
self.image.fill(0,0,0)
else: #if map given, image is size of map
self.image = PNMImage(len(map[0]), len(map))
self.image.fill(0,0,0)
# self.image.write("minimap.png") #saves the mini-map to hard drive (I just wanted to, not sure if necessary or not.)
self.map = map
self.texture = Texture()
self.texture.load(os.path.join('Glues','minimap.tga'))
self.onscreen = OnscreenImage(image=self.texture,pos=(-1.4,0,-0.81),scale=(0.2,0,0.19))
def createmap(self, map): #updates the map
self.image.clear()
del self.image
self.image = PNMImage(len(map[0]),len(map)) #if map size has changed,
for i in range(0, len(map)):
for me in range(0, len(map[0])):
if map[i][me] == 2:
self.image.setXel( me , len(map)-1 - i , 0,1,0)
if map[i][me] == 1:
self.image.setXel( me , len(map)-1 - i , 0,0,1)
def __update__(self, map): #a update function to be called every frame or every couple.
pass
self.createmap(map) #update map
self.texture.load(self.image) #save map image to texture
self.onscreen.setImage(self.texture) #set onscreenimage to that texture
def destroy(self):
self.onscreen.destroy()
class mainMenu:
def __init__(self, mainMenuState, cameraActive):
# Just try and destroy a menu if it already exists
try:
self.hideMainMenu()
except:
# If nothing exists we create the main menu
self.bk_text = "Welcome to SHENKO"
self.textObject = OnscreenText(text=self.bk_text,
pos=(0.95, -0.95),
scale=0.05,
fg=(0, 1, 1, 1),
bg=(0, 0, 0, .5),
align=TextNode.ACenter,
mayChange=1)
# Draw the Shenko LOGO
self.imageObject = OnscreenImage(image='logo.png',
pos=(0, 0, .6),
scale=0.5)
self.imageObject.setImage('logo.png')
# Menu buttons
rollSound = base.loader.loadSfx("click.ogg")
self.startbttn = DirectButton(text=("start", "---> start <---",
"--> start <--", "disabled"),
pos=(0, 0, .2),
scale=.07,
rolloverSound=rollSound,
command=self.start)
self.mainMenuState = False
print('derp', self.mainMenuState)
def hideMainMenu(self):
print("#---#### ####---#")
#DirectButton.destroy()
self.textObject.destroy() # This is the text lower right of screen
self.imageObject.destroy() # This is the Logo
self.startbttn['state'] = DGG.DISABLED
self.startbttn.destroy()
def start(self):
print("LOADING CENTRAL --------------------------_> ...")
self.hideMainMenu()
class Menu(DirectObject):
def __init__(self):
self.title = OnscreenImage(image = 'img/titleScreen.png', pos = (0, 0, 0) )
self.pointer = OnscreenImage(image = 'img/titleSelector.png', pos = (-.2, 0 ,-.63))
self.pointer.setScale(.05)
self.start = False
self.instructions = False
self.pointerPosition = 1
self.pointer.setTransparency(TransparencyAttrib.MAlpha)
self.accept("enter", self.screenHandler)
self.accept("arrow_up", self.movePointerUp)
self.accept("arrow_down", self.movePointerDown)
self.accept("backspace", self.back)
self.accept("escape", sys.exit)
def screenHandler(self):
if self.pointerPosition == 1:
self.start = True
self.title.destroy()
self.pointer.destroy()
else:
self.instructions = True
self.title.setImage('img/instructions.png')
def back(self):
if self.instructions == True:
self.instructions = False
self.title.setImage('img/titleScreen.png')
self.pointer.setImage('img/titleSelector.png')
def movePointerUp(self):
if self.pointerPosition == 2:
self.pointer.setPos(-.2, 0, -.63)
self.pointerPosition = 1
def movePointerDown(self):
if self.pointerPosition == 1:
self.pointer.setPos(-.2, 0, -.8)
self.pointerPosition = 2
def destroy(self):
self.ignoreAll()
class Drive(ShowBase):
def __init__(self):
ShowBase.__init__(self)
#Setup
scene = BulletWorld()
scene.setGravity(Vec3(0, 0, -9.81))
base.setBackgroundColor(0.6,0.9,0.9)
fog = Fog("The Fog")
fog.setColor(0.9,0.9,1.0)
fog.setExpDensity(0.003)
render.setFog(fog)
#Lighting
#Sun light
sun = DirectionalLight("The Sun")
sun_np = render.attachNewNode(sun)
sun_np.setHpr(0,-60,0)
render.setLight(sun_np)
#Ambient light
amb = AmbientLight("The Ambient Light")
amb.setColor(VBase4(0.39,0.39,0.39, 1))
amb_np = render.attachNewNode(amb)
render.setLight(amb_np)
#Variables
self.gear = 0
self.start = 0
self.Pbrake = 0
self.terrain_var = 1
self.time = 0
self.headlight_var = 0
self.RPM = 0
self.clutch = 0
self.carmaxspeed = 100 #KPH
self.carmaxreversespeed = -40 #KPH
self.steering = 0
#Functions
def V1():
camera.setPos(0.25,-1.2,0.5)
camera.setHpr(0,-13,0)
def V2():
camera.setPos(0,-15,3)
camera.setHpr(0,-10,0)
def V3():
camera.setPos(0,0,9)
camera.setHpr(0,-90,0)
def up():
self.gear = self.gear -1
if self.gear < -1:
self.gear = -1
def down():
self.gear = self.gear +1
if self.gear > 1:
self.gear = 1
def start_function():
self.start = 1
self.start_sound.play()
self.engine_idle_sound.play()
self.RPM = 1000
def stop_function():
self.start = 0
self.engine_idle_sound.stop()
def parkingbrake():
self.Pbrake = (self.Pbrake + 1) % 2
def rotate():
Car_np.setHpr(0, 0, 0)
def horn():
self.horn_sound.play()
def set_time():
if self.time == -1:
sun.setColor(VBase4(0.4, 0.3, 0.3, 1))
base.setBackgroundColor(0.8,0.7,0.7)
if self.time == 0:
sun.setColor(VBase4(0.7, 0.7, 0.7, 1))
base.setBackgroundColor(0.6,0.9,0.9)
if self.time == 1:
sun.setColor(VBase4(0.2, 0.2, 0.2, 1))
base.setBackgroundColor(0.55,0.5,0.5)
if self.time == 2:
sun.setColor(VBase4(0.02, 0.02, 0.05, 1))
base.setBackgroundColor(0.3,0.3,0.3)
if self.time == -2:
self.time = -1
if self.time == 3:
self.time = 2
def time_forward():
self.time = self.time + 1
def time_backward():
self.time = self.time -1
def set_terrain():
if self.terrain_var == 1:
self.ground_model.setTexture(self.ground_tex, 1)
self.ground_model.setScale(3)
if self.terrain_var == 2:
self.ground_model.setTexture(self.ground_tex2, 1)
self.ground_model.setScale(3)
if self.terrain_var == 3:
self.ground_model.setTexture(self.ground_tex3, 1)
self.ground_model.setScale(4)
if self.terrain_var == 4:
self.terrain_var = 1
if self.terrain_var == 0:
self.terrain_var = 3
def next_terrain():
self.terrain_var = self.terrain_var + 1
def previous_terrain():
self.terrain_var = self.terrain_var - 1
def show_menu():
self.menu_win.show()
self.a1.show()
self.a2.show()
self.a3.show()
self.a4.show()
self.t1.show()
self.t2.show()
self.ok.show()
self.exit_button.show()
def hide_menu():
self.menu_win.hide()
self.a1.hide()
self.a2.hide()
self.a3.hide()
self.a4.hide()
self.ok.hide()
self.t1.hide()
self.t2.hide()
self.exit_button.hide()
def Menu():
self.menu_win = OnscreenImage(image = "Textures/menu.png", pos = (0.9,0,0), scale = (0.5))
self.menu_win.setTransparency(TransparencyAttrib.MAlpha)
#The Arrow Buttons
self.a1 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.25), command = previous_terrain)
self.a2 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.25), command = next_terrain)
self.a3 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.0), command = time_backward)
self.a4 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.0), command = time_forward)
#The Text
self.t1 = OnscreenText(text = "Terrain", pos = (0.85,0.25,0), scale = 0.1, fg = (0.4,0.4,0.5,1))
self.t2 = OnscreenText(text = "Time", pos = (0.85,0,0), scale = 0.1, fg = (0.4,0.4,0.5,1))
#The Buttons
self.ok = DirectButton(text = "Okay", scale = 0.11, pos = (0.87,0,-0.25), command = hide_menu)
self.exit_button = DirectButton(text = "Quit", scale = 0.11, pos = (0.87,0,-0.42), command = sys.exit)
Menu()
def take_screenshot():
base.screenshot("Screenshot")
def set_headlights():
if self.headlight_var == 1:
Headlight1.setColor(VBase4(9.0,8.9,8.9,1))
Headlight2.setColor(VBase4(9.0,8.9,8.9,1))
if self.headlight_var == 0:
Headlight1.setColor(VBase4(0,0,0,1))
Headlight2.setColor(VBase4(0,0,0,1))
def headlights():
self.headlight_var = (self.headlight_var + 1) % 2
def update_rpm():
#Simulate RPM
if self.start == 1:
if self.gear == 0:
self.RPM = self.RPM - self.RPM / 400
else:
self.RPM = self.RPM + self.carspeed / 9
self.RPM = self.RPM - self.RPM / 200
#Reset RPM to 0 when engine is off
if self.start == 0:
if self.RPM > 0.0:
self.RPM = self.RPM - 40
if self.RPM < 10:
self.RPM = 0.0
#Idle RPM power
if self.start == 1:
if self.RPM < 650:
self.RPM = self.RPM + 4
if self.RPM < 600:
self.clutch = 1
else:
self.clutch = 0
#RPM limit
if self.RPM > 6000:
self.RPM = 6000
#Controls
inputState.watchWithModifiers("F", "arrow_up")
inputState.watchWithModifiers("B", "arrow_down")
inputState.watchWithModifiers("L", "arrow_left")
inputState.watchWithModifiers("R", "arrow_right")
do = DirectObject()
do.accept("escape", show_menu)
do.accept("1", V1)
do.accept("2", V2)
do.accept("3", V3)
do.accept("page_up", up)
do.accept("page_down", down)
do.accept("x-repeat", start_function)
do.accept("x", stop_function)
do.accept("p", parkingbrake)
do.accept("backspace", rotate)
do.accept("enter", horn)
do.accept("f12", take_screenshot)
do.accept("h", headlights)
#The ground
self.ground = BulletPlaneShape(Vec3(0, 0, 1,), 1)
self.ground_node = BulletRigidBodyNode("The ground")
self.ground_node.addShape(self.ground)
self.ground_np = render.attachNewNode(self.ground_node)
self.ground_np.setPos(0, 0, -2)
scene.attachRigidBody(self.ground_node)
self.ground_model = loader.loadModel("Models/plane.egg")
self.ground_model.reparentTo(render)
self.ground_model.setPos(0,0,-1)
self.ground_model.setScale(3)
self.ground_tex = loader.loadTexture("Textures/ground.png")
self.ground_tex2 = loader.loadTexture("Textures/ground2.png")
self.ground_tex3 = loader.loadTexture("Textures/ground3.png")
self.ground_model.setTexture(self.ground_tex, 1)
#The car
Car_shape = BulletBoxShape(Vec3(1, 2.0, 1.0))
Car_node = BulletRigidBodyNode("The Car")
Car_node.setMass(1200.0)
Car_node.addShape(Car_shape)
Car_np = render.attachNewNode(Car_node)
Car_np.setPos(0,0,3)
Car_np.setHpr(0,0,0)
Car_np.node().setDeactivationEnabled(False)
scene.attachRigidBody(Car_node)
Car_model = loader.loadModel("Models/Car.egg")
Car_model.reparentTo(Car_np)
Car_tex = loader.loadTexture("Textures/Car1.png")
Car_model.setTexture(Car_tex, 1)
self.Car_sim = BulletVehicle(scene, Car_np.node())
self.Car_sim.setCoordinateSystem(ZUp)
scene.attachVehicle(self.Car_sim)
#The inside of the car
Car_int = loader.loadModel("Models/inside.egg")
Car_int.reparentTo(Car_np)
Car_int_tex = loader.loadTexture("Textures/inside.png")
Car_int.setTexture(Car_int_tex, 1)
Car_int.setTransparency(TransparencyAttrib.MAlpha)
#The steering wheel
Sw = loader.loadModel("Models/Steering wheel.egg")
Sw.reparentTo(Car_np)
Sw.setPos(0.25,0,-0.025)
#The first headlight
Headlight1 = Spotlight("Headlight1")
lens = PerspectiveLens()
lens.setFov(180)
Headlight1.setLens(lens)
Headlight1np = render.attachNewNode(Headlight1)
Headlight1np.reparentTo(Car_np)
Headlight1np.setPos(-0.8,2.5,-0.5)
Headlight1np.setP(-15)
render.setLight(Headlight1np)
#The second headlight
Headlight2 = Spotlight("Headlight2")
Headlight2.setLens(lens)
Headlight2np = render.attachNewNode(Headlight2)
Headlight2np.reparentTo(Car_np)
Headlight2np.setPos(0.8,2.5,-0.5)
Headlight2np.setP(-15)
render.setLight(Headlight2np)
#Sounds
self.horn_sound = loader.loadSfx("Sounds/horn.ogg")
self.start_sound = loader.loadSfx("Sounds/enginestart.ogg")
self.engine_idle_sound = loader.loadSfx("Sounds/engineidle.ogg")
self.engine_idle_sound.setLoop(True)
self.accelerate_sound = loader.loadSfx("Sounds/enginethrottle.ogg")
#Camera
base.disableMouse()
camera.reparentTo(Car_np)
camera.setPos(0,-15,3)
camera.setHpr(0,-10,0)
#Wheel function
def Wheel(pos, np, r, f):
w = self.Car_sim.createWheel()
w.setNode(np.node())
w.setChassisConnectionPointCs(pos)
w.setFrontWheel(f)
w.setWheelDirectionCs(Vec3(0, 0, -1))
w.setWheelAxleCs(Vec3(1, 0, 0))
w.setWheelRadius(r)
w.setMaxSuspensionTravelCm(40)
w.setSuspensionStiffness(120)
w.setWheelsDampingRelaxation(2.3)
w.setWheelsDampingCompression(4.4)
w.setFrictionSlip(50)
w.setRollInfluence(0.1)
#Wheels
w1_np = loader.loadModel("Models/Lwheel")
w1_np.reparentTo(render)
w1_np.setColorScale(0,6)
Wheel(Point3(-1,1,-0.6), w1_np, 0.4, False)
w2_np = loader.loadModel("Models/Rwheel")
w2_np.reparentTo(render)
w2_np.setColorScale(0,6)
Wheel(Point3(-1.1,-1.2,-0.6), w2_np, 0.4, True)
w3_np = loader.loadModel("Models/Lwheel")
w3_np.reparentTo(render)
w3_np.setColorScale(0,6)
Wheel(Point3(1.1,-1,-0.6), w3_np, 0.4, True)
w4_np = loader.loadModel("Models/Rwheel")
w4_np.reparentTo(render)
w4_np.setColorScale(0,6)
Wheel(Point3(1,1,-0.6), w4_np, 0.4, False)
#The engine and steering
def processInput(dt):
#Vehicle properties
self.steeringClamp = 35.0
self.steeringIncrement = 70
engineForce = 0.0
brakeForce = 0.0
#Get the vehicle's current speed
self.carspeed = self.Car_sim.getCurrentSpeedKmHour()
#Engage clutch when in gear 0
if self.gear == 0:
self.clutch = 1
#Slow the steering when at higher speeds
self.steeringIncrement = self.steeringIncrement - self.carspeed / 1.5
#Reset the steering
if not inputState.isSet("L") and not inputState.isSet("R"):
if self.steering < 0.00:
self.steering = self.steering + 0.6
if self.steering > 0.00:
self.steering = self.steering - 0.6
if self.steering < 1.0 and self.steering > -1.0:
self.steering = 0
#Slow the car down while it's moving
if self.clutch == 0:
brakeForce = brakeForce + self.carspeed / 5
else:
brakeForce = brakeForce + self.carspeed / 15
#Forward
if self.start == 1:
if inputState.isSet("F"):
self.RPM = self.RPM + 35
self.accelerate_sound.play()
if self.clutch == 0:
if self.gear == -1:
if self.carspeed > self.carmaxreversespeed:
engineForce = -self.RPM / 3
if self.gear == 1:
if self.carspeed < self.carmaxspeed:
engineForce = self.RPM / 1
#Brake
if inputState.isSet("B"):
engineForce = 0.0
brakeForce = 12.0
if self.gear != 0 and self.clutch == 0:
self.RPM = self.RPM - 20
#Left
if inputState.isSet("L"):
if self.steering < 0.0:
#This makes the steering reset at the correct speed when turning from right to left
self.steering += dt * self.steeringIncrement + 0.6
self.steering = min(self.steering, self.steeringClamp)
else:
#Normal steering
self.steering += dt * self.steeringIncrement
self.steering = min(self.steering, self.steeringClamp)
#Right
if inputState.isSet("R"):
if self.steering > 0.0:
#This makes the steering reset at the correct speed when turning from left to right
self.steering -= dt * self.steeringIncrement + 0.6
self.steering = max(self.steering, -self.steeringClamp)
else:
#Normal steering
self.steering -= dt * self.steeringIncrement
self.steering = max(self.steering, -self.steeringClamp)
#Park
if self.Pbrake == 1:
brakeForce = 10.0
if self.gear != 0 and self. clutch == 0:
self.RPM = self.RPM - 20
#Apply forces to wheels
self.Car_sim.applyEngineForce(engineForce, 0);
self.Car_sim.applyEngineForce(engineForce, 3);
self.Car_sim.setBrake(brakeForce, 1);
self.Car_sim.setBrake(brakeForce, 2);
self.Car_sim.setSteeringValue(self.steering, 0);
self.Car_sim.setSteeringValue(self.steering, 3);
#Steering wheel
Sw.setHpr(0,0,-self.steering*10)
#The HUD
self.gear_hud = OnscreenImage(image = "Textures/gear_hud.png", pos = (-1,0,-0.85), scale = (0.2))
self.gear_hud.setTransparency(TransparencyAttrib.MAlpha)
self.gear2_hud = OnscreenImage(image = "Textures/gear2_hud.png", pos = (-1,0,-0.85), scale = (0.2))
self.gear2_hud.setTransparency(TransparencyAttrib.MAlpha)
self.starter = OnscreenImage(image = "Textures/starter.png", pos = (-1.2,0,-0.85), scale = (0.15))
self.starter.setTransparency(TransparencyAttrib.MAlpha)
self.park = OnscreenImage(image = "Textures/pbrake.png", pos = (-0.8,0,-0.85), scale = (0.1))
self.park.setTransparency(TransparencyAttrib.MAlpha)
self.rev_counter = OnscreenImage(image = "Textures/dial.png", pos = (-1.6, 0.0, -0.70), scale = (0.6,0.6,0.4))
self.rev_counter.setTransparency(TransparencyAttrib.MAlpha)
self.rev_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.6, 0.0, -0.70), scale = (0.5))
self.rev_needle.setTransparency(TransparencyAttrib.MAlpha)
self.rev_text = OnscreenText(text = " ", pos = (-1.6, -0.90, 0), scale = 0.05)
self.speedometer = OnscreenImage(image = "Textures/dial.png", pos = (-1.68, 0.0, -0.10), scale = (0.7,0.7,0.5))
self.speedometer.setTransparency(TransparencyAttrib.MAlpha)
self.speedometer_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.68, 0.0, -0.10), scale = (0.5))
self.speedometer_needle.setTransparency(TransparencyAttrib.MAlpha)
self.speedometer_text = OnscreenText(text = " ", pos = (-1.68, -0.35, 0), scale = 0.05)
#Update the HUD
def Update_HUD():
#Move gear selector
if self.gear == -1:
self.gear2_hud.setPos(-1,0,-0.785)
if self.gear == 0:
self.gear2_hud.setPos(-1,0,-0.85)
if self.gear == 1:
self.gear2_hud.setPos(-1,0,-0.91)
#Rotate starter
if self.start == 0:
self.starter.setHpr(0,0,0)
else:
self.starter.setHpr(0,0,45)
#Update the parking brake light
if self.Pbrake == 1:
self.park.setImage("Textures/pbrake2.png")
self.park.setTransparency(TransparencyAttrib.MAlpha)
else:
self.park.setImage("Textures/pbrake.png")
self.park.setTransparency(TransparencyAttrib.MAlpha)
#Update the rev counter
self.rev_needle.setR(self.RPM/22)
rev_string = str(self.RPM)[:4]
self.rev_text.setText(rev_string+" RPM")
#Update the speedometer
if self.carspeed > 0.0:
self.speedometer_needle.setR(self.carspeed*2.5)
if self.carspeed < 0.0:
self.speedometer_needle.setR(-self.carspeed*2.5)
speed_string = str(self.carspeed)[:3]
self.speedometer_text.setText(speed_string+" KPH")
#Update the program
def update(task):
dt = globalClock.getDt()
processInput(dt)
Update_HUD()
set_time()
set_terrain()
set_headlights()
update_rpm()
scene.doPhysics(dt, 5, 1.0/180.0)
return task.cont
taskMgr.add(update, "Update")
class MainMenu(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.accept("Exit",self.__exit)
self.__rm = ResourcesManager()
self.__destroySetting = False
# 菜单界面
def start(self):
#全屏
self.setFullScreen(0)
#load background image
self.__image = OnscreenImage(image='../../resources/images/menu/home1.png',scale=1)
self.__image.setSx(self.getAspectRatio())
self.__image.setTransparency(TransparencyAttrib.MAlpha)
# 监听输入
self.__keyInput = MenuPlayerInputHandler()
self.accept("NewGame",self.__new_game)
self.accept("LoadGame",self.__load_game)
self.accept("Description",self.__description)
self.accept("ChangeMenu",self.__change_menu)
self.accept("a",self.setting_menu)
self.accept("b",self.setting_destroy)
# 设置全屏
def setFullScreen(self,full):
if full == 1 :
self.__setFullscreen(2560,1600,0,0,1)
else:
self.__setFullscreen(800,600,150,50,0)
# 清除界面，清除监听
def destroy(self):
self.__image.destroy()
self.__keyInput.destroy()
# 私有函数，选择全屏
def __setFullscreen(self, width, height, posX, posY, full):
winProps = WindowProperties()
winProps.setOrigin(posX, posY)
winProps.setSize(width, height)
winProps.setFullscreen(full)
self.win.requestProperties(winProps)
# 私有函数，进入新建游戏界面
def __new_game(self):
print '进入new game'
messenger.send("serious_new_game")
print '发送了serious_new_game'
# 私有函数，进入读取游戏界面
def __load_game(self):
print '进入load game'
messenger.send("serious_load_game")
print '发送了serious_load_game'
# 私有函数，进入about界面
def __description(self):
print '进入description'
messenger.send("serious_description")
print '发送了serious_description'
# 私有函数，用来自建的选择进入的游戏界面
def __change_mode(self,image_path):
self.__image.setImage(image_path)
def __exit(self):
print '进入exit'
# self.__del__()
exit()
# 私有函数，更改游戏目录
def __change_menu(self):
switch_count = {0:'../../resources/images/menu/home1.png',
1:'../../resources/images/menu/home2.png',
2:'../../resources/images/menu/home3.png',
3:'../../resources/images/menu/home4.png',}
self.__change_mode(switch_count[self.__keyInput.get_count()])
#设置界面
def setting_menu(self):
if self.__destroySetting==False:
# 设置界面背景图
self.__background = OnscreenImage(image='../../resources/images/settings/setting_frame.png', pos=(0, 0, 0),
scale=(1.0, 0, 0.7))
self.__background.setTransparency(TransparencyAttrib.MAlpha)
##滑动条
self.__slider = DirectSlider(pos=(0.16, 0, 0.26), scale=0.5, value=0.5, command=self.__setMusicSliderVolume,
frameSize=(-1.0, 0.9, -0.06, 0.06),
image='../../resources/images/settings/slide_bar.png',
image_pos=(-0.05, 0, 0.0), image_scale=(1.0, 0, 0.05),
thumb_image='../../resources/images/settings/slide_btn.png',
thumb_image_pos=(-0.0, 0, 0.0), thumb_image_scale=0.1,
thumb_frameSize=(0.0, 0.0, 0.0, 0.0))
self.__slider.setTransparency(TransparencyAttrib.MAlpha)
# self.__musicButton = DirectButton(pos=(0.9, 0, 0.75), text="Close", scale=0.1, pad=(0.2, 0.2), rolloverSound=None,
# clickSound=None, command=self.toggleMusicBox,extraArgs=[base])
# 继续按钮
self.__continueButton = DirectButton(pos=(-0.25, 0, 0.0), text="", scale=(0.2, 0, 0.1),
command=self.__continue_game,
image=("../../resources/images/settings/btn_continue_0.png",
"../../resources/images/settings/btn_continue_0.png"
, "../../resources/images/settings/btn_continue_1.png"),
frameColor=(0, 0, 0, 0))
self.__continueButton.setTransparency(TransparencyAttrib.MAlpha)
# 存档按钮
self.__saveButton = DirectButton(pos=(0.33, 0, 0.0), text="", scale=(0.2, 0, 0.1), command=self.__save_game,
image=("../../resources/images/settings/btn_save_0.png",
"../../resources/images/settings/btn_save_0.png"
, "../../resources/images/settings/btn_save_1.png"),
frameColor=(0, 0, 0, 0))
self.__saveButton.setTransparency(TransparencyAttrib.MAlpha)
# 帮助按钮
self.__helpButton = DirectButton(pos=(-0.25, 0, -0.25), text="", scale=(0.2, 0, 0.1), command=self.__help,
image=("../../resources/images/settings/btn_help_0.png",
"../../resources/images/settings/btn_help_0.png"
, "../../resources/images/settings/btn_help_1.png"),
frameColor=(0, 0, 0, 0))
self.__helpButton.setTransparency(TransparencyAttrib.MAlpha)
# 回到主界面按钮
self.__homeButton = DirectButton(pos=(0.33, 0, -0.25), text="", scale=(0.2, 0, 0.1), command=self.__return_home,
image=("../../resources/images/settings/btn_home_0.png",
"../../resources/images/settings/btn_home_0.png"
, "../../resources/images/settings/btn_home_1.png"),
frameColor=(0, 0, 0, 0))
self.__homeButton.setTransparency(TransparencyAttrib.MAlpha)
# 设置滑动条value
self.__slider['value'] = self.__rm.get_volume()
self.__destroySetting = True
#移除设置界面所有控件
def setting_destroy(self):
if self.__destroySetting==True:
self.__background.destroy()
self.__rm.set_volume(self.__slider['value'])
self.__slider.destroy()
# self.__musicButton.destroy()
self.__continueButton.destroy()
self.__saveButton.destroy()
self.__helpButton.destroy()
self.__homeButton.destroy()
self.__destroySetting = False
# 设置音乐声音大小
def __setMusicSliderVolume(self):
newVolume = self.__slider.guiItem.getValue()
self.__rm.set_volume(newVolume)
# 设置界面，私有函数,继续游戏
def __continue_game(self):
self.setting_destroy()
# 设置界面，私有函数,存档
def __save_game(self):
self.setting_destroy()
# 设置界面，私有函数,游戏帮助
def __help(self):
self.setting_destroy()
# 设置界面，私有函数,回到主界面
def __return_home(self):
self.setting_destroy()
class ImagePresenter(MessagePresenter):
"""
A display that can present images with a fixed (or optionally randomly chosen) position,
size and other display properties (e.g. coloring).
See also MessagePresenter for usage information.
"""
def __init__(self,
pos=(-0.25,0.5), # position of the image center in the aspect2d viewport
# may also be a callable object (e.g.a draw from a random number generator)
scale=0.2, # scaling of the image; may also be callable
rotation=(0,0,0), # yaw, pitch, roll -- the most relevant is the roll coordinate; may also be callable
color=(1,1,1,1), # (r,g,b,a) image color
renderviewport=None, # the parent viewport if desired
image='blank.tga', # the initial image to present
*args,**kwargs
):
"""Construct a new ImagePresenter."""
MessagePresenter.__init__(self,*args,**kwargs)
self.pos = pos
self.scale = scale
self.rotation = rotation
self.color = color
self.renderviewport = renderviewport
# set up the text panel...
#if not (type(self.pos) is List or type(self.pos) is tuple):
#pos = self.pos()
#if callable(self.scale):
#scale = self.scale()
#if callable(self.rotation):
#rotation = self.rotation()
#if callable(self.color):
#color = self.color()
self.icon = OnscreenImage(image=image,pos=(pos[0],0,pos[1]),scale=scale,hpr=rotation,color= ((0,0,0,0) if image=="blank.tga" else self.color),parent=self.renderviewport)
self.icon.setTransparency(TransparencyAttrib.MAlpha)
def _present(self,message):
self.icon.setImage(message.strip())
self.icon.setTransparency(TransparencyAttrib.MAlpha)
# select remaining properties randomly, if applicable
# if callable(self.pos):
# p = self.pos()
# self.icon.setPos(p[0],p[1],p[2])
# if callable(self.scale):
# self.icon.setScale(self.scale())
# if callable(self.rotation):
# rot = self.rotation()
# self.icon.setHpr(rot[0],rot[1],rot[2])
col = self.color #() if callable(self.color) else self.color
self.icon.setColor(col[0],col[1],col[2],col[3])
self.marker(222)
def _unpresent(self):
try:
self.marker(223)
self.icon.setColor(0,0,0,0)
except:
pass
def destroy(self):
self.icon.removeNode()
def precache(self,message):
loader.loadTexture(message)
class Game(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# режим редактирования
self.edit_mode = True
# создаём менеджер карты
self.map_manager = MapManager()
# создаём контроллер мышки и клавиатуры
self.controller = Controller()
# создаём редактор
self.editor = Editor(self.map_manager)
# загружаем картинку курсора
self.pointer = OnscreenImage(image='target.png',
pos=(0, 0, 0),
scale=0.08)
# устанавливаем прозрачность
self.pointer.setTransparency(TransparencyAttrib.MAlpha)
# имя файла для сохранения и загрузки карт
self.file_name = "my_map.dat"
self.accept("f1", self.basicMap)
self.accept("f2", self.generateRandomMap)
self.accept("f3", self.saveMap)
self.accept("f4", self.loadMap)
print("'f1' - создать базовую карту")
print("'f2' - создать случайную карту")
print("'f3' - сохранить карту")
print("'f4' - загрузить карту")
# зарегистрируйте на события нажатия клавиш
# "0", "1", "2" ... "9" метод установки цвета
# ...
self.accept("z", self.map_manager.settex)
self.accept("x", self.map_manager.tchange)
self.accept("1", self.setcolor, [(1, 1, 1, 1)])
self.accept("2", self.setcolor, [(0.3, 1, 0.3, 1)])
#self.accept("3",self.setcolor,[()])
base.accept("tab", self.switchEditMode)
# генерируем случайный уровень
self.generateRandomMap()
def basicMap(self):
if not self.edit_mode:
self.controller.setEditMode(self.edit_mode)
self.map_manager.basicMap()
print('Basic map generated')
def generateRandomMap(self):
if not self.edit_mode:
self.controller.setEditMode(self.edit_mode)
self.map_manager.generateRandomMap()
print('Random map generated')
def saveMap(self):
self.map_manager.saveMap(self.file_name)
print('Map saved to "' + self.file_name + '"')
def loadMap(self):
if not self.edit_mode:
self.controller.setEditMode(self.edit_mode)
self.map_manager.loadMap(self.file_name)
print('Map loaded from "' + self.file_name + '"')
# добавьте метод установки цвета
# ...
def setcolor(self, color):
if self.edit_mode:
self.map_manager.setColor(color)
# если установлен режим редактирования
# ...
# вызовите метод setColor менеджера карты
# ...
def switchEditMode(self):
self.edit_mode = not self.edit_mode
self.controller.setEditMode(self.edit_mode)
self.editor.setEditMode(self.edit_mode)
if self.edit_mode:
self.pointer.setImage(image='target.png')
else:
self.pointer.setImage(image='target1.png')
self.pointer.setTransparency(TransparencyAttrib.MAlpha)
class ImagePresenter(MessagePresenter):
"""
A display that can present images with a fixed (or optionally randomly chosen) position,
size and other display properties (e.g. coloring).
See also MessagePresenter for usage information.
"""
def __init__(
self,
pos=(-0.25,
0.5), # position of the image center in the aspect2d viewport
# may also be a callable object (e.g.a draw from a random number generator)
scale=0.2, # scaling of the image; may also be callable
rotation=(
0, 0, 0
), # yaw, pitch, roll -- the most relevant is the roll coordinate; may also be callable
color=(1, 1, 1, 1), # (r,g,b,a) image color
renderviewport=None, # the parent viewport if desired
image='blank.tga', # the initial image to present
*args,
**kwargs):
"""Construct a new ImagePresenter."""
MessagePresenter.__init__(self, *args, **kwargs)
self.pos = pos
self.scale = scale
self.rotation = rotation
self.color = color
self.renderviewport = renderviewport
# set up the text panel...
#if not (type(self.pos) is List or type(self.pos) is tuple):
#pos = self.pos()
#if callable(self.scale):
#scale = self.scale()
#if callable(self.rotation):
#rotation = self.rotation()
#if callable(self.color):
#color = self.color()
self.icon = OnscreenImage(
image=image,
pos=(pos[0], 0, pos[1]),
scale=scale,
hpr=rotation,
color=((0, 0, 0, 0) if image == "blank.tga" else self.color),
parent=self.renderviewport)
self.icon.setTransparency(TransparencyAttrib.MAlpha)
def _present(self, message):
self.icon.setImage(message.strip())
self.icon.setTransparency(TransparencyAttrib.MAlpha)
# select remaining properties randomly, if applicable
# if callable(self.pos):
# p = self.pos()
# self.icon.setPos(p[0],p[1],p[2])
# if callable(self.scale):
# self.icon.setScale(self.scale())
# if callable(self.rotation):
# rot = self.rotation()
# self.icon.setHpr(rot[0],rot[1],rot[2])
col = self.color #() if callable(self.color) else self.color
self.icon.setColor(col[0], col[1], col[2], col[3])
self.marker(222)
def _unpresent(self):
try:
self.marker(223)
self.icon.setColor(0, 0, 0, 0)
except:
pass
def destroy(self):
self.icon.removeNode()
def precache(self, message):
loader.loadTexture(message)
class ControlScreen(DirectObject.DirectObject):
"""
Class that represents the main ControlScreen
"""
def __init__(self, gameEngine):
DirectObject.DirectObject.__init__(self)
self.gameEngine = gameEngine
self.elements = []
self.font = gameEngine.loader.loadFont(
self.gameEngine.params("font_path") +
self.gameEngine.params("default_font"))
iH = PNMImageHeader()
self.image_path = self.gameEngine.params("control_screen_image_path")
iH.readHeader(Filename(self.image_path + "screen.png"))
self._x0 = 2 / iH.get_x_size()
self._y0 = 2 / iH.get_y_size()
# setting 16/9 screen
self.props = WindowProperties()
self.props.set_size((1024, 576))
self.window = self.gameEngine.win
self.window.requestProperties(self.props)
self.gui_camera = self.gameEngine.cam2d
# this could be simply removed
self.gui_render_node = self.gui_camera
self.lens = self.gui_camera.node().getLens()
self.fg_color = LVector4f(0.3, 0.26, 0.227, 1.0)
self.fg_color_red = LVector4f(0.709, 0.180, 0.090, 1.0)
self.fg_color_green = LVector4f(0.501, 0.807, 0.337, 1.0)
self.background_image = OnscreenImage(image=self.image_path +
"default.png",
pos=(0, 0, 0),
sort=5,
parent=self.gui_render_node)
self._previous_screen = None
self._keyboard_hardware_map = read_ini_file(
self.gameEngine.params("hardware_keyboard_map_file"))
self.current_screen = None
self.on_screen_info = InfoOverScreen(self)
self.enter_func = None
self.limited_update = self.gameEngine.params(
"control_screen_limited_refresh")
if not self.limited_update:
self.window.setActive(True)
else:
self.update()
def gimp_pos(self, xg, yg):
"""
Returns the screen coordinates fro initial Gimp positions in the image
@param xg: the x position on Gimp
@param yg: the y position on Gimp
@return:
"""
return (-1 + xg * self._x0, 1 - yg * self._y0)
def set_background_image(self, name, extension='.png'):
"""
Changes the background image
@param name: the file name without extension
@param extension: the file extension.
"""
self.background_image.setImage(self.image_path + name + extension)
def info_text(self, text, close_time=10):
"""
Text popup screen. This screen can be closed by pressing 'enter' key
@param text: The text to display
@param close_time: the life time of the popup in seconds.
"""
self.gameEngine.sound_manager.play("gui_open")
self.on_screen_info.set_text(text)
self.on_screen_info.show()
self.gameEngine.update_soft_state("info_text", True)
def _end(t=None):
if self.on_screen_info.is_on_screen():
self.gameEngine.sound_manager.play("gui_close")
self.on_screen_info.hide()
self.gameEngine.update_soft_state("info_text", False)
if self.enter_func is not None:
self.accept("enter", self.enter_func)
else:
self.ignore("enter")
self.accept("enter", _end)
self.request_focus()
if close_time is not None:
self.gameEngine.taskMgr.doMethodLater(close_time,
_end,
name="end_info")
def event(self, message, **kwargs):
"""
Send an event to the screen.
@param message: the event name
@param kwargs: the assocaited parameters.
"""
if message == "crew_lock_screen":
self._previous_screen = message
self.listen_to_keyboard()
self.gameEngine.update_soft_state("listen_to_hardware", False)
if self.current_screen is not None:
self.current_screen.destroy()
self.current_screen = LockScreen(self,
kwargs.get("num_player", None))
elif message == "default_screen":
self._previous_screen = message
self.reject_keyboard()
self.gameEngine.update_soft_state("listen_to_hardware", True)
self.gameEngine.sound_manager.stop("alarm")
self.gameEngine.sound_manager.play("screen_intro")
if self.current_screen is not None:
self.current_screen.destroy()
self.current_screen = MainScreen(self)
elif message == "alert_screen":
self._previous_screen = message
self.listen_to_keyboard()
self.gameEngine.update_soft_state("listen_to_hardware", False)
if self.current_screen is not None:
self.current_screen.destroy()
self.current_screen = AlertScreen(self)
elif message == "target_screen":
self._previous_screen = message
self.gameEngine.update_soft_state("listen_to_hardware", False)
self.listen_to_keyboard()
if self.current_screen is not None:
self.current_screen.destroy()
self.current_screen = TargetScreen(self)
elif message == "image_screen":
self._previous_screen = message
self.reject_keyboard()
if self.current_screen is not None:
self.current_screen.destroy()
self.current_screen = ImageScreen(
self, kwargs.get("image_name", "default"))
elif message == "image_screen_text":
if isinstance(self.current_screen, ImageScreen):
self.current_screen.show_text(kwargs.get("text", ""),
size=kwargs.get("size", 1),
pos_x=kwargs.get("pos_x", 0.0),
pos_y=kwargs.get("pos_y", 0.0),
color=kwargs.get("color", None),
alpha_time=kwargs.get(
"alpha_time", 0.0))
elif message == "set_gauge_goto_time" and isinstance(
self.current_screen, MainScreen):
gauge = self.current_screen.gauges.get(kwargs.get("gauge", None),
None)
time = kwargs.get("time", None)
if gauge is not None and time is not None:
gauge.set_time_for_goto(time)
elif message == 'update_state' and isinstance(self.current_screen,
MainScreen):
key = kwargs.get("key", None)
if key is not None:
self.current_screen.set_element(key)
else:
self.current_screen.set_all_elements()
def set_previous_screen(self):
"""
Resets the previous screen
"""
self.event(self._previous_screen)
def request_focus(self):
"""
Request the focus. Seems to be useless
"""
self.props.setForeground(True)
self.window.requestProperties(self.props)
self.update()
def set_single_window(self,
screen_numbers=5,
res_x=1920,
res_y=1080,
decorated=False,
pos=None):
"""
If the game works in single window (much faster), enlarges the screen and allocates a fraction of it to the ControlScreen
@param screen_numbers: the numbers of simulated screens (including the ControlScreen)
@param res_x: the x resolution of each screen
@param res_y: the y resolution of each screen
@param decorated: if the window should be decorated or not
"""
# setting the main window
self.props.set_size((screen_numbers * res_x, res_y))
self.props.set_origin((0, 0) if pos is None else tuple(pos))
self.props.setUndecorated(not decorated)
self.window.requestProperties(self.props)
# setting the dimensions of the gui display region
for dr in self.window.get_display_regions():
cam = dr.get_camera()
if cam and "cam2d" in cam.name:
dr.set_dimensions(0, 1 / screen_numbers, 0, 1)
self.update()
def set_fullscreen(self):
"""
Sets this screen in fullscreen mode.
"""
res = get_screen_resolutions()[0]
self.props.set_size(res)
self.props.setFullscreen(True)
self.lens.setAspectRatio(float(res[1] / res[0]))
self.window.requestProperties(self.props)
self.update()
def listen_to_keyboard(self):
"""
Allows to listen to the keyboard. Maps keys to the corresponding chars.
"""
self.request_focus()
self.reject_keyboard(False)
if self.gameEngine.params("fulfill_current_step_key_with_F1"):
self.accept('f1', self.gameEngine.scenario.fulfill_current_step)
char_list = string.printable
for char in char_list[:10]:
self.accept(char, self.input_text, extraArgs=[char])
for i, char in enumerate(char_list[10:36]):
self.accept(char, self.input_text, extraArgs=[char])
self.accept("shift-" + char,
self.input_text,
extraArgs=[char_list[i + 36]])
# dot
self.accept('.', self.input_text, extraArgs=['.'])
self.accept("backspace", self.input_text, extraArgs=['back'])
self.accept("enter", self.input_text, extraArgs=['enter'])
self.enter_func = lambda: self.input_text("enter")
def keyboard_as_shuttle_control(self):
"""
Sets the keyboard as a shuttle controller.
"""
self.request_focus()
self.reject_keyboard(False)
self.accept('arrow_up', self.gameEngine.shuttle.boost, extraArgs=['f'])
self.accept('arrow_down',
self.gameEngine.shuttle.boost,
extraArgs=['b'])
self.accept('arrow_right',
self.gameEngine.shuttle.boost,
extraArgs=['r'])
self.accept('arrow_left',
self.gameEngine.shuttle.boost,
extraArgs=['l'])
self.accept('+', self.gameEngine.shuttle.boost, extraArgs=['pp'])
self.accept('-', self.gameEngine.shuttle.boost, extraArgs=['pm'])
self.accept('space', self.gameEngine.shuttle.stop)
self.accept('enter',
lambda: print(self.gameEngine.shuttle.frame.get_pos()))
self.accept('backspace', self.gameEngine.reset_game, extraArgs=[True])
self.enter_func = lambda: print(self.gameEngine.shuttle.frame.get_pos(
))
for key in ['x', 'y', 'z']:
self.accept(key,
self.gameEngine.shuttle.align_along,
extraArgs=[key])
def keyboard_as_hardware(self):
"""
Sets the keyboard as a simulated hardware. The mapping is defined in the keyboard_hardware file.
"""
self.request_focus()
self.reject_keyboard(False)
for key in self._keyboard_hardware_map:
name = self._keyboard_hardware_map[key]
if key == "enter":
self.enter_func = lambda: self.gameEngine.update_hard_state[
name]
if name.startswith('j_'):
self.accept(key,
self.gameEngine.update_hard_state,
extraArgs=[name, 1])
self.accept('shift-' + key,
self.gameEngine.update_hard_state,
extraArgs=[name, -1])
self.accept(key + '-up',
self.gameEngine.update_hard_state,
extraArgs=[name, 0])
elif name.startswith('b_'):
self.accept(key,
self.gameEngine.update_hard_state,
extraArgs=[name, True])
self.accept(key + '-up',
self.gameEngine.update_hard_state,
extraArgs=[name, False])
else:
self.accept(key, self._switch_state, extraArgs=[name])
def reject_keyboard(self, connect_alternative=True):
"""
Ignore all keyboard inputs.
@param connect_alternative: if True, reads the params of the game and sets the keyboard on shuttle_control or hardware_control
"""
self.ignore_all()
if self.gameEngine.params("fulfill_current_step_key_with_F1"):
self.accept('f1', self.gameEngine.scenario.fulfill_current_step)
if connect_alternative:
if self.gameEngine.params("keyboard_simulates_hardware"):
self.keyboard_as_hardware()
elif self.gameEngine.params("keyboard_controls_shuttle"):
self.keyboard_as_shuttle_control()
def _switch_state(self, key):
if self.gameEngine.get_hard_state(key):
self.gameEngine.update_hard_state(key, False)
else:
self.gameEngine.update_hard_state(key, True)
def update(self):
"""
Updates the window when this window is not active (for saving FPS).
"""
if self.limited_update:
self.window.setActive(True)
self.gameEngine.graphicsEngine.render_frame()
self.window.setActive(False)
else:
pass
def input_text(self, textEntered):
"""
Transmitting keyboard inputs.
@param textEntered: string. Sent from the shuttle object.
"""
self.current_screen.process_text(textEntered)
class QuestEmblemGui(DirectFrame):
notify = directNotify.newCategory('QuestEmblemGui')
def __init__(self, parent):
DirectFrame.__init__(self, parent)
self.emblem = OnscreenImage(image=loader.loadTexture(
'phase_5/maps/quest_available_emblem.png'),
parent=self)
self.emblem.setTransparency(TransparencyAttrib.MAlpha)
self.emblem.setBillboardAxis()
self.emblem.setTwoSided(1)
glowMdl = loader.loadModel('phase_4/models/minigames/particleGlow.bam')
self.glow = OnscreenImage(parent=self.emblem,
image=glowMdl,
color=(1.0, 1.0, 0.4, 1.0),
scale=(3.0, 3.0, 3.0),
pos=(0, 0.05, 0))
self.glow.setBin('gui-popup', 10)
glowMdl.removeNode()
self.track = None
self.state = LOADED
def setEmblem(self, questAvailable=QUEST_AVAILABLE):
# Sets the texture of the emblem.
texture = loader.loadTexture('phase_5/maps/quest_available_emblem.png')
if questAvailable is 0:
texture = loader.loadTexture(
'phase_5/maps/quest_scroll_emblem.png')
self.state = questAvailable
self.emblem.setImage(texture)
self.emblem.setTransparency(TransparencyAttrib.MAlpha)
self.emblem.setBillboardAxis()
self.emblem.setTwoSided(1)
def start(self, bobMinHeight=0.5, bobMaxHeight=0.5):
# Shows the emblem and starts the bobbing animation.
# Stops so we don't have two animations running at once.
self.stop()
# Shows the emblem
self.show()
# Let's create the animation and run the animation.
self.track = Sequence(
LerpPosInterval(self.emblem,
1.35,
pos=(0, 0, self.getZ() - bobMinHeight),
startPos=(0, 0, bobMaxHeight),
blendType='easeInOut'),
LerpPosInterval(self.emblem,
1.35,
pos=(0, 0, bobMaxHeight),
startPos=(0, 0, self.getZ() - bobMinHeight),
blendType='easeInOut')).loop()
def stop(self):
# Hides the emblem and stops the animation.
self.hide()
if self.track:
self.track.pause()
self.track = None
self.state = DISABLED
def destroy(self):
self.stop()
self.glow.destroy()
self.emblem.destroy()
self.state = None
DirectFrame.destroy(self)
class Timer:
def __init__(self, style):
"""
Timer class with fun pictures
@param style: 0 = SUN, 1 = MOON, 2 = GUN
@type style: int
"""
self.style = style
VirtualFileSystem.getGlobalPtr().mount(Filename("mf/timer.mf"), ".", VirtualFileSystem.MFReadOnly)
self.egg = loader.loadModel("timer.egg")
self.img = None
self.interval = None
self.types[style](self)
def create_sun(self):
"""
Creates the sun timer
"""
# load image
self.img = OnscreenImage(image=self.egg.find('**/sun'), pos=(1.15, 0, 0.75),
color=(255, 255, 0, 1), scale=0.25)
# interval
self.interval = LerpFunc(self.run_interval, fromData=1, toData=0, duration=TIME)
self.interval.start()
return
def create_moon(self):
"""
Creates the moon timer
"""
# load image
self.img = OnscreenImage(image=self.egg.find('**/moon-quarter'), pos=(0, 0, 0),
color=(1, 1, 1, 1), scale=0.25)
# interval
self.interval = LerpFunc(self.run_interval, fromData=1, toData=0, duration=TIME)
self.interval.start()
return
def create_gun(self):
"""
Creates the gun timer
"""
# load image
self.img = OnscreenImage(image=self.egg.find('**/gun-0'), pos=(1.05, 0, 0.75), scale=0.25)
# interval
self.interval = LerpFunc(self.run_interval, fromData=1, toData=0, duration=TIME)
self.interval.start()
return
def run_interval(self, c):
if self.style == SUN:
self.img.setColor((1, c, 0, 1))
self.img.setPos(1.15-(c/4), 0, 0.75+(math.sin(math.pi*c)/10))
elif self.style == MOON:
self.img.setColor((1, c, c, 1))
self.img.setPos(0.9+(c/4), 0, 0.75+(math.sin(math.pi*c)/10))
elif self.style == GUN:
self.img.setHpr(0, 0, 360*(1-c)-60)
if c % (1 / 6) < 0.05:
if c % (1 / 6) > 0.025:
self.img.setColor((1, 40*(c % (1 / 6)), 40*(c % (1 / 6)), 1))
else:
self.img.setImage(self.egg.find('**/gun-{}'.format(6 - (round(c / (1 / 6))))))
self.img.setColor((1, 1-40*(c % (1 / 6)), 1-40*(c % (1 / 6)), 1))
else:
self.img.setColor((1, 1, 1, 1))
def annihilate(self):
self.interval.finish()
self.img.destroy()
loader.unloadModel(self.egg)
VirtualFileSystem.getGlobalPtr().unmount("mf/timer.mf")
del self
types = {
SUN: create_sun,
MOON: create_moon,
GUN: create_gun
}
class Menu (DirectObject):
def __init__(self, cursor):
#-----------------------------------------------------------------------------------------------------------------------------------------------
#---------------------------------------------------VARIABLE DECLARATION------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
self.title = None
self.play = None
self.credits = None
self.ins = None
self.selected = "PLAY"
self.pastTime = 0.0
self.oldX = 0.0
self.run = True
self.moved = 0.0
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------MENU INIT----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
self.title = OnscreenImage("./tex/menu/glooveth.png", (0, 0, -0.25), None, (1.0,1.0,0.25), None, None, 10)
self.title.setTransparency(TransparencyAttrib.MAlpha)
self.credits = OnscreenImage("./tex/menu/credits.png", (-1.0, 0, -0.75), None, (0.25,1.0,0.125), None, None, 10)
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.ins = OnscreenImage("./tex/menu/ins.png", (1.0, 0, -0.75), None, (0.25,1.0,0.125), None, None, 10)
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.play = OnscreenImage("./tex/menu/playOver.png", (0, 0, -0.75), None, (0.35,1.0,0.20), None, None, 10)
self.play.setTransparency(TransparencyAttrib.MAlpha)
# Cursor
self.cursor = cursor
# Start tasks
taskMgr.add(self.taskMenuMovement, 'taskMenuMovement')
#end __init__
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------FUNCTIONS----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# It hides the main menu of the game
def hide(self):
self.title.hide()
self.play.hide()
self.credits.hide()
self.ins.hide()
self.run = False
#end hide
# It shows the main menu of the game
def show(self):
self.title.show()
self.play.show()
self.credits.show()
self.ins.show()
taskMgr.add( self.taskMenuMovement, 'taskMenuMovement' )
self.run = True
#end show
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------TASKS,THREADS------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Menu interaction
def taskMenuMovement(self, task):
if( self.run == True ):
mpos = self.cursor.getCursorPos()
if( (mpos.getX() < -0.33) and (self.oldX >= -0.33 ) ): self.selected = "CREDITS"
elif( (mpos.getX() > -0.33) and (self.oldX <= -0.33) ): self.selected = "PLAY"
elif( (mpos.getX() < 0.33) and (self.oldX >= 0.33) ): self.selected = "PLAY"
elif( (mpos.getX() > 0.33) and (self.oldX <= 0.33) ): self.selected = "INS"
# Making bigger the button selected depending on the region of the cursor
if( self.selected == "PLAY" ):
self.play.setImage("./tex/menu/playOver.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.35,1.0,0.20))
elif( self.selected == "CREDITS" ):
self.credits.setImage("./tex/menu/creditsOver.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.35,1.0,0.20))
elif( self.selected == "INS" ):
self.ins.setImage("./tex/menu/insOver.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.35,1.0,0.20))
self.oldX = mpos.getX()
# Setting the others to a smaller size
if( self.selected == "PLAY" ):
self.credits.setImage("./tex/menu/credits.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.25,1.0,0.125))
self.ins.setImage("./tex/menu/ins.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.25,1.0,0.125))
elif( self.selected == "CREDITS" ):
self.play.setImage("./tex/menu/play.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.25,1.0,0.125))
self.ins.setImage("./tex/menu/ins.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.25,1.0,0.125))
elif( self.selected == "INS" ):
self.play.setImage("./tex/menu/play.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.25,1.0,0.125))
self.credits.setImage("./tex/menu/credits.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.25,1.0,0.125))
return task.cont
else: return task.done
#end taskMenuMovement
#end class Menu
class MyApp(ShowBase):
gameMode = "Intro"
def __init__(self):
ShowBase.__init__(self)
#self.cameraSetup()
self.setupKeyboard()
self.initIntro()
def gameChangeMode(self):
if base.gameMode == "Intro":
self.initIntro()
elif base.gameMode == "Convo":
self.initConvo()
def initIntro(self):
self.fadeAlpha = 0.0
self.fadeTime = 30.0
self.fadeInc = 1.0 / self.fadeTime
self.fadeDir = "up"
self.sceneImage = OnscreenImage(image="images/scene.png",
scale=(1920.0 / 1080.0, 1, 1))
self.sceneImage.setTransparency(TransparencyAttrib.MAlpha)
self.sceneImage.setAlphaScale(self.fadeAlpha)
self.imageNumber = 0
self.sceneImageList = ["images/scene.png", "images/image1.jpg"]
#self.texty = OnscreenText(str(self.fadeAlpha))
taskMgr.add(self.gameIntroUpdate, "GameIntroUpdate")
def gameIntroUpdate(self, task):
self.slideManager()
if (base.gameMode != "Intro"):
self.gameChangeMode()
return Task.done
return Task.cont
def cameraSetup(self):
base.camLens.setAspectRatio(1920.0 / 1080.0)
def slideManager(self):
if self.fadeDir == "up" and self.fadeAlpha < 1:
self.fadeAlpha += self.fadeInc
self.sceneImage.setAlphaScale(self.fadeAlpha)
#self.texty.setText(str(self.fadeAlpha))
if self.fadeDir == "down" and self.fadeAlpha > 0:
self.fadeAlpha -= self.fadeInc
self.sceneImage.setAlphaScale(self.fadeAlpha)
if self.fadeDir == "up" and self.fadeAlpha >= 1:
self.fadeDir = "down"
if self.fadeDir == "down" and self.fadeAlpha <= 0:
if self.imageNumber < 1:
self.fadeDir = "up"
self.sceneImage.setImage(self.nextImage())
self.sceneImage.setTransparency(TransparencyAttrib.MAlpha)
self.sceneImage.setAlphaScale(self.fadeAlpha)
else:
self.fadeDir = "up"
base.gameMode = "Convo"
self.sceneImage.setImage(self.sceneImageList[self.imageNumber])
self.sceneImage.setTransparency(TransparencyAttrib.MAlpha)
self.sceneImage.setAlphaScale(self.fadeAlpha)
def nextImage(self):
self.imageNumber += 1
return self.sceneImageList[self.imageNumber]
def initConvo(self):
self.textToType = "This will be used for talking\nThis is a good conversation box"
self.textVisible = ""
self.strOptionA = "Yes"
self.strOptionB = "No"
self.strOptionC = "Maybe"
self.convoResponseSelected = False
self.convoDepth = "1"
self.intOptionCount = 3
#self.txtConvo = OnscreenText(self.textVisible, align = TextNode.ALeft)
self.txtConvo = TextNode("Texty Bastard")
self.txtConvo.setText(self.textToType)
self.txtReply = TextNode("reply")
self.txtReply.setText("")
self.intHover = 0
#self.txtConvo.setFrameColor(0, 0, 1, 1)
#self.txtConvo.setFrameAsMargin(0.2, 0.2, 0.1, 0.1)
myFrame = DirectFrame(frameColor=(0.8, 0.8, 0.8, 0.4),
frameSize=(-1, 0, -1, 0))
nodePathConvo = aspect2d.attachNewNode(self.txtConvo)
nodePathConvo.setScale(0.07)
nodePathConvo.setPos(-1, 0, -0.1)
self.i = 0
self.indent = 0.0
self.selectedResponse = 0
self.txtOptionA = OnscreenText(text="",
pos=(-1, -0.6),
align=TextNode.ALeft)
self.txtOptionB = OnscreenText(text="",
pos=(-1, -0.7),
align=TextNode.ALeft)
self.txtOptionC = OnscreenText(text="",
pos=(-1, -0.8),
align=TextNode.ALeft)
taskMgr.add(self.gameConvoUpdate, "GameConvoUpdate")
def gameConvoUpdate(self, task):
if (len(self.textVisible) != len(self.textToType)):
task.delayTime = 0.001
while (self.i < len(self.textToType)):
self.textVisible += self.textToType[self.i]
self.txtConvo.setText(self.textVisible)
self.i += 1
return Task.again
else:
taskMgr.add(self.gameConvoOptions, "ConvoOptions")
return Task.done
def gameConvoOptions(self, task):
self.txtOptionA.setText(self.strOptionA)
self.txtOptionB.setText(self.strOptionB)
self.txtOptionC.setText(self.strOptionC)
if self.convoResponseSelected == True:
if self.convoCheckBranch("01", self.convoDepth):
#self.txtConvo.setText(self.convoGetStrings("01", self.convoDepth))
self.convoNextDialogue("01", self.convoDepth)
else:
#self.txtConvo.setText("It DIDn't worked")
self.convoDepth = "1"
self.convoNextDialogue("01", self.convoDepth)
return Task.done
elif self.selectedResponse == 0:
if self.intOptionCount > 0:
self.txtOptionA.setX(-1 + self.indent)
self.txtOptionA.setFg(fg=(1, 0, 0, 1))
if self.intOptionCount > 1:
self.txtOptionB.setX(-1)
self.txtOptionB.setFg(fg=(0, 0, 0, 1))
if self.intOptionCount > 2:
self.txtOptionC.setX(-1)
self.txtOptionC.setFg(fg=(0, 0, 0, 1))
self.indent = self.getIndent(self.indent, 0.01, 0.1)
return Task.again
elif self.selectedResponse == 1:
if self.intOptionCount > 0:
self.txtOptionA.setX(-1)
self.txtOptionA.setFg(fg=(0, 0, 0, 1))
if self.intOptionCount > 1:
self.txtOptionB.setX(-1 + self.indent)
self.txtOptionB.setFg(fg=(1, 0, 0, 1))
if self.intOptionCount > 2:
self.txtOptionC.setX(-1)
self.txtOptionC.setFg(fg=(0, 0, 0, 1))
self.indent = self.getIndent(self.indent, 0.01, 0.1)
return Task.again
elif self.selectedResponse == 2:
if self.intOptionCount > 0:
self.txtOptionA.setX(-1)
self.txtOptionA.setFg(fg=(0, 0, 0, 1))
if self.intOptionCount > 1:
self.txtOptionB.setX(-1)
self.txtOptionB.setFg(fg=(0, 0, 0, 1))
if self.intOptionCount > 2:
self.txtOptionC.setX(-1 + self.indent)
self.txtOptionC.setFg(fg=(1, 0, 0, 1))
self.indent = self.getIndent(self.indent, 0.01, 0.1)
return Task.again
def convoGetStrings(self, npcId, depth):
if self.convoCheckBranch(npcId, depth) != True:
return "#Error# String Not Found\nLooking for: " + "(" + str(
npcId) + ")." + depth + ":"
char = ""
line = ""
feed = ""
path = os.path.abspath(os.getcwd())
f = open(path + "\\text\\stringsConvo.txt", "r")
while line != "(" + str(npcId) + ")." + depth + ":":
while char != ":":
char = f.readline(1)
line += char
feed += "\n" + line
if line != "(" + str(npcId) + ")." + depth + ":":
char = ""
line = ""
f.readline()
print(feed + " Selected")
f.readline(1)
line = f.readline()
line = line.replace("##", "\n")
f.close()
return line
def convoCheckBranch(self, npcId, depth):
path = os.path.abspath(os.getcwd())
f = open(path + "\\text\\stringsConvo.txt", "r")
char = ""
line = ""
branchFound = False
while line != "<END>:":
char = ""
line = ""
while char != ":":
char = f.readline(1)
line += char
if line == "<END>:":
f.close()
return False
elif line == "(" + str(npcId) + ")." + str(depth) + ":":
f.close()
return True
else:
f.readline()
def convoNextDialogue(self, npcId, depth):
self.textToType = self.convoGetStrings(npcId, depth)
self.intOptionCount = self.convoGetOptionCount(npcId, depth)
if self.intOptionCount == 1:
self.strOptionA = self.convoGetStrings(npcId, depth + ".A")
self.strOptionB = ""
self.strOptionC = ""
elif self.intOptionCount == 2:
self.strOptionA = self.convoGetStrings(npcId, depth + ".A")
self.strOptionB = self.convoGetStrings(npcId, depth + ".B")
self.strOptionC = ""
elif self.intOptionCount == 3:
self.strOptionA = self.convoGetStrings(npcId, depth + ".A")
self.strOptionB = self.convoGetStrings(npcId, depth + ".B")
self.strOptionC = self.convoGetStrings(npcId, depth + ".C")
else:
self.strOptionA = ""
self.strOptionB = ""
self.strOptionC = ""
self.textVisible = ""
self.txtOptionA.setText("")
self.txtOptionB.setText("")
self.txtOptionC.setText("")
self.txtConvo.setText(self.textVisible)
#self.intOptionCount = 2
self.selectedResponse = 0
self.i = 0
self.convoResponseSelected = False
taskMgr.add(self.gameConvoUpdate, "GameConvoUpdate")
def convoGetOptionCount(self, npcId, depth):
if self.convoCheckBranch(
npcId, depth + ".A") and self.convoCheckBranch(
npcId, depth + ".B") and self.convoCheckBranch(
npcId, depth + ".C"):
return 3
elif self.convoCheckBranch(npcId,
depth + ".A") and self.convoCheckBranch(
npcId, depth + ".B"):
return 2
elif self.convoCheckBranch(npcId, depth + ".A"):
return 1
else:
return 0
def getIndent(self, value, increment, limit):
if (value + increment >= limit):
return limit
else:
return value + increment
def setupKeyboard(self):
self.accept("arrow_down", self.convoOptionDown)
self.accept("arrow_up", self.convoOptionUp)
self.accept("enter", self.convoOptionSelect)
def convoOptionUp(self):
self.indent = 0.0
if self.selectedResponse == 0:
self.selectedResponse = self.intOptionCount - 1
elif self.selectedResponse > 0:
self.selectedResponse -= 1
def convoOptionDown(self):
self.indent = 0.0
if self.selectedResponse < self.intOptionCount - 1:
self.selectedResponse += 1
elif self.selectedResponse == self.intOptionCount - 1:
self.selectedResponse = 0
def convoOptionSelect(self):
if self.selectedResponse == 0:
self.convoDepth += ".A.1"
elif self.selectedResponse == 1:
self.convoDepth += ".B.1"
elif self.selectedResponse == 2:
self.convoDepth += ".C.1"
self.convoResponseSelected = True
class Game(ShowBase):
def __init__(self):
ShowBase.__init__(self)
#start the time
self.globalTime = 0
self.nextEnemy = 1
#setup your collision event handlers, apparently needs a direct object
self.do = DirectObject()
self.do.accept('unit-into-unit', self.handleUnitIntoCollision)
self.do.accept('unit-out-unit', self.handleUnitOutCollision)
self.do.accept('unit-into-cube', self.handleCubeIntoCollision)
self.do.accept('unit-into-wing', self.handleWingIntoCollision)
self.do.accept('unit-into-bar', self.handleBarIntoCollision)
#get window properties
self.winProps = WindowProperties()
#self.winProps.setFullscreen(True)
self.winProps.setCursorHidden(True)
base.win.requestProperties(self.winProps)
self.winProps = base.win.getProperties()
self.screenHeight = self.winProps.getYSize()
#set up the control scheme
self.controlScheme = ControlScheme(base.mouseWatcherNode, base.win, \
[LEFT, RIGHT, UP, DOWN, PAUSE, PULL, PUSH, SWITCH, QUIT])
#disable the automatic task to move the camera
#(this does not actually disable the mouse)
base.disableMouse()
#declare null values for variables, fill them in later
self.environment = None
self.player = None
#a node for holding all in-game units
self.unitNodePath = NodePath('unit holder')
self.unitNodePath.reparentTo(self.render)
#object lists
self.enemies = []
self.obstacles = []
self.projectiles = []
#list of enemies to be spawned
self.eSpawnList = []
#not paused by default
self.paused = False
self.pauseWasPressed = False
#variables for tracking time
self.previousFrameTime = 0
#start the collision traverser
traverser = CollisionTraverser()
base.cTrav = traverser#run every frame
self.cTrav = base.cTrav
#set the check for units accidentally passing through level geometry
self.cTrav.setRespectPrevTransform(True)
#self.cTrav.showCollisions(self.render)
#self.cTrav.showCollisions(self.unitNodePath)#show the collisions
#load terrain and enemies
#load the environment, it seems that an x value of zero, a y value of -50 puts the origin point relatively in the middle of the crater
filename = PARAMS_PATH + "environment.txt"
self.loadLevelGeom(filename)
#load the enemies
filename = PARAMS_PATH + "enemies.txt"
self.loadLevelEnemies(filename)
#lookup table for actors
self.actors = {}
#place the player in the environment
self.player = Player(self.controlScheme, self.camera, self, 0, 0, 0)
self.player.setName("player")
self.player.setH(180)
self.player.reparentTo(self.unitNodePath)
self.player.nodePath = self.render.find("player")
self.actors["player"] = self.player
#add some lights
topLight = DirectionalLight("top light")
topLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
topLight.setDirection(Vec3(0, -90, 0))
self.render.setLight(self.render.attachNewNode(topLight))
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
self.render.setLight(self.render.attachNewNode(ambientLight))
#the distance the camera is from the player
self.cameraHOffset = 45
self.cameraVOffset = 10
#add the collision sound
self.collisionSound = self.loader.loadSfx(SFX_PATH + "collide.wav")
#register the update task
self.taskMgr.add(self.updateGame, "updateGame")
#add targeting to the world
self.setupTargeting()
#seed the random number generator
random.seed()
# configure the entire GUI
self.setupGUI()
# configure the title screen
self.setupTitleScreen()
def setupGUI(self):
GUIFont = loader.loadFont(FONTS_PATH + 'orbitron-medium.ttf')
"""
self.debugText = TextNode('debug')
self.debugText.setText("")
self.debugText.setAlign(TextNode.ALeft)
self.debugText.setFont(GUIFont)
dTextNodePath = aspect2d.attachNewNode(self.debugText)
dTextNodePath.setScale(0.075)
dTextNodePath.setPos(-1.2, 0, -0.9)
"""
#INTRO
self.introText = TextNode('intro')
self.introText.setText("")
self.introText.setAlign(TextNode.ALeft)
self.introText.setFont(GUIFont)
self.introText.setCardColor(0.1, 0.1, 0.1, 0.6)
self.introText.setCardAsMargin(0.5, 0.5, 0.5, 0.5)
self.introText.setCardDecal(True)
self.introText.setWordwrap(30.0)
self.iTextNodePath = aspect2d.attachNewNode(self.introText)
self.iTextNodePath.setScale(0.06)
self.iTextNodePath.setPos(-1.2, 0, -0.7)
#image is 171 x 323
self.leftMouseImage = OnscreenImage()
self.leftMouseImage.setImage(GUI_PATH + "mouse-icon-left.png")
self.leftMouseImage.setTransparency(1)
self.leftMousePath = aspect2d.attachNewNode(self.leftMouseImage.node())
self.rightMouseImage = OnscreenImage()
self.rightMouseImage.setImage(GUI_PATH + "mouse-icon-right.png")
self.rightMouseImage.setTransparency(1)
self.rightMousePath = aspect2d.attachNewNode(self.rightMouseImage.node())
self.middleMouseImage = OnscreenImage()
self.middleMouseImage.setImage(GUI_PATH + "mouse-icon-middle.png")
self.middleMouseImage.setTransparency(1)
self.middleMousePath = aspect2d.attachNewNode(self.middleMouseImage.node())
self.leftMousePath.setScale(.105882, 0, .2)
self.leftMousePath.setPos(1.1, 0, -0.75)
self.rightMousePath.setScale(.105882, 0, .2)
self.rightMousePath.setPos(1.1, 0, -0.75)
self.middleMousePath.setScale(.105882, 0, .2)
self.middleMousePath.setPos(1.1, 0, -0.75)
self.leftMousePath.hide()
self.rightMousePath.hide()
self.middleMousePath.hide()
#HUD
#image is 365 x 187
self.attackModeImage = OnscreenImage()
self.attackModeImage.setImage(GUI_PATH + "mode-area.png")
self.attackModeImage.setTransparency(1)
modeNodePath = aspect2d.attachNewNode(self.attackModeImage.node())
modeNodePath.setScale(.136631, 0, .07)
modeNodePath.setPos(-1.13, 0, 0.88)
self.energyBarImage = OnscreenImage()
self.energyBarImage.setImage(GUI_PATH + "energy-bar-full.png")
self.energyBarImage.setTransparency(1)
eBarNodePath = aspect2d.attachNewNode(self.energyBarImage.node())
eBarNodePath.setScale(.400, 0, .0475)
eBarNodePath.setPos(-0.66, 0, 0.88)
self.healthBarImage = OnscreenImage()
self.healthBarImage.setImage(GUI_PATH + "health-bar-full.png")
self.healthBarImage.setTransparency(1)
hBarNodePath = aspect2d.attachNewNode(self.healthBarImage.node())
hBarNodePath.setScale(.400, 0, .0475)
hBarNodePath.setPos(0.85, 0, 0.88)
def setupTitleScreen(self):
self.titleScreenIsActive = True
#image is 800 x 600
self.titleImage = OnscreenImage()
self.titleImage.setImage(GUI_PATH + "title.png")
titleNodePath = aspect2d.attachNewNode(self.titleImage.node())
titleNodePath.setScale(1.33333, 0, 1)
titleNodePath.setPos(0, 0, 0)
def updateTitleScreen(self):
if (self.controlScheme.keyDown(PUSH) or self.controlScheme.keyDown(PULL) or self.controlScheme.keyDown(SWITCH)) and self.titleScreenIsActive:
self.titleImage.hide()
self.titleScreenIsActive = False
elif self.titleScreenIsActive:
self.titleImage.setImage(GUI_PATH + "title.png")
self.globalTime=0
else:
pass
def calculateBarImage(self, level):
if level == 0:
level = "empty"
elif level == 10:
level = "full"
elif level == 1:
level = "1"
elif level == 2:
level = "2"
elif level == 3:
level = "3"
elif level == 4:
level = "4"
elif level == 5:
level = "5"
elif level == 6:
level = "6"
elif level == 7:
level = "7"
elif level == 8:
level = "8"
elif level == 9:
level = "9"
return level
def updateGUI(self):
"""
self.debugText.setText("Energy: "+str((100*self.player.energy/self.player.maxEnergy))+"%, Health: "+str((100*self.player.health/self.player.maxHealth)))
"""
self.updateIntro()
if self.player.currentWeapon == AREA:
modeImg = "mode-area"
elif self.player.currentWeapon == NARROW:
modeImg = "mode-narrow"
energyLevel = self.calculateBarImage((100 * (self.player.energy / self.player.maxEnergy)) // 10)
self.energyBarImage.setImage(GUI_PATH + "energy-bar-" + energyLevel + ".png")
self.energyBarImage.setTransparency(1)
self.attackModeImage.setImage(GUI_PATH + modeImg + ".png")
self.attackModeImage.setTransparency(1)
healthLevel = self.calculateBarImage((100 * (self.player.health / self.player.maxHealth)) // 10)
self.healthBarImage.setImage(GUI_PATH + "health-bar-" + healthLevel + ".png")
self.healthBarImage.setTransparency(1)
def updateIntro(self):
modifiedTime = self.globalTime/5
if self.introText is None:
pass
elif modifiedTime>=14300 and self.introText is not None:
self.iTextNodePath.removeNode()
self.introText = None
elif modifiedTime<300: #0-300
self.introText.setText("Hey are you receiving?")
elif modifiedTime<800: #300-800
self.introText.setText("We recently uncovered the location of an old cruiser wreck from the war.")
elif modifiedTime<1500: #800-1500
self.introText.setText("You're gonna go in there and get the little bits of it that are still worth salvaging.")
elif modifiedTime<2900: #1500-2900
self.introText.setText("Be aware though, this job may not be quite as simple as a grab-and-run. The coordinates have been leaked to some of our old enemies.")
elif modifiedTime<4200: #2900-4200
self.introText.setText("To give you an edge, we've made a few upgrades to your electromagnetic grapple.")
elif modifiedTime<5300: #4200-5300
self.introText.setText("Pull enemies inwards with the right mouse button.")
self.leftMousePath.hide()
self.rightMousePath.show()
self.middleMousePath.hide()
elif modifiedTime<6400: #5300-6400
self.introText.setText("Push enemies away with the left mouse button.")
self.leftMousePath.show()
self.rightMousePath.hide()
self.middleMousePath.hide()
elif modifiedTime<8500: #6400-8500
self.introText.setText("Toggle between your range and narrow electromagnet with the middle mouse button (or spacebar).")
self.leftMousePath.hide()
self.rightMousePath.hide()
self.middleMousePath.show()
elif modifiedTime<13300: #8500-13300
self.introText.setText("You can give a solid kick to anything straight in front of you or just push everything around you away. Try and throw 'em into each other or other wreckage to finish 'em off for good.")
self.leftMousePath.hide()
self.rightMousePath.hide()
self.middleMousePath.hide()
elif modifiedTime<14300: #13300-14300
self.introText.setText("After all, the more salvage left over, the better. Out.")
def loadLevelGeom(self, filename):
filename = os.path.abspath(filename)
if not os.path.isfile(filename):
print "FILE DOES NOT EXIST:"
exit(1)
#get the lines from the file
textFileList = open(filename, 'r').readlines()
if len(textFileList) < 1:
print "FATAL ERROR READING FILE"
exit(1)
#now split each line into lists
for num, val in enumerate(textFileList):
val = val.rstrip('\n')#strip the newlines
val = val.strip()
textFileList[num] = val.split(TEXT_DELIMITER)
obstacle = None
for list in textFileList: #go through the list
if list[0] == TERRAIN_OUTER:#do all the things for the terrain
#choose the model
modelVal = list[1]
modelVal = (MODELS_PATH + modelVal)
self.environment = self.loader.loadModel(modelVal)
self.environment.reparentTo(self.render)
#get the collision geometry for the environment
#and move it up a bit to allow the character to float above the crater
self.craterCollision = self.environment.find("**/craterCollisionPlane")
self.craterCollision.setZ(self.environment.getZ() + 0.15)
self.environment.setCollideMask(BitMask32.allOff())
self.craterCollision.setCollideMask(BitMask32(TERRAIN_RAY_MASK))
#self.environment.find( #.find("craterCollisionPlane").setZ(self.environment.getZ() + 10)
#set scale
scaleVal = list[2].split(',')#split by commas
self.environment.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
#set location
locVal = list[3].split(',')
self.environment.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#then we have our terrain
#set rotation
hprVal = list[4].split(',')
self.environment.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
elif list[0] == TERRAIN_CUBE:
#choose the model
modelVal = list[1]
modelVal = (MODELS_PATH + modelVal)
#load the model
obstacle = self.loader.loadModel(modelVal)
obstacle.reparentTo(render)
#set scale
scaleVal = list[2].split(',')
obstacle.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
#set location
locVal = list[3].split(',')
obstacle.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#the we have our object
hprVal = list[4].split(',')
obstacle.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
#set up collisions
unitCollision = obstacle.find("**/CubeBlock")
unitCollision.node().setName("cube")
obstacle.setCollideMask(BitMask32.allOff())
unitCollision.setCollideMask(BitMask32(PLAYER_ENEMY_OBJECTS))
self.obstacles.append(obstacle)
elif list[0] == TERRAIN_WING:
modelVal = list[1]
modelVal = (MODELS_PATH + modelVal)
#load the model
obstacle = self.loader.loadModel(modelVal)
obstacle.reparentTo(render)
#set scale
scaleVal = list[2].split(',')
obstacle.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
#set location
locVal = list[3].split(',')
obstacle.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#the we have our object
hprVal = list[4].split(',')
obstacle.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
#set up collisions
unitCollision = obstacle.find("**/wingCollider")
unitCollision.node().setName("wing")
obstacle.setCollideMask(BitMask32.allOff())
unitCollision.setCollideMask(BitMask32(PLAYER_ENEMY_OBJECTS))
self.obstacles.append(obstacle)
elif list[0] == TERRAIN_BAR:
modelVal = list[1]
modelVal = (MODELS_PATH + modelVal)
#load the model
obstacle = self.loader.loadModel(modelVal)
obstacle.reparentTo(render)
#set scale
scaleVal = list[2].split(',')
obstacle.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
#set location
locVal = list[3].split(',')
obstacle.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#the we have our object
hprVal = list[4].split(',')
obstacle.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
#set up collisions
unitCollision = obstacle.find("**/metalBarCollisionCube")
unitCollision.node().setName("bar")
obstacle.setCollideMask(BitMask32.allOff())
unitCollision.setCollideMask(BitMask32(PLAYER_ENEMY_OBJECTS))
elif list[0] == TERRAIN_SHARDS:
modelVal = list[1]
modelVal = (MODELS_PATH + modelVal)
#load the model
obstacle = self.loader.loadModel(modelVal)
obstacle.reparentTo(render)
#set scale
scaleVal = list[2].split(',')
obstacle.setScale(float(scaleVal[0]), float(scaleVal[1]), float(scaleVal[2]))
#set location
locVal = list[3].split(',')
obstacle.setPos(float(locVal[0]), float(locVal[1]), float(locVal[2]))#the we have our object
hprVal = list[4].split(',')
obstacle.setHpr(float(hprVal[0]), float(hprVal[1]), float(hprVal[2]))
#set up collisions
unitCollision = obstacle.find("**/metalShardCollisionCube")
unitCollision.node().setName("shard")
obstacle.setCollideMask(BitMask32.allOff())
unitCollision.setCollideMask(BitMask32(PLAYER_ENEMY_OBJECTS))
else:
print "FATAL ERROR READING FILE"
exit(1)
pass
def loadLevelEnemies(self, filename):
filename = os.path.abspath(filename)
if not os.path.isfile(filename):
print "FILE DOES NOT EXIST:"
exit(1)
#get the lines from the file and split them
textFileList = open(filename, 'r').readlines()
if len(textFileList) < 1:
print "FATAL ERROR READING FILE"
exit(1)
for num, val in enumerate(textFileList):
val = val.rstrip('\n')#strip the newlines
val = val.strip()
textFileList[num] = val.split(TEXT_DELIMITER)
currwave = dict()
currwave["time"] = None
currwave["enemies"] = []
currEnem = dict()
for val in textFileList:
if val[0] == BEGIN_WAVE:
currwave = dict()
currwave["time"] = float(val[1])#set your time
currwave["enemies"] = []
elif val[0] == RUSH_ENEMY:
currEnem = dict()
pos = []
pos = val[1].split(',')#get the three values for spawning, not floats
currEnem["type"] = RUSH_ENEMY
currEnem["xVal"] = float(pos[0])
currEnem["yVal"] = float(pos[1])
currEnem["zVal"] = float(pos[2])
currwave["enemies"].append(dict(currEnem))#copy
elif val[0] == DRONE_ENEMY:
currEnem = dict()
pos = []
pos = val[1].split(',')#get the three values for spawning, not floats
currEnem["type"] = DRONE_ENEMY
currEnem["xVal"] = float(pos[0])
currEnem["yVal"] = float(pos[1])
currEnem["zVal"] = float(pos[2])
currwave["enemies"].append(dict(currEnem))#copy
elif val[0] == SHOOTING_ENEMY:
currEnem = dict()
pos = []
pos = val[1].split(',')#get the three values for spawning, not floats
currEnem["type"] = SHOOTING_ENEMY
currEnem["xVal"] = float(pos[0])
currEnem["yVal"] = float(pos[1])
currEnem["zVal"] = float(pos[2])
currwave["enemies"].append(dict(currEnem))#copy
elif val[0] == END_WAVE:#then we are done with that wave
self.eSpawnList.append(dict(currwave))#copy
else:
pass#then something was stupid
#now sort your waves with lowest time first
self.eSpawnList.sort(key = lambda object: object["time"])
#and you're done
def updateGame(self, task):
if not self.titleScreenIsActive:
self.globalTime = self.globalTime + task.time
elapsedTime = task.time - self.previousFrameTime
#base.resetPrevTransform(render)#for our high intensity collision detection
if self.controlScheme.keyDown(QUIT):
exit(0)
if not self.paused and not self.titleScreenIsActive:
time = elapsedTime
while time > 0.02:
self.updateGameComponents(0.02)
time -= 0.02
self.updateGameComponents(time)
self.cTrav.traverse(render)
self.spawnEnemies()#globalTime is available
if self.controlScheme.keyDown(PAUSE):
if not self.pauseWasPressed:
self.paused = not self.paused
self.controlScheme.resetMouse()
self.pauseWasPressed = True
else:
self.pauseWasPressed = False
self.updateGUI()
self.updateTitleScreen()
self.previousFrameTime = task.time
return task.cont
def updateGameComponents(self, time):
'''
Updates the state of the world.
@precondition: The game isn't paused.
'''
self.updateCamera(time)
for enemy in self.enemies:
enemy.update(time)
for projectile in self.projectiles:
projectile.update(time)
#check for basic terrain collisions
self.player.terrainCollisionCheck()
self.player.update(time)
for enemy in self.enemies:
enemy.terrainCollisionCheck()
for projectile in self.projectiles:
projectile.terrainCollisionCheck()
def spawnEnemies(self):#now we spawn our enemies
while((len(self.eSpawnList) > 0) and self.eSpawnList[0]["time"] < self.globalTime):
for val in self.eSpawnList[0]["enemies"]:
if val["type"] == RUSH_ENEMY:
#add an enemy
tempEnemy = RushEnemy(self, val["xVal"], val["yVal"], val["zVal"])
self.configureEnemy(tempEnemy)
elif val["type"] == DRONE_ENEMY:
#add an enemy
tempEnemy = DroneEnemy(self, self.player, val["xVal"], val["yVal"], val["zVal"])
self.configureEnemy(tempEnemy)
elif val["type"] == SHOOTING_ENEMY:
#add an enemy
tempEnemy = ShootingEnemy(self, val["xVal"], val["yVal"], val["zVal"])
self.configureEnemy(tempEnemy)
else:
pass
del self.eSpawnList[0]#del
def configureEnemy(self, tempEnemy):#after making an enemy configure it for the game
numString = str(self.nextEnemy)
tempEnemy.setName("enemy" + numString)
tempEnemy.reparentTo(self.unitNodePath)
tempEnemy.nodePath = self.render.find("enemy1")
self.actors["enemy" + numString] = tempEnemy
self.nextEnemy = self.nextEnemy + 1
self.enemies.append(tempEnemy)
def rotateCamera(self):
if self.controlScheme.mouseX > self.winProps.getXSize():
self.camera.setH(-(self.winProps.getXSize() - 20) * 0.5)
else:
self.camera.setH(-self.controlScheme.mouseX * 0.5)
def updateCamera(self, elapsedTime):
#update the camera's heading based on the mouse's x position
if self.controlScheme.recheckMouse():
self.camera.setH(-self.controlScheme.mouseX * 0.5)
else:
self.rotateCamera()
#update the camera's pitch and vertical position based on the mouse's y position
self.cameraVOffset = min(self.screenHeight, max(0, self.controlScheme.mouseY)) / self.screenHeight * 25 + 4
self.cameraHOffset = self.cameraVOffset * 0.8 + 30
self.camera.setP(atan2(-self.cameraVOffset * 0.7, self.cameraHOffset) \
* 180 / pi)
#update the camera to point at the player
self.camera.setPos(self.player.getX() + self.cameraHOffset * sin(self.camera.getH() * pi / 180),
self.player.getY() - self.cameraHOffset * cos(self.camera.getH() * pi / 180),
self.player.getZ() + 0.3 + self.cameraVOffset)
def selectTarget(self):
"""Finds the closest shootable object and returns it"""
#traverse all objects in render
self.mPickerTraverser.traverse(self.unitNodePath)
if (self.mCollisionQue.getNumEntries() > 0):
self.mCollisionQue.sortEntries()
for i in range(0, self.mCollisionQue.getNumEntries()):
entry = self.mCollisionQue.getEntry(i)
pickedObj = entry.getIntoNodePath()
if not pickedObj.isEmpty():
name = pickedObj.getParent().getName()
if name == "render":
return None
#if the object is shootable, set it as the target
try:
if self.actors[name].shootable:
return self.actors[name]
except:
continue
return None
def setupTargeting(self):
"""Set up the collisions necessary to target enemies and other objects"""
#Since we are using collision detection to do picking, we set it up
#any other collision detection system with a traverser and a handler
self.mPickerTraverser = CollisionTraverser() #Make a traverser
#self.mPickerTraverser.showCollisions(self.unitNodePath)
self.mCollisionQue = CollisionHandlerQueue()
#create a collision solid ray to detect against
self.mPickRay = CollisionRay()
self.mPickRay.setOrigin(self.player.getPos(self.render))
self.mPickRay.setDirection(self.render.getRelativeVector(self.player, Vec3(0, 1, 0)))
self.mPickRay2 = CollisionRay()
self.mPickRay2.setOrigin(self.player.getPos(self.render))
self.mPickRay2.setDirection(self.render.getRelativeVector(self.player, Vec3(0.06, 1, 0)))
self.mPickRay3 = CollisionRay()
self.mPickRay3.setOrigin(self.player.getPos(self.render))
self.mPickRay3.setDirection(self.render.getRelativeVector(self.player, Vec3(-0.06, 1, 0)))
self.mPickRay4 = CollisionRay()
self.mPickRay4.setOrigin(self.player.getPos(self.render))
self.mPickRay4.setDirection(self.render.getRelativeVector(self.player, Vec3(0, 1, 0.06)))
self.mPickRay5 = CollisionRay()
self.mPickRay5.setOrigin(self.player.getPos(self.render))
self.mPickRay5.setDirection(self.render.getRelativeVector(self.player, Vec3(0, 1, -0.06)))
#create our collison Node to hold the ray
self.mPickNode = CollisionNode('pickRay')
self.mPickNode.setIntoCollideMask(BitMask32.allOff())
self.mPickNode.addSolid(self.mPickRay)
self.mPickNode2 = CollisionNode('pickRay2')
self.mPickNode2.setIntoCollideMask(BitMask32.allOff())
self.mPickNode2.addSolid(self.mPickRay2)
self.mPickNode3 = CollisionNode('pickRay3')
self.mPickNode3.setIntoCollideMask(BitMask32.allOff())
self.mPickNode3.addSolid(self.mPickRay3)
self.mPickNode4 = CollisionNode('pickRay4')
self.mPickNode4.setIntoCollideMask(BitMask32.allOff())
self.mPickNode4.addSolid(self.mPickRay4)
self.mPickNode5 = CollisionNode('pickRay5')
self.mPickNode5.setIntoCollideMask(BitMask32.allOff())
self.mPickNode5.addSolid(self.mPickRay5)
#Attach that node to the player since the ray will need to be positioned
#relative to it, returns a new nodepath
#well use the default geometry mask
#this is inefficent but its for mouse picking only
self.mPickNP = self.player.attachNewNode(self.mPickNode)
self.mPickNP2 = self.player.attachNewNode(self.mPickNode2)
self.mPickNP3 = self.player.attachNewNode(self.mPickNode3)
self.mPickNP4 = self.player.attachNewNode(self.mPickNode4)
self.mPickNP5 = self.player.attachNewNode(self.mPickNode5)
#well use what panda calls the "from" node. This is really a silly convention
#but from nodes are nodes that are active, while into nodes are usually passive environments
#this isnt a hard rule, but following it usually reduces processing
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it, we use bitmasks to determine what we check other objects against
#if they dont have a bitmask for bit 1 well skip them!
#self.mPickNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.mPickNode.setFromCollideMask(PLAYER_ENEMY_OBJECTS)
self.mPickNode2.setFromCollideMask(PLAYER_ENEMY_OBJECTS)
self.mPickNode3.setFromCollideMask(PLAYER_ENEMY_OBJECTS)
self.mPickNode4.setFromCollideMask(PLAYER_ENEMY_OBJECTS)
self.mPickNode5.setFromCollideMask(PLAYER_ENEMY_OBJECTS)
#Register the ray as something that can cause collisions
self.mPickerTraverser.addCollider(self.mPickNP, self.mCollisionQue)
self.mPickerTraverser.addCollider(self.mPickNP2, self.mCollisionQue)
self.mPickerTraverser.addCollider(self.mPickNP3, self.mCollisionQue)
self.mPickerTraverser.addCollider(self.mPickNP4, self.mCollisionQue)
self.mPickerTraverser.addCollider(self.mPickNP5, self.mCollisionQue)
def handleUnitIntoCollision(self, entry):
try:
fromName = entry.getFromNodePath().getParent().getName()
intoName = entry.getIntoNodePath().getParent().getName()
Unit.collideWithUnit(self.actors[intoName], self.actors[fromName])
if (fromName == "player" or intoName == "player") and self.collisionSound.status() is not self.collisionSound.PLAYING:
self.collisionSound.play()
except:
pass
def handleUnitOutCollision(self, entry):
pass
def handleWingIntoCollision(self, entry):
fromName = entry.getFromNodePath().getParent().getName()
Unit.collideWithObstacle(self.actors[fromName])
if fromName == "player" and self.collisionSound.status() is not self.collisionSound.PLAYING:
self.collisionSound.play()
def handleCubeIntoCollision(self, entry):
try:
fromName = entry.getFromNodePath().getParent().getName()
Unit.collideWithObstacle(self.actors[fromName])
if fromName == "player" and self.collisionSound.status() is not self.collisionSound.PLAYING:
self.collisionSound.play()
except:
pass
def handleBarIntoCollision(self, entry):
fromName = entry.getFromNodePath().getParent().getName()
Unit.collideWithObstacle(self.actors[fromName])
if fromName == "player" and self.collisionSound.status() is not self.collisionSound.PLAYING:
self.collisionSound.play()
def gameOver(self):
pass
class ScreenshotViewer:
notify = DirectNotifyGlobal.directNotify.newCategory('ScreenshotViewer')
def __init__(self):
self.resetImages()
imageFrame = PDialog(parent = aspect2dp, pos = (0, 0, 0.10000000000000001), image_scale = (1.3 * 4 / 3.0, 1, 1.3), fadeScreen = 0.84999999999999998, scale = 1.1000000000000001)
imageFrame.hide()
imX = 0.84999999999999998
imY = imX * 3 / 4.0
self.imageObj = OnscreenImage(parent = imageFrame, image = self.screens[0], scale = (imX, 1, imY), pos = (0, 0, -0.025000000000000001))
self.imageLabel = DirectLabel(parent = imageFrame, relief = None, state = DGG.DISABLED, pos = (0, 0, -0.75), textMayChange = 1, text_fg = (0.59999999999999998, 0.59999999999999998, 0.59999999999999998, 1), text_scale = 0.040000000000000001)
self.imageLabel.hide()
topGui = loader.loadModel('models/gui/toplevel_gui')
arrow = topGui.find('**/generic_arrow')
buttons = loader.loadModel('models/gui/lookout_gui')
closeButton = (buttons.find('**/lookout_close_window'), buttons.find('**/lookout_close_window_down'), buttons.find('**/lookout_close_window_over'))
xs = 1.2
self.nextButton = DirectButton(parent = imageFrame, relief = None, command = self.next, pos = (0.69999999999999996, 0, 0), image = arrow, image_scale = (-xs, xs, xs), sortOrder = -5)
self.prevButton = DirectButton(parent = imageFrame, relief = None, command = self.prev, pos = (-0.69999999999999996, 0, 0), image = arrow, image_scale = xs, sortOrder = -5)
self.closeButton = DirectButton(parent = imageFrame, relief = None, command = self.close, pos = (0.78000000000000003, 0, -0.5), image = closeButton, image_scale = 0.29999999999999999, text = PLocalizer.lClose, text_fg = PiratesGuiGlobals.TextFG1, text_scale = 0.050000000000000003, text_pos = (0, -0.10000000000000001), sortOrder = -5)
self.showIval = Sequence(Func(imageFrame.show), Wait(1), Parallel(LerpPosInterval(self.closeButton, 0.20000000000000001, Vec3(0.78000000000000003, 0, -0.80000000000000004), Vec3(0.78000000000000003, 0, -0.5)), LerpPosInterval(self.nextButton, 0.20000000000000001, Vec3(1, 0, 0), Vec3(0.69999999999999996, 0, 0)), LerpPosInterval(self.prevButton, 0.20000000000000001, Vec3(-1, 0, 0), Vec3(-0.69999999999999996, 0, 0))), Func(self.imageLabel.show))
self.imageFrame = imageFrame
base.transitions.fadeScreen(0.84999999999999998)
def destroy(self):
self.imageFrame.destroy()
def resetImages(self):
filenames = os.listdir(os.curdir + '/' + PLocalizer.ScreenshotDir)
self.screens = _[1]
self.currentIndex = 0
def resetButtons(self):
self.closeButton.setPos(Vec3(0.78000000000000003, 0, -0.5))
self.nextButton.setPos(Vec3(0.69999999999999996, 0, 0))
self.prevButton.setPos(Vec3(-0.69999999999999996, 0, 0))
def showImage(self, index):
if index >= 0 and index < len(self.screens):
self.imageFrame.show()
self.imageObj.setImage(self.screens[index])
pandafile = Filename(str(ExecutionEnvironment.getCwd()))
winfile = pandafile.toOsSpecific()
self.imageLabel['text'] = '%s:\n%s\n%s\n[%s/%s]' % (PLocalizer.ScreenshotLocation, winfile, self.screens[index], index + 1, len(self.screens))
self.imageLabel['text_fg'] = (0.59999999999999998, 0.59999999999999998, 0.59999999999999998, 1)
self.imageLabel['text_scale'] = 0.040000000000000001
if len(self.screens) == 1:
self.prevButton['state'] = DGG.DISABLED
self.nextButton['state'] = DGG.DISABLED
else:
self.prevButton['state'] = DGG.NORMAL
self.nextButton['state'] = DGG.NORMAL
def next(self):
self.currentIndex = (self.currentIndex + 1) % len(self.screens)
try:
self.showImage(self.currentIndex)
except:
self.notify.error('Bad image')
def prev(self):
self.currentIndex = (self.currentIndex - 1) % len(self.screens)
try:
self.showImage(self.currentIndex)
except:
self.notify.error('Bad Image')
def close(self):
self.imageFrame.hide()
def show(self):
self.resetImages()
self.resetButtons()
self.showImage(0)
self.showIval.start()
def toggleShow(self):
if self.imageFrame.isHidden():
self.show()
else:
self.close()
class MyApp(ShowBase):
def __init__(self, markerImage='marker.jpg', calib_file='test.npz'):
ShowBase.__init__(self)
base.disableMouse()
self.marker = cv2.imread(markerImage)
self.marker = cv2.flip(self.marker, 0)
self.kp_marker, self.des_marker = getDes(self.marker)
if useCamera:
self.cap = cv2.VideoCapture(0)
ret, frame = self.cap.read()
else:
ret, frame = True, cv2.imread("sample_0.jpg")
if ret:
self.frame = frame
self.criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER,
30, 0.001)
with np.load(calib_file) as calib_File:
self.K = calib_File['mtx']
self.D = calib_File['coef']
(h, w) = frame.shape[0:2]
print w, h
far = 100
near = 0.1
fovx, fovy, f, (cx, cy), a = cv2.calibrationMatrixValues(
self.K, (w, h), w, h)
print fovx, fovy, f, cx, cy
base.camLens.setFilmSize(w, h)
base.camLens.setFilmOffset(w * 0.5 - cx, h * 0.5 - cy)
base.camLens.setFocalLength(f)
base.camLens.setFov(fovx, fovy)
base.camLens.setNearFar(near, far)
#base.camLens.setCoordinateSystem(4)
base.camLens.setCoordinateSystem(4)
#base.camLens.setViewVector(Vec3(0,0,1), Vec3(0,1,0))
#self.render.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
self.tex = Texture("detect") #self.buff.getTexture()
self.tex.setCompression(Texture.CMOff)
self.tex.setup2dTexture(w, h, Texture.TUnsignedByte, Texture.FRgb)
self.b = OnscreenImage(parent=render2d, image=self.tex)
base.cam.node().getDisplayRegion(0).setSort(20)
self.taskMgr.add(self.updateFrameTask, "UpdateCameraFrameTask")
self.modelroot = NodePath('ARRootNode')
self.modelroot.reparentTo(self.render)
'''
self.x = self.loader.loadModel("models/box")
self.x.reparentTo(self.modelroot)
self.x.setScale(3, 0.1, 0.1)
self.x.setPos(0, -0.05, -0.05)
self.x.setColor(1,0,0,1,1)
self.y = self.loader.loadModel("models/box")
self.y.reparentTo(self.modelroot)
self.y.setScale(0.1, 3, 0.1)
self.y.setPos(-0.05, 0, -0.05)
self.y.setColor(0,1,0,1,1)
self.z = self.loader.loadModel("models/box")
self.z.reparentTo(self.modelroot)
self.z.setScale(0.1, 0.1, 3)
self.z.setPos(-0.05, -0.05, 0)
self.z.setColor(0,0,1,1,1)
'''
self.panda = NodePath('PandaRoot')
self.panda.reparentTo(self.modelroot)
# Load and transform the panda actor.
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.003, 0.003, 0.003)
self.pandaActor.reparentTo(self.panda)
self.pandaActor.loop("walk")
self.pandaActor.setH(180)
#self.pandaMotion = MopathInterval("Panda Path", self.panda, "Interval Name")
self.pathCurve = createNurbsCurve()
for i in range(0, 30):
self.pathCurve.addPoint(
(random.uniform(1, 7), random.uniform(1, 7), 0))
'''
self.pathCurve.addPoint((1, 5, 0))
self.pathCurve.addPoint((5, 5, 0))
self.pathCurve.addPoint((5, 1, 0))
self.pathCurve.addPoint((1, 1, 0))
'''
curveNode = self.pathCurve.getNodepath()
self.myMopath = Mopath()
self.myMopath.loadNodePath(curveNode)
self.myMopath.fFaceForward = True
myInterval = MopathInterval(self.myMopath,
self.panda,
duration=100,
name="Name")
myInterval.loop()
# This task runs for two seconds, then prints done
def updateFrameTask(self, task):
if useCamera:
ret, frame = self.cap.read()
else:
ret, frame = True, self.frame
if ret:
frame = cv2.flip(frame, 0)
kp_frame, des_frame = getDes(frame)
matches = getMatches(self.des_marker, des_frame)
if not matches or len(matches) < 5:
return task.cont
pattern_points = [self.kp_marker[pt.trainIdx].pt for pt in matches]
pattern_points = np.array([(x / 50.0, y / 50.0, 0)
for x, y in pattern_points],
dtype=np.float32)
image_points = np.array(
[kp_frame[pt.queryIdx].pt for pt in matches], dtype=np.float32)
#ret, rvecs, tvecs = cv2.solvePnP(pattern_points, image_points, self.K, None)
rvecs, tvecs, inliers = cv2.solvePnPRansac(pattern_points,
image_points, self.K,
None)
#print "Tadam!",rvecs, tvecs
#img_pts, jac = cv2.projectPoints(axis, rvecs, tvecs, camera_matrix, dist_coefs)
#draw_lines(image, img_pts)
T = tvecs.ravel()
R = rvecs.ravel()
RotM, _ = cv2.Rodrigues(R)
RotM = RotM.T
RotM = Mat3(
RotM[0, 0],
RotM[0, 1],
RotM[0, 2],
RotM[1, 0],
RotM[1, 1],
RotM[1, 2],
# RotM[2,0],RotM[2,1],RotM[2,2])
-RotM[2, 0],
-RotM[2, 1],
-RotM[2, 2])
self.modelroot.setMat(Mat4(RotM, Vec3(T[0], T[1], T[2])))
self.tex.setRamImage(frame)
self.b.setImage(image=self.tex, parent=render2d)
self.camera.setPos(0, 0, 0)
self.camera.setHpr(0, 0, 0)
self.camera.setScale(1, 1, 1)
return task.cont
class Menu(DirectObject):
def __init__(self, cursor):
#-----------------------------------------------------------------------------------------------------------------------------------------------
#---------------------------------------------------VARIABLE DECLARATION------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
self.title = None
self.play = None
self.credits = None
self.ins = None
self.selected = "PLAY"
self.pastTime = 0.0
self.oldX = 0.0
self.run = True
self.moved = 0.0
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------MENU INIT----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
self.title = OnscreenImage("./tex/menu/glooveth.png", (0, 0, -0.25),
None, (1.0, 1.0, 0.25), None, None, 10)
self.title.setTransparency(TransparencyAttrib.MAlpha)
self.credits = OnscreenImage("./tex/menu/credits.png",
(-1.0, 0, -0.75), None,
(0.25, 1.0, 0.125), None, None, 10)
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.ins = OnscreenImage("./tex/menu/ins.png", (1.0, 0, -0.75), None,
(0.25, 1.0, 0.125), None, None, 10)
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.play = OnscreenImage("./tex/menu/playOver.png", (0, 0, -0.75),
None, (0.35, 1.0, 0.20), None, None, 10)
self.play.setTransparency(TransparencyAttrib.MAlpha)
# Cursor
self.cursor = cursor
# Start tasks
taskMgr.add(self.taskMenuMovement, 'taskMenuMovement')
#end __init__
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------FUNCTIONS----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# It hides the main menu of the game
def hide(self):
self.title.hide()
self.play.hide()
self.credits.hide()
self.ins.hide()
self.run = False
#end hide
# It shows the main menu of the game
def show(self):
self.title.show()
self.play.show()
self.credits.show()
self.ins.show()
taskMgr.add(self.taskMenuMovement, 'taskMenuMovement')
self.run = True
#end show
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------TASKS,THREADS------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Menu interaction
def taskMenuMovement(self, task):
if (self.run == True):
mpos = self.cursor.getCursorPos()
if ((mpos.getX() < -0.33) and (self.oldX >= -0.33)):
self.selected = "CREDITS"
elif ((mpos.getX() > -0.33) and (self.oldX <= -0.33)):
self.selected = "PLAY"
elif ((mpos.getX() < 0.33) and (self.oldX >= 0.33)):
self.selected = "PLAY"
elif ((mpos.getX() > 0.33) and (self.oldX <= 0.33)):
self.selected = "INS"
# Making bigger the button selected depending on the region of the cursor
if (self.selected == "PLAY"):
self.play.setImage("./tex/menu/playOver.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.35, 1.0, 0.20))
elif (self.selected == "CREDITS"):
self.credits.setImage("./tex/menu/creditsOver.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.35, 1.0, 0.20))
elif (self.selected == "INS"):
self.ins.setImage("./tex/menu/insOver.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.35, 1.0, 0.20))
self.oldX = mpos.getX()
# Setting the others to a smaller size
if (self.selected == "PLAY"):
self.credits.setImage("./tex/menu/credits.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.25, 1.0, 0.125))
self.ins.setImage("./tex/menu/ins.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.25, 1.0, 0.125))
elif (self.selected == "CREDITS"):
self.play.setImage("./tex/menu/play.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.25, 1.0, 0.125))
self.ins.setImage("./tex/menu/ins.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.25, 1.0, 0.125))
elif (self.selected == "INS"):
self.play.setImage("./tex/menu/play.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.25, 1.0, 0.125))
self.credits.setImage("./tex/menu/credits.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.25, 1.0, 0.125))
return task.cont
else:
return task.done
#end taskMenuMovement
#end class Menu
class Rodney(Actor):
def __init__(self,
app,
model,
rightArm=None,
leftArm=None,
leftArmBook=None,
lives=9):
Actor.__init__(self, model)
self.app = app
self.scene = app.scene
self.lives = lives
self.last_x = 0
self.last_y = 0
# self.charged = True
self.block = False
self.setHpr(180, 0, 0)
if leftArm: self.leftArm = self.app.loader.loadModel(leftArm)
if rightArm: self.rightArm = self.app.loader.loadModel(rightArm)
if leftArmBook:
self.leftArmBook = self.app.loader.loadModel(leftArmBook)
self.set_up_arms()
self.init_collision()
self.load_HUD()
self.init_mouse_control_event()
def set_up_arms(self):
self.rightArm.reparentTo(self)
self.rightArm.setPos(0, -1, 0.8)
self.rightArm.setHpr(180, 0, 0)
self.leftArm.reparentTo(self)
self.leftArm.setPos(-10, 0, 2)
self.leftArm.setScale(0.2, 02, 0.2)
self.leftArm.setHpr(180, 0, 0)
self.leftArmBook.reparentTo(self.leftArm)
self.leftArmBook.setPos(-1, 0, -4)
def load_HUD(self):
self.life_image = OnscreenImage(
image=
'Thats_so_Ravens/PureMagicApp/PureMagicAssets/life_images/rodney_lives_'
+ str(self.lives) + '.png',
scale=(0.9, 0, 0.1),
pos=(0.1, 0, 1.3))
self.life_image.setTransparency(TransparencyAttrib.MAlpha)
self.shield_image = OnscreenImage(
image='Thats_so_Ravens/PureMagicApp/PureMagicAssets/Shield_off.png',
scale=(0.1),
pos=(0.8, 0, 1.0))
self.shield_image.setTransparency(TransparencyAttrib.MAlpha)
# self.charge_image = OnscreenImage(image='Thats_so_Ravens/PureMagicApp/PureMagicAssets/charge_on.png', scale=(0.1),
# pos=(.8, 0, 1))
# self.charge_image.setTransparency(TransparencyAttrib.MAlpha)
def set_life_image(self):
self.life_image.setImage(
'Thats_so_Ravens/PureMagicApp/PureMagicAssets/life_images/rodney_lives_'
+ str(self.lives) + '.png')
self.life_image.setTransparency(TransparencyAttrib.MAlpha)
def set_shield_image(self, onoff):
self.shield_image.setImage(
'Thats_so_Ravens/PureMagicApp/PureMagicAssets/Shield_' + onoff +
'.png')
self.shield_image.setTransparency(TransparencyAttrib.MAlpha)
# def set_charge_image(self, onoff):
# self.charge_image.setImage('Thats_so_Ravens/PureMagicApp/PureMagicAssets/charge_' + onoff + '.png')
# self.charge_image.setTransparency(TransparencyAttrib.MAlpha)
# def set_charge_image(self):
def init_collision(self):
cs = CollisionSphere(0, 0, 0, 1)
cnodePath = self.attachNewNode(CollisionNode('rodneyCnode'))
cnodePath.node().addSolid(cs)
def shooting_animation(self):
shooting_animation = []
######## TODO Change numbers to actually make a shooting animation
shooting_animation.append(
self.rightArm.hprInterval(1.0, Vec3(180, 90, 0)))
shoot = Sequence(*shooting_animation)
shoot.start()
def blocking_animation(self):
blocking_animation = []
######## TODO Change numbers to actually make a blocking animation
blocking_animation.append(
self.leftArm.hprInterval(1.0, Vec3(180, 90, 0)))
block = Sequence(*blocking_animation)
block.start()
# def charge(self):
# #self.play(charge_animation)
# self.charged = True
# self.set_charge_image("on")
def shoot(self, target):
# if self.charged:
# ###Rodney shoot animation
# self.app.rodProjectiles.append(Projectile(self.app, "PureMagicApp/Maya_Assets/scenes/projectile.egg", self.getPos(), target, "rodney"))
# self.app.rodProjectiles[-1].shoot()
# self.charged = False
# self.set_charge_image("off")
# else:
# self.play(uncharged animation)
self.app.rodProjectiles.append(
Projectile(self.app,
"PureMagicApp/Maya_Assets/scenes/projectile.egg",
self.getPos(), target, "rodney"))
self.app.rodProjectiles[-1].shoot()
def die(self):
self.app.game_over()
#TODO uncoment out rodneyloosingLives
def get_hit(self):
if not self.block:
self.lives -= 1
# self.play(get hit animation)
if self.lives == 0:
self.die()
else:
self.set_life_image()
def blocks(self):
self.set_shield_image("on")
self.block = True
#self.play(blocking animation)
#self.pose(blocking animation) #### last frame for 1 second
def unblocks(self):
self.set_shield_image("off")
self.block = False
def init_mouse_control_event(self):
props = WindowProperties()
#props.setCursorHidden(True)
self.app.win.requestProperties(props)
def mouse_control_event(self, task):
if self.app.mouseWatcherNode.hasMouse():
pres_y = self.app.mouseWatcherNode.getMouseY()
pres_x = self.app.mouseWatcherNode.getMouseX()
if self.block and pres_x > BLOCK_TRIGGER:
self.unblocks()
# TODO: add the scaling factor of the screen size so that we make the line at 0.4 * screenLength
if self.last_y < self.app.WINDOW_SIZE_Y * SHOOT_TRIGGER and pres_y > self.app.WINDOW_SIZE_Y * SHOOT_TRIGGER:
ratio_y = self.map(pres_y) - self.map(self.last_y)
ratio_x = self.map(pres_x) - self.map(self.last_x)
if ratio_y == 0: ratio_y = 0.0001
degree = math.degrees(math.atan(ratio_x / ratio_y))
self.shoot(self.scale(degree))
#TODO: convert degree(should be between 0-180) to a number within the x constraints of profs motion
elif pres_y < BLOCK_TRIGGER:
self.blocks()
self.last_x = self.app.mouseWatcherNode.getMouseX()
self.last_y = self.app.mouseWatcherNode.getMouseY()
task.delayTime = 0.15
return task.again
def scale(self, degree):
#magic numbers are adjustments with 30 = to profs y pos, 0 profs z pos.
return (degree // 2 + 12, 30, 0)
def map(self, num):
new_num = (num + 100) / 2
return new_num
class BSpecial(Bar):
def __init__(self):
Bar.__init__(self)
#-----------------------------------------------------------------------------------------------------------------------------------------------
#---------------------------------------------------VARIABLE DECLARATION------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Init the bar with alpha sprites
self.cereal = False
self.specialCereal = OnscreenImage(
image="./tex/cereal_not_special.png",
pos=(0.43, 0, 0.87),
hpr=None,
scale=0.11,
color=None,
parent=None,
sort=1)
self.specialCereal.setTransparency(TransparencyAttrib.MAlpha)
self.banana = False
self.specialBanana = OnscreenImage(
image="./tex/banana_not_special.png",
pos=(0.63, 0, 0.87),
hpr=None,
scale=0.11,
color=None,
parent=None,
sort=1)
self.specialBanana.setTransparency(TransparencyAttrib.MAlpha)
self.cheese = False
self.specialCheese = OnscreenImage(
image="./tex/cheese_not_special.png",
pos=(0.83, 0, 0.87),
hpr=None,
scale=0.11,
color=None,
parent=None,
sort=1)
self.specialCheese.setTransparency(TransparencyAttrib.MAlpha)
self.tomato = False
self.specialTomato = OnscreenImage(
image="./tex/tomato_not_special.png",
pos=(1.03, 0, 0.87),
hpr=None,
scale=0.11,
color=None,
parent=None,
sort=1)
self.specialTomato.setTransparency(TransparencyAttrib.MAlpha)
self.egg = False
self.specialEgg = OnscreenImage(image="./tex/egg_not_special.png",
pos=(1.23, 0, 0.87),
hpr=None,
scale=0.11,
color=None,
parent=None,
sort=1)
self.specialEgg.setTransparency(TransparencyAttrib.MAlpha)
#end __init__
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------FUNCTIONS----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# It makes visible (change alpha sprite) the item corresponding to the type given
def itemCollected(self, type):
if type == "GRAIN":
self.cereal = True
self.specialCereal.setImage("./tex/cereal_special.png")
self.specialCereal.setTransparency(TransparencyAttrib.MAlpha)
if type == "FRUIT":
self.banana = True
self.specialBanana.setImage("./tex/banana_special.png")
self.specialBanana.setTransparency(TransparencyAttrib.MAlpha)
if type == "MILK":
self.cheese = True
self.specialCheese.setImage("./tex/cheese_special.png")
self.specialCheese.setTransparency(TransparencyAttrib.MAlpha)
if type == "VEGETABLE":
self.tomato = True
self.specialTomato.setImage("./tex/tomato_special.png")
self.specialTomato.setTransparency(TransparencyAttrib.MAlpha)
if type == "FISH":
self.egg = True
self.specialEgg.setImage("./tex/egg_special.png")
self.specialEgg.setTransparency(TransparencyAttrib.MAlpha)
#end itemCollected
# It puts the bar at the same characteristics as its initialization
def reInit(self):
self.cereal = False
self.specialCereal.setImage("./tex/cereal_not_special.png")
self.specialCereal.setTransparency(TransparencyAttrib.MAlpha)
self.banana = False
self.specialBanana.setImage("./tex/banana_not_special.png")
self.specialBanana.setTransparency(TransparencyAttrib.MAlpha)
self.cheese = False
self.specialCheese.setImage("./tex/cheese_not_special.png")
self.specialCheese.setTransparency(TransparencyAttrib.MAlpha)
self.tomato = False
self.specialTomato.setImage("./tex/tomato_not_special.png")
self.specialTomato.setTransparency(TransparencyAttrib.MAlpha)
self.egg = False
self.specialEgg.setImage("./tex/egg_not_special.png")
self.specialEgg.setTransparency(TransparencyAttrib.MAlpha)
#end reInit
# It check if all the special items are collected.
# Return true if it's correct.
def hasAllSpecial(self):
if ((self.cereal == True) and (self.banana == True)
and (self.cheese == True) and (self.tomato == True)
and (self.egg == True)):
return True
else:
return False
#end hasAllSpecial
# It makes disappear the bar
def hide(self):
self.specialCereal.hide()
self.specialBanana.hide()
self.specialCheese.hide()
self.specialTomato.hide()
self.specialEgg.hide()
#end hide
# It makes appear the bar
def show(self):
self.specialCereal.show()
self.specialBanana.show()
self.specialCheese.show()
self.specialTomato.show()
self.specialEgg.show()
class MyApp(ShowBase):
gameMode = "Intro"
def __init__(self):
ShowBase.__init__(self)
#self.cameraSetup()
self.setupKeyboard()
self.initIntro()
def gameChangeMode(self):
if base.gameMode == "Intro":
self.initIntro()
elif base.gameMode == "Convo":
self.initConvo()
def initIntro(self):
self.fadeAlpha = 0.0
self.fadeTime = 30.0
self.fadeInc = 1.0/self.fadeTime
self.fadeDir = "up"
self.sceneImage = OnscreenImage(image = "images/scene.png", scale = (1920.0/1080.0,1,1))
self.sceneImage.setTransparency(TransparencyAttrib.MAlpha)
self.sceneImage.setAlphaScale(self.fadeAlpha)
self.imageNumber = 0
self.sceneImageList = ["images/scene.png","images/image1.jpg"]
#self.texty = OnscreenText(str(self.fadeAlpha))
taskMgr.add(self.gameIntroUpdate, "GameIntroUpdate")
def gameIntroUpdate(self, task):
self.slideManager()
if (base.gameMode != "Intro"):
self.gameChangeMode()
return Task.done
return Task.cont
def cameraSetup(self):
base.camLens.setAspectRatio(1920.0/1080.0)
def slideManager(self):
if self.fadeDir == "up" and self.fadeAlpha<1:
self.fadeAlpha += self.fadeInc
self.sceneImage.setAlphaScale(self.fadeAlpha)
#self.texty.setText(str(self.fadeAlpha))
if self.fadeDir == "down" and self.fadeAlpha > 0:
self.fadeAlpha -= self.fadeInc
self.sceneImage.setAlphaScale(self.fadeAlpha)
if self.fadeDir == "up" and self.fadeAlpha >= 1:
self.fadeDir = "down"
if self.fadeDir == "down" and self.fadeAlpha <= 0:
if self.imageNumber < 1:
self.fadeDir = "up"
self.sceneImage.setImage(self.nextImage())
self.sceneImage.setTransparency(TransparencyAttrib.MAlpha)
self.sceneImage.setAlphaScale(self.fadeAlpha)
else:
self.fadeDir = "up"
base.gameMode = "Convo"
self.sceneImage.setImage(self.sceneImageList[self.imageNumber])
self.sceneImage.setTransparency(TransparencyAttrib.MAlpha)
self.sceneImage.setAlphaScale(self.fadeAlpha)
def nextImage(self):
self.imageNumber += 1
return self.sceneImageList[self.imageNumber]
def initConvo(self):
self.textToType = "This will be used for talking\nThis is a good conversation box"
self.textVisible = ""
self.strOptionA = "Yes"
self.strOptionB = "No"
self.strOptionC = "Maybe"
self.convoResponseSelected = False
self.convoDepth = "1"
self.intOptionCount = 3
#self.txtConvo = OnscreenText(self.textVisible, align = TextNode.ALeft)
self.txtConvo = TextNode("Texty Bastard")
self.txtConvo.setText(self.textToType)
self.txtReply = TextNode("reply")
self.txtReply.setText("")
self.intHover = 0
#self.txtConvo.setFrameColor(0, 0, 1, 1)
#self.txtConvo.setFrameAsMargin(0.2, 0.2, 0.1, 0.1)
myFrame = DirectFrame(frameColor=(0.8, 0.8, 0.8, 0.4),
frameSize=(-1, 0, -1, 0))
nodePathConvo = aspect2d.attachNewNode(self.txtConvo)
nodePathConvo.setScale(0.07)
nodePathConvo.setPos(-1, 0, -0.1)
self.i = 0
self.indent = 0.0
self.selectedResponse = 0
self.txtOptionA = OnscreenText(text = "", pos = (-1,-0.6), align = TextNode.ALeft)
self.txtOptionB = OnscreenText(text = "", pos = (-1,-0.7), align = TextNode.ALeft)
self.txtOptionC = OnscreenText(text = "", pos = (-1,-0.8), align = TextNode.ALeft)
taskMgr.add(self.gameConvoUpdate, "GameConvoUpdate")
def gameConvoUpdate(self, task):
if (len(self.textVisible) != len(self.textToType)):
task.delayTime = 0.001
while (self.i < len(self.textToType)):
self.textVisible += self.textToType[self.i]
self.txtConvo.setText(self.textVisible)
self.i += 1
return Task.again
else:
taskMgr.add(self.gameConvoOptions, "ConvoOptions")
return Task.done
def gameConvoOptions(self, task):
self.txtOptionA.setText(self.strOptionA)
self.txtOptionB.setText(self.strOptionB)
self.txtOptionC.setText(self.strOptionC)
if self.convoResponseSelected == True:
if self.convoCheckBranch("01", self.convoDepth):
#self.txtConvo.setText(self.convoGetStrings("01", self.convoDepth))
self.convoNextDialogue("01", self.convoDepth)
else:
#self.txtConvo.setText("It DIDn't worked")
self.convoDepth = "1"
self.convoNextDialogue("01", self.convoDepth)
return Task.done
elif self.selectedResponse == 0:
if self.intOptionCount > 0:
self.txtOptionA.setX(-1+self.indent)
self.txtOptionA.setFg(fg = (1,0,0,1))
if self.intOptionCount > 1:
self.txtOptionB.setX(-1)
self.txtOptionB.setFg(fg = (0,0,0,1))
if self.intOptionCount > 2:
self.txtOptionC.setX(-1)
self.txtOptionC.setFg(fg = (0,0,0,1))
self.indent = self.getIndent(self.indent,0.01,0.1)
return Task.again
elif self.selectedResponse == 1:
if self.intOptionCount > 0:
self.txtOptionA.setX(-1)
self.txtOptionA.setFg(fg = (0,0,0,1))
if self.intOptionCount > 1:
self.txtOptionB.setX(-1+self.indent)
self.txtOptionB.setFg(fg = (1,0,0,1))
if self.intOptionCount > 2:
self.txtOptionC.setX(-1)
self.txtOptionC.setFg(fg = (0,0,0,1))
self.indent = self.getIndent(self.indent,0.01,0.1)
return Task.again
elif self.selectedResponse == 2:
if self.intOptionCount > 0:
self.txtOptionA.setX(-1)
self.txtOptionA.setFg(fg = (0,0,0,1))
if self.intOptionCount > 1:
self.txtOptionB.setX(-1)
self.txtOptionB.setFg(fg = (0,0,0,1))
if self.intOptionCount > 2:
self.txtOptionC.setX(-1+self.indent)
self.txtOptionC.setFg(fg = (1,0,0,1))
self.indent = self.getIndent(self.indent,0.01,0.1)
return Task.again
def convoGetStrings(self,npcId,depth):
if self.convoCheckBranch(npcId,depth) != True:
return "#Error# String Not Found\nLooking for: "+"("+str(npcId)+")."+depth+":"
char = ""
line = ""
feed = ""
path = os.path.abspath(os.getcwd())
f = open(path+"\\text\\stringsConvo.txt","r")
while line != "("+str(npcId)+")."+depth+":":
while char != ":":
char = f.readline(1)
line += char
feed += "\n"+line
if line != "("+str(npcId)+")."+depth+":":
char = ""
line = ""
f.readline()
print(feed + " Selected")
f.readline(1)
line = f.readline()
line = line.replace("##", "\n")
f.close()
return line
def convoCheckBranch(self,npcId,depth):
path = os.path.abspath(os.getcwd())
f = open(path+"\\text\\stringsConvo.txt","r")
char = ""
line = ""
branchFound = False
while line != "<END>:":
char = ""
line = ""
while char != ":":
char = f.readline(1)
line += char
if line == "<END>:":
f.close()
return False
elif line == "("+str(npcId)+")."+str(depth)+":":
f.close()
return True
else:
f.readline()
def convoNextDialogue(self,npcId,depth):
self.textToType = self.convoGetStrings(npcId, depth)
self.intOptionCount = self.convoGetOptionCount(npcId, depth)
if self.intOptionCount == 1:
self.strOptionA = self.convoGetStrings(npcId, depth+".A")
self.strOptionB = ""
self.strOptionC = ""
elif self.intOptionCount == 2:
self.strOptionA = self.convoGetStrings(npcId, depth+".A")
self.strOptionB = self.convoGetStrings(npcId, depth+".B")
self.strOptionC = ""
elif self.intOptionCount == 3:
self.strOptionA = self.convoGetStrings(npcId, depth+".A")
self.strOptionB = self.convoGetStrings(npcId, depth+".B")
self.strOptionC = self.convoGetStrings(npcId, depth+".C")
else:
self.strOptionA = ""
self.strOptionB = ""
self.strOptionC = ""
self.textVisible = ""
self.txtOptionA.setText("")
self.txtOptionB.setText("")
self.txtOptionC.setText("")
self.txtConvo.setText(self.textVisible)
#self.intOptionCount = 2
self.selectedResponse = 0
self.i = 0
self.convoResponseSelected = False
taskMgr.add(self.gameConvoUpdate, "GameConvoUpdate")
def convoGetOptionCount(self,npcId,depth):
if self.convoCheckBranch(npcId,depth+".A") and self.convoCheckBranch(npcId,depth+".B") and self.convoCheckBranch(npcId,depth+".C"):
return 3
elif self.convoCheckBranch(npcId,depth+".A") and self.convoCheckBranch(npcId,depth+".B"):
return 2
elif self.convoCheckBranch(npcId,depth+".A"):
return 1
else:
return 0
def getIndent(self, value, increment, limit):
if (value + increment >= limit):
return limit
else:
return value+increment
def setupKeyboard(self):
self.accept("arrow_down", self.convoOptionDown)
self.accept("arrow_up", self.convoOptionUp)
self.accept("enter",self.convoOptionSelect)
def convoOptionUp(self):
self.indent = 0.0
if self.selectedResponse == 0:
self.selectedResponse = self.intOptionCount-1
elif self.selectedResponse > 0:
self.selectedResponse -= 1
def convoOptionDown(self):
self.indent = 0.0
if self.selectedResponse < self.intOptionCount-1:
self.selectedResponse += 1
elif self.selectedResponse == self.intOptionCount-1:
self.selectedResponse = 0
def convoOptionSelect(self):
if self.selectedResponse == 0:
self.convoDepth += ".A.1"
elif self.selectedResponse == 1:
self.convoDepth += ".B.1"
elif self.selectedResponse == 2:
self.convoDepth += ".C.1"
self.convoResponseSelected = True
class Hud(DirectObject):
def __init__(self):
self.frameCharStatus = DirectFrame(
# size of the frame
frameSize = (0, .8,
-.20, 0),
# bg color Transparent
frameColor = (0, 0, 0, 0))
self.frameCharStatus.reparentTo(base.a2dTopLeft)
self.statusHealth = OnscreenImage(
image = "HUD_Life100.png",
scale = (0.1, 1, 0.1),
pos = (0.085, 0, -0.085))
self.statusHealth.setTransparency(True)
self.statusHealth.reparentTo(self.frameCharStatus)
self.statusWeapon = OnscreenImage(
image = "WeaponMG.png",
scale = (0.1, 1, 0.1),
pos = (0.285, 0, -0.085))
self.statusWeapon.setTransparency(True)
self.statusWeapon.reparentTo(self.frameCharStatus)
self.highscore = DirectLabel(
text = "0",
text_fg = (0,0,0,1),
text_align = TextNode.ALeft,
frameColor = (0,0,0,0),
pos = (0.4,0,-0.12),
scale = 0.15)
self.highscore.setTransparency(True)
self.highscore.reparentTo(self.frameCharStatus)
def show(self):
self.frameCharStatus.show()
self.accept("setHighscore", self.setHighscore)
self.accept("setHealth", self.setHealth)
def hide(self):
self.frameCharStatus.hide()
self.ignore("setHighscore")
self.ignore("setHealth")
def setHighscore(self, score):
self.highscore["text"] = str(score)
def setHealth(self, hp):
if hp > 75.0:
self.statusHealth.setImage("HUD_Life100.png")
elif hp > 50.0:
self.statusHealth.setImage("HUD_Life75.png")
elif hp > 25.0:
self.statusHealth.setImage("HUD_Life50.png")
elif hp > 0:
self.statusHealth.setImage("HUD_Life25.png")
else:
print "Your dead!"
self.statusHealth.setImage("HUD_Life0.png")
self.statusHealth.setTransparency(True)
def setWeapon(self, weaponType):
if weaponType == "Pistol":
self.statusWeapon.setImage("WeaponPistol.png")
else:
self.statusWeapon.setImage("WeaponMG.png")
self.statusWeapon.setTransparency(True)
class InGame(DirectObject):
def __init__(self, parent):
self.active = False
self.paused = True
self.parent = parent
self.mainFrame = DirectFrame(frameColor=(0,0,0,0),
frameSize=(-0.2,0.2,0.4,-0.4 ))
self.continueImage = OnscreenImage(image = 'Models/menu/Resume.png', pos = (0,0,0.5), scale = 0.2)
self.continueImage.setTransparency(TransparencyAttrib.MMultisampleMask)
self.restartImage = OnscreenImage(image = 'Models/menu/Restart.png', pos = (0,0,0), scale = 0.2)
self.restartImage.setTransparency(TransparencyAttrib.MMultisampleMask)
self.exitImage = OnscreenImage(image = 'Models/menu/Exit.png', pos = (0,0,-0.5), scale = 0.2)
self.exitImage.setTransparency(TransparencyAttrib.MMultisampleMask)
self.cont = DirectButton(parent = self.mainFrame,
pos = (0,0,0.5), scale=.2,
frameColor = (0,0,0,0),
frameSize = (-1,1,-1,1),
command = self.togglePause)
self.cont.guiItem.setActive(True)
self.cont.bind(DGG.WITHIN, self.mouseOverContinue, [self.cont])
self.cont.bind(DGG.WITHOUT, self.mouseOutContinue, [self.cont])
self.restart = DirectButton(parent = self.mainFrame,
pos = (0,0,0), scale=.2,
frameColor = (0,0,0,0),
frameSize = (-1,1,-1,1),
command = self.restart)
self.restart.guiItem.setActive(True)
self.restart.bind(DGG.WITHIN, self.mouseOverRestart, [self.restart])
self.restart.bind(DGG.WITHOUT, self.mouseOutRestart, [self.restart])
self.exit = DirectButton(parent = self.mainFrame,
pos = (0,0,-0.5), scale=.2,
frameColor = (0,0,0,0),
frameSize = (-1,1,-1,1),
command = parent.exit)
self.exit.guiItem.setActive(True)
self.exit.bind(DGG.WITHIN, self.mouseOverExit, [self.exit])
self.exit.bind(DGG.WITHOUT, self.mouseOutExit, [self.exit])
#self.firstTransition = Transitions(loader)
#self.firstTransition.setFadeColor(0,0,0)
self.continueImage.hide()
self.restartImage.hide()
self.exitImage.hide()
self.deactivate()
#Change text color on mouseover
def mouseOverContinue(self, frame, mousePos):
self.continueImage.setImage('Models/menu/Resume2.png')
self.continueImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def mouseOutContinue(self, frame, mousePos):
if self.paused:
self.continueImage.setImage('Models/menu/Resume.png')
self.continueImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def mouseOverRestart(self, frame, mousePos):
self.restartImage.setImage('Models/menu/Restart2.png')
self.restartImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def mouseOutRestart(self, frame, mousePos):
if self.paused:
self.restartImage.setImage('Models/menu/Restart.png')
self.restartImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def mouseOverExit(self, frame, mousePos):
self.exitImage.setImage('Models/menu/Exit2.png')
self.exitImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def mouseOutExit(self, frame, mousePos):
if self.paused:
self.exitImage.setImage('Models/menu/Exit.png')
self.exitImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def activate(self):
#self.firstTransition.fadeOut(3)
self.active = True
self.paused = False
self.play = Play(self)
#self.firstTransition.fadeOut(3)
def deactivate(self):
self.mainFrame.hide()
self.active = False
self.paused = True
def togglePause(self):
self.continueImage.setImage('Models/menu/Resume.png')
self.continueImage.setTransparency(TransparencyAttrib.MMultisampleMask)
self.restartImage.setImage('Models/menu/Restart.png')
self.restartImage.setTransparency(TransparencyAttrib.MMultisampleMask)
self.play.togglePause()
def restart(self):
self.restartImage.setImage('Models/menu/Restart.png')
self.restartImage.setTransparency(TransparencyAttrib.MMultisampleMask)
self.togglePause()
self.play.player.die(self.play.level)
def __del__(self):
self.cont.destroy()
self.exit.destroy()
self.mainFrame.destroy()
class Game(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# режим редактирования
self.edit_mode = True
# создаём менеджер карты
self.map_manager = MapManager()
# создаём контроллер мышки и клавиатуры
self.controller = Controller()
# создаём редактор
self.editor = Editor(self.map_manager)
# загрузка модели
sky = loader.loadModel('sky/skybox')
# перемещаем модель в рендер
sky.reparentTo(render)
# устанавливаем масштаб и позицию для модели
sky.setScale(100)
# загружаем картинку курсора
self.pointer = OnscreenImage(image='target.png',
pos=(0, 0, 0),
scale=0.08)
# устанавливаем прозрачность
self.pointer.setTransparency(TransparencyAttrib.MAlpha)
# имя файла для сохранения и загрузки карт
self.file_name = "testmap.dat"
# номер строки для текста на экране
self.text_row = 1
# вывод на экран инструкций
self.addInstructions("[Tab]: Edit/Game mode")
self.addInstructions("Move mouse: Rotate camera")
self.addInstructions("Left mouse button: Add block")
self.addInstructions("Right mouse button: Remove block")
self.addInstructions("[W]: Move Forward")
self.addInstructions("[S]: Move Back")
self.addInstructions("[A]: Move Left")
self.addInstructions("[D]: Move Right")
self.addInstructions("[E]: Move Up")
self.addInstructions("[Q]: Move Down")
self.addInstructions("[Space]: Jump")
self.addInstructions("[F1]: Basic map")
self.addInstructions("[F2]: Random map")
self.addInstructions("[F3]: Save map")
self.addInstructions("[F4]: Load map")
self.addInstructions("[1-8]: Select color")
self.addInstructions("Press ESC to exit")
# элемент текста оповещений
self.infoText = OnscreenText(text='',
scale=0.06,
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1),
align=TextNode.ALeft,
parent=base.a2dBottomLeft,
pos=(0.08, 0.08))
self.accept("f1", self.basicMap)
self.accept("f2", self.generateRandomMap)
self.accept("f3", self.saveMap)
self.accept("f4", self.loadMap)
self.accept("1", self.setColor, [(1, 1, 1, 1), 'white'])
self.accept("2", self.setColor, [(1, 0.3, 0.3, 1), 'red'])
self.accept("3", self.setColor, [(0.3, 1, 0.3, 1), 'green'])
self.accept("4", self.setColor, [(0.3, 0.3, 1, 1), 'blue'])
self.accept("5", self.setColor, [(1, 1, 0.3, 0.5), 'yellow'])
self.accept("6", self.setColor, [(0.3, 1, 1, 0.5), 'aqua'])
self.accept("7", self.setColor, [(1, 0.3, 1, 0.5), 'purple'])
self.accept("8", self.setColor, [None, 'random'])
base.accept("tab", self.switchEditMode)
self.setInfoText('')
self.setColor(None, 'random')
# генерируем случайный уровень
self.generateRandomMap()
def setInfoText(self, text):
self.infoText.setText(text)
if taskMgr.hasTaskNamed('clearText'):
taskMgr.remove('clearText')
taskMgr.doMethodLater(3, self.clearText, 'clearText')
def basicMap(self):
if not self.edit_mode:
self.controller.setEditMode(self.edit_mode)
self.map_manager.basicMap()
self.setInfoText('Basic map generated')
def generateRandomMap(self):
if not self.edit_mode:
self.controller.setEditMode(self.edit_mode)
self.map_manager.generateRandomMap()
self.setInfoText('Random map generated')
def saveMap(self):
self.map_manager.saveMap(self.file_name)
self.setInfoText('Map saved to "' + self.file_name + '"')
def loadMap(self):
if not self.edit_mode:
self.controller.setEditMode(self.edit_mode)
self.map_manager.loadMap(self.file_name)
self.setInfoText('Map loaded from "' + self.file_name + '"')
def setColor(self, color, name):
if self.edit_mode:
self.map_manager.setColor(color)
self.setInfoText('Set color - ' + name)
def switchEditMode(self):
self.edit_mode = not self.edit_mode
self.controller.setEditMode(self.edit_mode)
self.editor.setEditMode(self.edit_mode)
if self.edit_mode:
self.pointer.setImage(image='target.png')
else:
self.pointer.setImage(image='target1.png')
self.pointer.setTransparency(TransparencyAttrib.MAlpha)
def addInstructions(self, msg):
OnscreenText(text=msg,
scale=0.05,
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1),
align=TextNode.ALeft,
parent=base.a2dTopLeft,
pos=(0.08, -self.text_row * 0.055 - 0.04))
self.text_row += 1
def clearText(self, task):
self.setInfoText('')
class World(DirectObject):
def __init__(self):
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0, "shoot":0}
base.win.setClearColor(Vec4(0,0,0,1))
# Post the instructions
self.inst6 = addInstructions(0.95, "Mad Max's Revenge!")
self.inst1 = addInstructions(0.90, "[ESC]: Quit")
self.inst2 = addInstructions(0.85, "[a]: Left Turn")
self.inst3 = addInstructions(0.80, "[d]: Right Turn")
self.inst4 = addInstructions(0.75, "[w]: Drive Forward")
self.inst4 = addInstructions(0.70, "[s]: Reverse")
self.inst5 = addInstructions(0.65, "[mouse]: Fire Rocket")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("Assets/Models/env") #models/environment
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.sky = loader.loadModel("Assets/Models/sky") #models/environment
self.sky.reparentTo(render)
self.sky.setPos(0,0,0)
# Create the main character, player
playerStartPos = Point3(8,14,1) #self.environ.find("**/start_point").getPos()
enemyStartPos = Point3(-7,-8,1) #self.environ.find("**/start_point").getPos()
#~ print enemyStartPos
enemyStartPos.addX(1.0)
enemyStartPos.addY(1.0)
#~ print enemyStartPos
self.player = Actor("Assets/Models/player_model", {"drive":"Assets/Models/player_drive", "fire":"Assets/Models/player_turret", "drivefire":"Assets/Models/player_both"})
self.player.reparentTo(render)
self.player.setScale(0.1)
self.player.setPos(playerStartPos)
#~ self.playerdrive=self.player.actorInterval("drive")
#~ self.playerfire=self.player.actoraaaaaaaInterval("fire")
#~ self.playerdrivefire=self.player.actorInterval("drivefire")
# Create the enemy, Enemy
self.enemy = Actor("Assets/Models/enemy_model", {"drive":"Assets/Models/enemy_drive", "fire":"Assets/Models/enemy_turret", "drivefire":"Assets/Models/enemy_both"})
self.enemy.reparentTo(render)
self.enemy.setScale(0.1)
tex = loader.loadTexture("Assets/Models/cartexture1.png")
self.enemy.setTexture(tex, 1)
self.enemy.setPos(enemyStartPos)
self.enemyrockettiming = globalClock.getFrameTime()
#print self.enemy.getCurrentAnim()
#print self.enemy.getCurrentAnim()
#~ self.enemydrive=self.enemy.actorInterval("drive")
#~ self.enemyfire=self.enemy.actorInterval("fire")
#~ self.enemydrivefire=self.enemy.actorInterval("drivefire")
self.music = loader.loadMusic("Assets/Sound/music.mp3")
SoundInterval(self.music).loop()
audio3d.attachSoundToObject(EnemyRunning, self.enemy)
audio3d.attachSoundToObject(EnemyIdling, self.enemy)
backward = self.enemy.getNetTransform().getMat().getRow3(1)
backward.setZ(0)
backward.normalize()
#self.enemy.setPos(self.enemy.getPos() - backward*(50))
#Set up the lighting
self.playerleftlight=self.player.attachNewNode(Spotlight("playerheadleft"))
self.playerleftlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1))
self.playerleftlight.node().setLens( PerspectiveLens() )
self.playerleftlight.node().getLens().setFov( 50, 50)
self.playerleftlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) )
self.playerleftlight.node().setExponent( 60.0 )
self.playerleftlight.setPos(-1, -0.1, 1.5)
self.playerleftlight.setHpr(180, -10, 0)
render.setLight(self.playerleftlight)
self.playerrightlight=self.player.attachNewNode(Spotlight("playerheadright"))
self.playerrightlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1))
self.playerrightlight.node().setLens( PerspectiveLens() )
self.playerrightlight.node().getLens().setFov( 50, 50)
self.playerrightlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) )
self.playerrightlight.node().setExponent( 60.0 )
self.playerrightlight.setPos(1, -0.1, 1.5)
self.playerrightlight.setHpr(180, -10, 0)
render.setLight(self.playerrightlight)
self.playerlightson=1
self.enemyleftlight=self.enemy.attachNewNode(Spotlight("enemyheadleft"))
self.enemyleftlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1))
self.enemyleftlight.node().setLens( PerspectiveLens() )
self.enemyleftlight.node().getLens().setFov( 50, 50)
self.enemyleftlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) )
self.enemyleftlight.node().setExponent( 60.0 )
self.enemyleftlight.setPos(-1, -0.1, 1.5)
self.enemyleftlight.setHpr(180, -10, 0)
render.setLight(self.enemyleftlight)
self.enemyrightlight=self.enemy.attachNewNode(Spotlight("enemyheadright"))
self.enemyrightlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1))
self.enemyrightlight.node().setLens( PerspectiveLens() )
self.enemyrightlight.node().getLens().setFov( 50, 50)
self.enemyrightlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) )
self.enemyrightlight.node().setExponent( 60.0 )
self.enemyrightlight.setPos(1, -0.1, 1.5)
self.enemyrightlight.setHpr(180, -10, 0)
render.setLight(self.enemyrightlight)
self.enemylightson=1
self.spotlight=camera.attachNewNode(PointLight("spotlight"))
#self.spotlight.setPos(0, 3, 0.5)
#self.spotlight.setHpr(0, 0, 0)
self.spotlight.node().setColor(Vec4(1, 1, 1, 1))
#self.spotlight.node().setLens( PerspectiveLens() )
#self.spotlight.node().getLens().setFov( 180, 120)
self.spotlight.node().setAttenuation( Vec3( 1, 0, 0.05 ))
#self.spotlight.node().setExponent( 60.0 )
render.setLight(self.spotlight)
self.playerlight=self.player.attachNewNode(PointLight("spotlight"))
self.playerlight.node().setColor(Vec4(1, 1, 1, 1))
#self.spotlight.node().setLens( PerspectiveLens() )
#self.spotlight.node().getLens().setFov( 180, 120)
self.playerlight.node().setAttenuation( Vec3( 1, 0, 0.05 ))
#self.spotlight.node().setExponent( 60.0 )
render.setLight(self.playerlight)
self.ambientlight=self.sky.attachNewNode(AmbientLight("ambientLight"))
self.ambientlight.node().setColor(Vec4(1, 1, 1, 1))
self.sky.setLight(self.ambientlight)
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("a", self.setKey, ["left",1])
self.accept("d", self.setKey, ["right",1])
self.accept("w", self.setKey, ["forward",1])
self.accept("s", self.setKey, ["backward",1])
self.accept("a-up", self.setKey, ["left",0])
self.accept("d-up", self.setKey, ["right",0])
self.accept("w-up", self.setKey, ["forward",0])
self.accept("s-up", self.setKey, ["backward",0])
self.accept("l", self.playerLights,[])
self.accept("mouse1", self.setKey, ["shoot", 1])
self.accept("mouse1-up", self.setKey, ["shoot", 0]) #self.shootRocketshootRocket
taskMgr.add(self.playerMove,"moveTask")
taskMgr.add(self.enemyMove,"moveTask")
taskMgr.add(self.shoot,"shootTask")
taskMgr.add(self.rocketCollision,"rocketCollision")
# Game state variables
self.prevtime = 0
self.isMoving = False
self.prevShotTime = 0
self.prevEnemyMoveTime = 0
# Set up the camera
base.disableMouse()
base.camera.setPos(self.player.getX(),self.player.getY()+10,2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above player's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.playerGroundRay = CollisionRay()
self.playerGroundRay.setOrigin(0,0,1000)
self.playerGroundRay.setDirection(0,0,-1)
self.playerGroundCol = CollisionNode('playerRay')
self.playerGroundCol.addSolid(self.playerGroundRay)
self.playerGroundCol.setFromCollideMask(BitMask32.bit(3))
self.playerGroundCol.setIntoCollideMask(BitMask32.allOff())
self.playerGroundColNp = self.player.attachNewNode(self.playerGroundCol)
self.playerGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.playerGroundColNp, self.playerGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(3))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.playerGroundColNp.show()
#self.camGroundColNp.show()
#Uncomment this line to show a visual representation of the
#collisions occuring
#self.cTrav.showCollisions(render)
#Code for Enemy player
self.enemyGroundRay = CollisionRay()
self.enemyGroundRay.setOrigin(0,0,1000)
self.enemyGroundRay.setDirection(0,0,-1)
self.enemyGroundCol = CollisionNode('enemyRay')
self.enemyGroundCol.addSolid(self.enemyGroundRay)
self.enemyGroundCol.setFromCollideMask(BitMask32.bit(3))
self.enemyGroundCol.setIntoCollideMask(BitMask32.allOff())
self.enemyGroundColNp = self.enemy.attachNewNode(self.enemyGroundCol)
self.enemyGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.enemyGroundColNp, self.enemyGroundHandler)
self.cRocketHandler = CollisionHandlerQueue()
self.worldEdge = CollisionInvSphere(0, 0, 0, 50)
cNode = CollisionNode("worldEdge")
cNode.addSolid(self.worldEdge)
cNode.setFromCollideMask(BitMask32.allOff())
cNode.setIntoCollideMask(BitMask32.allOn())
self.worldEdgeNp=self.environ.attachNewNode(cNode)
#self.cTrav.addCollider(self.worldEdgeNp, self.cRocketHandler)
#cNP = render.attachNewNode(cNode)
cNode2 = CollisionNode("wall")
cNode2.addSolid(CollisionPlane(Plane(Vec3(-1,0,0), Point3(22.5,0,0))))
cNode2.addSolid(CollisionPlane(Plane(Vec3(1,0,0), Point3(-22.5,0,0))))
cNode2.addSolid(CollisionPlane(Plane(Vec3(0,-1,0), Point3(0,22.5,0))))
cNode2.addSolid(CollisionPlane(Plane(Vec3(0,1,0), Point3(0,-22.5,0))))
cNode2.setFromCollideMask(BitMask32.allOff())
cNode2.setIntoCollideMask(BitMask32.allOn())
cNP2=self.environ.attachNewNode(cNode2)
self.picker = CollisionTraverser() #Make a traverser
self.pq = CollisionHandlerQueue() #Make a handler
#Make a collision node for our picker ray
self.pickerNode = CollisionNode('mouseRay')
#Attach that node to the camera since the ray will need to be positioned
#relative to it
self.pickerNP = camera.attachNewNode(self.pickerNode)
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it
self.pickerNode.setFromCollideMask(BitMask32.allOn())
self.pickerRay = CollisionRay() #Make our ray
self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node
#Register the ray as something that can cause collisions
self.picker.addCollider(self.pickerNP, self.pq)
self.playerrocket = None
self.enemyrocket = None
self.enemyTurn = 0
self.enemyDestAng = 180
self.enemyHp = 3
self.playerHp = 3
#Collisions
self.setupCollisions()
self.playermoving = False
#setup hud
self.drawHud()
def drawHud(self):
#Player
OnscreenText(text="Player Health", style=1, fg=(1,1,1,1), pos=(0.85, 0.9), align=TextNode.ALeft, scale = .08)
self.playerHealthImg = OnscreenImage(image = 'Assets/Images/healthFull.png', pos = (1.05, 0, .84), scale = .12)
self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha)
#Enemy
OnscreenText(text="Enemy Health", style=1, fg=(1,1,1,1), pos=(0.85, 0.7), align=TextNode.ALeft, scale = .08)
self.enemyHealthImg = OnscreenImage(image = 'Assets/Images/healthFull.png', pos = (1.05, 0, .64), scale = .12)
self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha)
def updateGui(self):
#player bar
if self.playerHp == 2:
self.playerHealthImg.setImage('Assets/Images/healthMedium.png')
self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha)
elif self.playerHp == 1:
self.playerHealthImg.setImage('Assets/Images/healthLow.png')
self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha)
#enemy bar
if self.enemyHp == 2:
self.enemyHealthImg.setImage('Assets/Images/healthMedium.png')
self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha)
elif self.enemyHp == 1:
self.enemyHealthImg.setImage('Assets/Images/healthLow.png')
self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha)
def setupCollisions(self):
#player sphere
cPlayerSphere = CollisionSphere(Point3(0, 0, .5), 10)
cPlayerNode = CollisionNode("Player")
cPlayerNode.addSolid(cPlayerSphere)
cPlayerNode.setFromCollideMask(BitMask32.bit(4))
cPlayerNode.setIntoCollideMask(BitMask32(20))
cPlayerNP = self.player.attachNewNode(cPlayerNode)
self.cTrav.addCollider(cPlayerNP, self.playerGroundHandler)
#self.cTrav.addCollider(cPlayerNP, self.cRocketHandler)
#cPlayerNP.show()
#enemy sphere
cEnemySphere = CollisionSphere(Point3(0, 0, .5), 10)
cEnemyNode = CollisionNode("Enemy")
cEnemyNode.addSolid(cEnemySphere)
cEnemyNode.setFromCollideMask(BitMask32.bit(4))
cEnemyNode.setIntoCollideMask(BitMask32(18))
cEnemyNP = self.enemy.attachNewNode(cEnemyNode)
self.cTrav.addCollider(cEnemyNP, self.enemyGroundHandler)
#self.cTrav.addCollider(cEnemyNP, self.cRocketHandler)
#cEnemyNP.show()
def rocketCollision(self, task):
"""Check for rocket collisions with players and objects"""
toRemove = []
for i in range(self.cRocketHandler.getNumEntries()):
entry = self.cRocketHandler.getEntry(i)
#~ print entry
if entry.getFromNode().getName() == "PlayerRocket" and entry.getIntoNode().getName() == "Enemy":
self.enemyHp -= 1
self.updateGui()
if self.enemyHp == 0:
print "Victory!"
OnscreenText(text="Victory!", style=2, fg=(0,1,0,1),
pos=(-0.6, 0), align=TextNode.ALeft, scale = .5, shadow=(0,0,0,0))
self.playerHp += 5
#LerpFunc(end_game, fromData = 0, toData = 1, duration = 3.0,
#blendType = 'noBlend', extraArgs = [], name = None)
taskMgr.remove("moveTask")
taskMgr.remove("shootTask")
#print "GAME OVER, YOU WIN"
#sys.exit(0)
elif entry.getFromNode().getName() == "EnemyRocket" and entry.getIntoNode().getName() == "Player":
self.playerHp -= 1
self.updateGui()
if self.playerHp == 0:
#~ print "GAME OVER, YOU LOSE"
OnscreenText(text="Failure!", style=2, fg=(1,0,0,1),
pos=(-0.6, 0), align=TextNode.ALeft, scale = .5, shadow=(0,0,0,0))
self.enemyHp += 5
taskMgr.remove("moveTask")
taskMgr.remove("shootTask")
#Add to remove list
if entry.getFromNodePath() not in toRemove:
toRemove.append(entry.getFromNodePath())
#remove
for np in toRemove:
if np.getNode(0).getName() == "PlayerRocket":
if self.playerrocket:
self.playerrocket.kill_light()
#~ print "BOOM!, PLAYER ROCKET EXPLODED"
BoomSound.play()
RocketFire.stop()
Explosion.Explosion(self.playerrocket.rocket.getPos(), render)
self.playerrocket = None
np.getParent().remove()
else:
if self.enemyrocket:
self.enemyrocket.kill_light()
#~ print "BOOM!, ENEMY ROCKET EXPLODED"
BoomSound.play()
RocketFire.stop()
Explosion.Explosion(self.enemyrocket.rocket.getPos(), render)
self.enemyrocket = None
np.getParent().remove()
self.cRocketHandler.clearEntries()
return Task.cont
def shootPlayerRocket(self):
"""Shoot a player rocket"""
#Check to see if we can access the mouse. We need it to do anything else
if base.mouseWatcherNode.hasMouse():
#get the mouse position
mpos = base.mouseWatcherNode.getMouse()
#Set the position of the ray based on the mouse position
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
#Do the actual collision pass
pickerpoint=Point3(0,0,0)
self.picker.traverse(render)
for i in range(self.pq.getNumEntries()):
entry = self.pq.getEntry(i)
if entry.getFromNode().getName() == "mouseRay" and entry.getIntoNode().getName()=="terrain":
pickerpoint=entry.getSurfacePoint(render)
direction=pickerpoint-Point3(self.player.getX(), self.player.getY(), self.player.getZ()+0.5)
#~ if self.playerrocket is None:
#~ angle = math.radians(self.player.getH())
playerpos=self.player.getPos()
self.playerrocket = Rocket.Rocket(Point3(playerpos.getX(), playerpos.getY(), playerpos.getZ()+0.5), direction, "PlayerRocket", render)
self.playerrocket.setupCollision(self.cTrav, self.cRocketHandler)
RocketFire.play()
if self.player.getCurrentAnim()=="drive":
self.player.play("drivefire")
else:
self.player.play("fire")
def shootEnemyRocket(self):
"""Shoot a enemy rocket"""
if not (self.enemyrocket) and self.enemyrockettiming <= globalClock.getFrameTime() :
#~ angle = math.radians(self.enemy.getH())
#~ self.enemyrocket = Rocket.Rocket(self.enemy.getPos(), angle, "EnemyRocket", render)
#~ self.enemyrocket.setupCollision(self.cTrav, self.cRocketHandler)
direction = self.player.getPos() - self.enemy.getPos()
enemyPos = self.enemy.getPos()
self.enemyrocket = Rocket.Rocket(enemyPos + Point3(0,0,.5),direction,"EnemyRocket",render)
self.enemyrocket.setupCollision(self.cTrav, self.cRocketHandler)
RocketFire.play()
self.enemy.play("drivefire")
self.enemyrockettiming = globalClock.getFrameTime() + 2.0
#Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
def shoot(self, task):
elapsed = task.time - self.prevShotTime
if(self.keyMap["shoot"]!=0 and elapsed > 1):
self.shootPlayerRocket()
self.prevShotTime = task.time
return Task.cont
def playerLights(self):
if self.playerlightson:
self.playerleftlight.node().setColor(Vec4(0,0,0,1))
self.playerrightlight.node().setColor(Vec4(0,0,0,1))
self.playerlightson=0
else:
self.playerleftlight.node().setColor(Vec4(0.75,0.75,0.75,1))
self.playerrightlight.node().setColor(Vec4(0.75,0.75,0.75,1))
self.playerlightson=1
def enemyLights(self):
if self.enemylightson:
self.enemyleftlight.node().setColor(Vec4(0,0,0,1))
self.enemyrightlight.node().setColor(Vec4(0,0,0,1))
self.enemylightson=0
else:
self.enemyleftlight.node().setColor(Vec4(0.75,0.75,0.75,1))
self.enemyrightlight.node().setColor(Vec4(0.75,0.75,0.75,1))
self.enemylightson=1
def enemyMove(self, task):
elapsed = task.time - self.prevEnemyMoveTime
startpos = self.enemy.getPos()
#Calculate distance to the enemy
distvec = self.player.getPos() - self.enemy.getPos()
distvec.setZ(0)
dist = distvec.length()
backward = self.enemy.getNetTransform().getMat().getRow3(1)
backward.setZ(0)
backward.normalize()
#Drive!
if self.enemy.getCurrentAnim() is None:
self.enemy.loop("drive")
#Find the vector from the enemy to the player, then find the angle of that vector
vec = self.enemy.getPos() - self.player.getPos()
angle = math.degrees(math.atan2(vec.getX(), vec.getY()))
#Find the angle left to turn according to the enemy's current angle
angleToPlayer = (-self.enemy.getH() - angle) % 360
#Fire rocket if within 60 degree arc of player
#~ print angleToPlayer
if angleToPlayer < 30 or angleToPlayer > 330:
self.shootEnemyRocket()
#AI control code starts here
#enemyTurn is zero for heading straight, -1 to turn full left, +1 to turn full right
#Turning rate is currently maxed at 100 degrees per second
#drivedir is for forward (1) or backward (-1)
#Wall avoidance stuff
enemyTurn=0
myh=self.player.getH()%360
print myh
if abs(self.enemy.getPos().getX())>19 or abs(self.enemy.getPos().getX())>19:
drivedir=-1.0
else:
drivedir=1.0
if self.playerrocket:
playerpos=self.player.getPos()
if playerpos.getX()>12.5 and (myh<90 or myh>270):
self.enemyTurn = -(0.5+0.05*(self.enemy.getX()-12.5))*sign(myh-180)
print 1
elif playerpos.getX()<12.5 and not (myh<90 or myh>270):
self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getX()))*sign(myh-180)
print 2
elif playerpos.getY()>12.5 and myh<180:
self.enemyTurn = -(0.5+0.05*(self.enemy.getY()-12.5))*sign(myh-90)
print 3
elif playerpos.getY()<12.5 and myh>180:
self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getY()))*sign(myh-270)
print 4
elif self.enemy.getPos().getX()>12.5 and (myh<90 or myh>270):
self.enemyTurn = -(0.5+0.05*(self.enemy.getX()-12.5))*sign(myh-180)
print 5
elif self.enemy.getPos().getX()<-12.5 and not (myh<90 or myh>270):
self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getX()))*sign(myh-180)
print 6
elif self.enemy.getPos().getY()>12.5 and myh<180:
self.enemyTurn = -(0.5+0.05*(self.enemy.getY()-12.5))*sign(myh-90)
print 7
elif self.enemy.getPos().getY()<-12.5 and myh>180:
self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getY()))*sign(myh-270)
print 8
elif not(math.fabs(self.enemyDestAng - angleToPlayer) > 3 and math.fabs(self.enemyDestAng - angleToPlayer) < 357):
print 9
self.enemyTurn = 0
else:
print 10
if dist > 5:
self.enemyDestAng = 0
if angleToPlayer > 1 and angleToPlayer <= 180:
#Turn left
self.enemyTurn = -0.5
elif angleToPlayer > 180 and angleToPlayer < 359:
#Turn right
self.enemyTurn = 0.5
elif dist < 5:
self.enemyDestAng = 180
if angleToPlayer >= 0 and angleToPlayer < 179:
#Turn left
self.enemyTurn = 0.5
elif angleToPlayer > 181 and angleToPlayer < 360:
#Turn right
self.enemyTurn = -0.5
#Replace later
#drivedir=1.0
#End of AI code
#Enemy always tries to move forward, regardless of where the player is
self.enemy.setPos(self.enemy.getPos() - backward*(drivedir*elapsed*5))
self.enemy.setH(self.enemy.getH() - elapsed *100.0*self.enemyTurn)
EnemyRunning.play()
self.cTrav.traverse(render)
entries = []
terrain = []
for i in range(self.enemyGroundHandler.getNumEntries()):
entry = self.enemyGroundHandler.getEntry(i)
if entry.getFromNode().getName() == "enemyRay":
terrain.append(entry)
elif entry.getFromNode().getName() == "Enemy" and entry.getIntoNode().getName() != "terrain":
entries.append(entry)
terrain.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0):
self.enemy.setPos(startpos)
if (len(terrain)>0) and (terrain[0].getIntoNode().getName() == "terrain"):
self.enemy.setZ(terrain[0].getSurfacePoint(render).getZ()+.5)
else:
self.enemy.setPos(startpos)
# Store the task time and continue.
self.prevEnemyMoveTime = task.time
return Task.cont
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def playerMove(self, task):
elapsed = task.time - self.prevtime
base.camera.lookAt(self.player)
camright = base.camera.getNetTransform().getMat().getRow3(0)
camright.normalize()
# save player's initial position so that we can restore it,
# in case he falls off the map or runs into something.
startpos = self.player.getPos()
# If a move-key is pressed, move player in the specified direction.
if ((self.keyMap["left"]!=0) & (self.keyMap["forward"]!=0)):
self.player.setH(self.player.getH() + elapsed*50)
Idling.stop()
Running.play()
self.playermoving = True
elif((self.keyMap["left"]!=0) & (self.keyMap["backward"]!=0)):
self.player.setH(self.player.getH() - elapsed*50)
Idling.stop()
Running.play()
self.playermoving = True
if ((self.keyMap["right"]!=0) & (self.keyMap["forward"]!=0)):
self.player.setH(self.player.getH() - elapsed*50)
Idling.stop()
Running.play()
self.playermoving = True
elif ((self.keyMap["right"]!=0) & (self.keyMap["backward"]!=0)):
self.player.setH(self.player.getH() + elapsed*50)
Idling.stop()
Running.play()
self.playermoving = True
if (self.keyMap["forward"]!=0):
backward = self.player.getNetTransform().getMat().getRow3(1)
backward.setZ(0)
backward.normalize()
self.player.setPos(self.player.getPos() - backward*(elapsed*5))
Running.play()
Idling.stop()
self.playermoving = True
if (self.keyMap["backward"]!=0):
backward = self.player.getNetTransform().getMat().getRow3(1)
backward.setZ(0)
backward.normalize()
self.player.setPos(self.player.getPos() + backward*(elapsed*5))
Idling.stop()
Running.play()
self.playermoving = True
if (self.keyMap["backward"]==0 and self.keyMap["forward"]==0 and self.keyMap["left"]==0 and self.keyMap["right"]==0):
Running.stop()
Idling.play()
self.playermoving = False
if self.player.getCurrentAnim()=="drive":
self.player.stop()
#print "STOP MOVING"
#DRIVE!
if self.player.getCurrentAnim() is None and self.playermoving:
self.player.loop("drive")
#print "DRIVE ON!"
dist = 10.0
angle = math.radians(self.player.getH()) + math.pi
dx = dist * math.sin(angle)
dy = dist * -math.cos(angle)
dest = Point3(self.player.getX() + dx, self.player.getY() + dy, self.player.getZ()+1)
base.camera.setPos(dest)
# If player is moving, loop the run animation.
# If he is standing still, stop the animation.
if (self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0):
if self.isMoving is False:
#self.player.loop("run")
self.isMoving = True
else:
if self.isMoving:
#self.player.stop()
#self.player.pose("walk",5)
self.isMoving = False
# If the camera is too far from player, move it closer.
# If the camera is too close to player, move it farther.
camvec = self.player.getPos() - base.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if (camdist > 20.0):
base.camera.setPos(base.camera.getPos() + camvec*(camdist-20))
camdist = 20.0
if (camdist < 10.0):
base.camera.setPos(base.camera.getPos() - camvec*(10-camdist))
camdist = 10.0
# Now check for collisions.
self.cTrav.traverse(render)
# Adjust player's Z coordinate. If player's ray hit terrain,
# update his Z. If it hit anything else, or didn't hit anything, put
# him back where he was last frame.
terrain = []
entries = []
for i in range(self.playerGroundHandler.getNumEntries()):
entry = self.playerGroundHandler.getEntry(i)
if entry.getFromNode().getName() == "playerRay":
terrain.append(entry)
elif entry.getFromNode().getName() == "Player" and entry.getIntoNode().getName() != "terrain":
entries.append(entry)
terrain.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0):
self.player.setPos(startpos)
elif (len(terrain)>0) and (terrain[0].getIntoNode().getName() == "terrain"):
self.player.setZ(terrain[0].getSurfacePoint(render).getZ()+.5)
else:
self.player.setPos(startpos)
# Keep the camera at one foot above the terrain,
# or two feet above player, whichever is greater.
entries = []
for i in range(self.camGroundHandler.getNumEntries()):
entry = self.camGroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"):
base.camera.setZ(entries[0].getSurfacePoint(render).getZ()+ 1.5)
if (base.camera.getZ() < self.player.getZ() + 2.5):
base.camera.setZ(self.player.getZ() + 2.5)
# The camera should look in player's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above player's head.
self.floater.setPos(self.player.getPos())
self.floater.setZ(self.floater.getZ()+1)
base.camera.lookAt(self.floater)
# Store the task time and continue.
self.prevtime = task.time
return Task.cont
class BSpecial (Bar):
def __init__(self):
Bar.__init__(self)
#-----------------------------------------------------------------------------------------------------------------------------------------------
#---------------------------------------------------VARIABLE DECLARATION------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Init the bar with alpha sprites
self.cereal = False
self.specialCereal = OnscreenImage(image="./tex/cereal_not_special.png", pos = (0.43, 0, 0.87),hpr=None, scale = 0.11, color=None, parent=None, sort=1)
self.specialCereal.setTransparency(TransparencyAttrib.MAlpha)
self.banana = False
self.specialBanana = OnscreenImage(image="./tex/banana_not_special.png", pos = (0.63, 0, 0.87),hpr=None, scale = 0.11, color=None, parent=None, sort=1)
self.specialBanana.setTransparency(TransparencyAttrib.MAlpha)
self.cheese = False
self.specialCheese = OnscreenImage(image="./tex/cheese_not_special.png", pos = (0.83, 0, 0.87),hpr=None, scale = 0.11, color=None, parent=None, sort=1)
self.specialCheese.setTransparency(TransparencyAttrib.MAlpha)
self.tomato = False
self.specialTomato = OnscreenImage(image="./tex/tomato_not_special.png", pos = (1.03, 0, 0.87),hpr=None, scale = 0.11, color=None, parent=None, sort=1)
self.specialTomato.setTransparency(TransparencyAttrib.MAlpha)
self.egg = False
self.specialEgg= OnscreenImage(image="./tex/egg_not_special.png", pos = (1.23, 0, 0.87),hpr=None, scale = 0.11, color=None, parent=None, sort=1)
self.specialEgg.setTransparency(TransparencyAttrib.MAlpha)
#end __init__
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------FUNCTIONS----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# It makes visible (change alpha sprite) the item corresponding to the type given
def itemCollected(self,type):
if type == "GRAIN":
self.cereal = True
self.specialCereal.setImage("./tex/cereal_special.png")
self.specialCereal.setTransparency(TransparencyAttrib.MAlpha)
if type == "FRUIT":
self.banana = True
self.specialBanana.setImage("./tex/banana_special.png")
self.specialBanana.setTransparency(TransparencyAttrib.MAlpha)
if type == "MILK":
self.cheese = True
self.specialCheese.setImage("./tex/cheese_special.png")
self.specialCheese.setTransparency(TransparencyAttrib.MAlpha)
if type == "VEGETABLE":
self.tomato = True
self.specialTomato.setImage("./tex/tomato_special.png")
self.specialTomato.setTransparency(TransparencyAttrib.MAlpha)
if type == "FISH":
self.egg = True
self.specialEgg.setImage("./tex/egg_special.png")
self.specialEgg.setTransparency(TransparencyAttrib.MAlpha)
#end itemCollected
# It puts the bar at the same characteristics as its initialization
def reInit(self):
self.cereal = False
self.specialCereal.setImage("./tex/cereal_not_special.png")
self.specialCereal.setTransparency(TransparencyAttrib.MAlpha)
self.banana = False
self.specialBanana.setImage("./tex/banana_not_special.png")
self.specialBanana.setTransparency(TransparencyAttrib.MAlpha)
self.cheese = False
self.specialCheese.setImage("./tex/cheese_not_special.png")
self.specialCheese.setTransparency(TransparencyAttrib.MAlpha)
self.tomato = False
self.specialTomato.setImage("./tex/tomato_not_special.png")
self.specialTomato.setTransparency(TransparencyAttrib.MAlpha)
self.egg = False
self.specialEgg.setImage("./tex/egg_not_special.png")
self.specialEgg.setTransparency(TransparencyAttrib.MAlpha)
#end reInit
# It check if all the special items are collected.
# Return true if it's correct.
def hasAllSpecial(self):
if( (self.cereal == True) and (self.banana == True) and (self.cheese == True) and (self.tomato == True) and (self.egg == True) ):
return True
else:
return False
#end hasAllSpecial
# It makes disappear the bar
def hide(self):
self.specialCereal.hide()
self.specialBanana.hide()
self.specialCheese.hide()
self.specialTomato.hide()
self.specialEgg.hide()
#end hide
# It makes appear the bar
def show(self):
self.specialCereal.show()
self.specialBanana.show()
self.specialCheese.show()
self.specialTomato.show()
self.specialEgg.show()
#end show
class BetterOnscreenImage(DebugObject):
""" Simple wrapper arroun OnscreenImage, providing a simpler interface and
better visuals """
def __init__(self,
image=None,
parent=None,
x=0,
y=0,
w=10,
h=10,
transparent=True,
nearFilter=True,
anyFilter=True):
""" Creates a new image, taking (x,y) as topleft coordinates.
When nearFilter is set to true, a near filter will be set to the
texture passed. This provides sharper images.
When anyFilter is set to false, the passed image won't be modified at
all. This enables you to display existing textures, otherwise the
texture would get a near filter in the 3D View, too. """
DebugObject.__init__(self, "BetterOnscreenImage")
self.w, self.h = w, h
self.initialPos = self.translatePos(x, y)
self._node = OnscreenImage(image=image,
parent=parent,
pos=self.initialPos,
scale=(w / 2.0, 1, h / 2.0))
if transparent:
self._node.setTransparency(TransparencyAttrib.MAlpha)
tex = self._node.getTexture()
if nearFilter and anyFilter:
tex.setMinfilter(Texture.FTNearest)
tex.setMagfilter(Texture.FTNearest)
if anyFilter:
tex.setAnisotropicDegree(8)
tex.setWrapU(Texture.WMClamp)
tex.setWrapV(Texture.WMClamp)
def getInitialPos(self):
""" Returns the initial position of the image. This can be used for
animations """
return self.initialPos
def posInterval(self, *args, **kwargs):
""" Returns a pos interval, this is a wrapper around
NodePath.posInterval """
return self._node.posInterval(*args, **kwargs)
def hprInterval(self, *args, **kwargs):
""" Returns a hpr interval, this is a wrapper around
NodePath.hprInterval """
return self._node.hprInterval(*args, **kwargs)
def setImage(self, img):
""" Sets the current image """
self._node.setImage(img)
def setPos(self, x, y):
""" Sets the position """
self.initialPos = self.translatePos(x, y)
self._node.setPos(self.initialPos)
def translatePos(self, x, y):
""" Converts 2d coordinates to pandas coordinate system """
return Vec3(x + self.w / 2.0, 1, -y - self.h / 2.0)
def remove(self):
self._node.remove()
def hide(self):
self._node.hide()
def show(self):
self._node.show()
class GameStart(ShowBase):
#Lists for storing entities
projectileList = []
enemyList = []
pickuplist = []
#Initialize keys
keyMap = {"forward":False, "backward":False, "left":False, "right":False, "m":False}
fsm = 0
levelChanger = 0
player = 0
def __init__(self):
#Start ShowBase
ShowBase.__init__(self)
#Set up task chain for game play
base.taskMgr.setupTaskChain('GameTasks')
#Flag to see if a player has already been spawned
self.needPlayer = True
#Load in all menu images. If the don't all get set initially, it stutters on switch,
self.mainMenuImage = OnscreenImage("./resources/mainMenu1.png")
self.mainMenuImage.setImage("./resources/mainMenu2.png")
self.mainMenuImage.reparentTo(render2d)
self.gameOverImage = OnscreenImage("./resources/gameOver1.png")
self.gameOverImage.setImage("./resources/gameOver2.png")
self.gameOverImage.reparentTo(render2d)
self.gameOverImage.hide()
self.victoryImage = OnscreenImage("./resources/victory1.png")
self.victoryImage.setImage("./resources/victory2.png")
self.victoryImage.reparentTo(render2d)
self.victoryImage.hide()
#start FSM
self.fsm = TerminalZoneFSM()
#Open file to get configs
self.configFile = open("config.txt")
self.configList = self.configFile.readlines()
self.configFile.close()
#Get and set resolution
properties = WindowProperties()
self.xRes = self.configList[4].split("=")[1].translate(None,"\n")
self.yRes = self.configList[5].split("=")[1].translate(None,"\n")
properties.setSize(int(self.xRes), int(self.yRes))
base.win.requestProperties(properties)
#Determine prepare to cry mode
if self.configList[7].split("=")[1].translate(None,"\n") == "True":
self.damageMod = 2
else:
self.damageMod = 1
#Starts main menu
self.fsm.request('MainMenu', 1)
def startNewGame(self, load):
#Hide menu background on start of game.
self.mainMenuImage.hide()
#Get window properties, hide the cursor, set properties
properties = WindowProperties()
properties.setCursorHidden(True)
base.win.requestProperties(properties)
#Disable default mouse controls
self.disableMouse()
#Create new collision system
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
#Init player here
#If we don't already have a player
if self.needPlayer:
self.player = Player()
self.needPlayer = False
#Display HUD and set default stats
self.player.show()
self.player.resetEnergy()
#Load first environment
self.environ = self.loader.loadModel("./resources/theSouthBridge")
self.environ.reparentTo(self.render)
self.environ.setScale(7, 7, 3)
#Load skybox
self.skybox = loader.loadModel("resources/skyBox")
self.skyboxPath = NodePath(self.skybox)
self.skyboxPath.setCompass()
self.skybox.setBin('background',1)
self.skybox.setDepthWrite(False)
self.skybox.setLightOff()
self.skybox.reparentTo(camera)
#Global current player spawn coordinates
self.xPos = 0
self.yPos = 0
self.zPos = 3
#Create level changer
self.levelChanger = LevelChanger()
#Check to see if load game was pressed
if load:
self.levelChanger.goToBoss()
#Create spawner open on current level
self.spawner = Spawner(self.environ, "theRoot")
else:
#Create spawner open on current level
self.spawner = Spawner(self.environ, "theSouthBridge")
#Populate level with enemies
self.spawner.spawn()
#Add tasks
#base.taskMgr.add(self.spawner.checkSpawn, "Spawn Enemies", taskChain='GameTasks')
base.taskMgr.add(self.projCleanTask, "Projectile Clean Up", taskChain='GameTasks')
base.taskMgr.add(self.enemyCleanUp, "enemyCleanup", taskChain='GameTasks')
base.taskMgr.add(self.levelChanger.checkLevel, "checkLevel", taskChain='GameTasks')
base.taskMgr.add(self.pickupClean, "Pickup celeanup", taskChain='GameTasks')
#Get movement controls from config file
self.forward = self.configList[0].split("=")[1].translate(None,"\n")
self.backward = self.configList[1].split("=")[1].translate(None,"\n")
self.left = self.configList[2].split("=")[1].translate(None,"\n")
self.right = self.configList[3].split("=")[1].translate(None,"\n")
#Controls
self.accept("escape", sys.exit, [0])
self.accept("enter", self.startPause)
#Set Controls
self.accept(self.forward, self.setKey, ["forward", True])
self.accept(self.backward, self.setKey, ["backward", True])
self.accept(self.left, self.setKey, ["left", True])
self.accept(self.right, self.setKey, ["right", True])
self.accept(self.forward+"-up", self.setKey, ["forward", False])
self.accept(self.backward+"-up", self.setKey, ["backward", False])
self.accept(self.left+"-up", self.setKey, ["left", False])
self.accept(self.right+"-up", self.setKey, ["right", False])
# Changes the states of the keys pressed
def setKey(self, key, value):
self.keyMap[key] = value
#Spawn and append pickups to the list
def spawnPickup(self, id, node):
n = Pickup(id, node)
self.pickuplist.append(n)
#Cleans projectiles after impact and specified duration
def projCleanTask(self, task):
#using this task to find all the projectiles in the projList
#that have reached the end of their lifespan
#use the built in destroy to remove them
for i in self.projectileList:
if i.flag:
i.projectileNode.removeNode()
self.projectileList.remove(i)
return task.cont
#Clears pickups from the environment after collection
def pickupClean(self, task):
for i in self.pickuplist:
if i.deletePickup:
i.destroy()
self.pickuplist.remove(i)
return task.cont
#Clears enemies from the environment after being killed or upon player death
def enemyCleanUp(self, task):
self.levelChanger.checkLevel(task)
#Remove flagged enemies
for i in self.enemyList:
if i.delFlag:
#i.enemyNode.removeNode()
i.destroy()
self.enemyList.remove(i)
#self.spawner.spawnableCount-=1
return task.cont
#Requests pause from the fsm
def startPause(self):
self.fsm.request('PauseMenu')
#Handles the delay between menu image swaps
def menusTasks(self, s, task):
if task.time > .75:
if s == "mainmenu1":
base.fsm.request('MainMenu', 2)
elif s == "mainmenu2":
base.fsm.request('MainMenu', 1)
elif s == "gameover1":
base.fsm.request('GameOver', 2)
elif s == "gameover2":
base.fsm.request('GameOver', 1)
elif s == "winmenu1":
base.fsm.request('WinMenu', 2)
elif s == "winmenu2":
base.fsm.request('WinMenu', 1)
return task.cont
class LoadPlot(DirectObject):
def __init__(self):
self.__plotFilePath="../../resources/files/dialogue.txt"
#打开对话文件
# self.__file = open("../../resources/files/dialogue.txt", 'r')
with open(self.__plotFilePath, 'r') as f:
# 对话内容
self.__content = f.readlines()
# #对话内容
# self.__content = self.__file.readlines()
# 对话数组,id唯一标识
self.__dialogueList = []
#对话part
self.__part = 1
#对话第几句
self.__index = 0
#当前选择对话id
self.__id=1
#读取对话文件，存成数组
self.dialogue_list()
#初始化剧情树
self.init_tree()
#能否移除控件
self.__destroy=False
#能否移除提示框
self.__destroyPrompt=False
#剧情路径
self.__path=""
self.__pathTrade="18"
# 设置对话part,默认为1
# self.selectPart(1)
#初始化对话与人物头像
def init_interface(self,part):
if self.__destroy == False :
self.__id=part
if self.init_dialogue(part):
self.init_head_portrait()
self.__destroy = True
else:
self.__destroy=False
# 初始化对话框
def init_dialogue(self,part):
# 显示对话内容
if self.__destroy == False:
self.__dialogue = OnscreenText("", pos=(0, -0.9), scale=0.07, fg=(1, 1, 1, 1), shadow=(0, 0, 0, 1),
mayChange=True)
if self.selectPart():
print "第",part,"成功"
# self.__destroy = True
return True
else:
print "第",part,"失败"
# self.__destroy = False
return False
# 初始化人物头像
def init_head_portrait(self):
# 人物头像
if self.__destroy == False:
self.__image = OnscreenImage(image='../../resources/images/1.jpg', pos=(-0.9, 0, -0.2), scale=0.2)
self.__image.setTransparency(TransparencyAttrib.MAlpha)
# self.__destroy = True
#初始化提示框
def init_prompt(self):
if self.__destroyPrompt==False:
self.__prompt = OnscreenText("提示", pos=(0, -0.5), scale=0.07, fg=(1, 1, 1, 1), shadow=(0, 0, 0, 1),
mayChange=True)
self.__destroyPrompt=True
#移除控件
def destroy(self):
if self.__destroy == True:
self.destroy_dialogue()
self.destroy_image()
self.__destroy = False
# 移除对话框
def destroy_dialogue(self):
if self.__destroy == True:
self.__dialogue.destroy()
# self.__destroy = False
#移除头像
def destroy_image(self):
if self.__destroy == True:
self.__image.destroy()
# self.__destroy = False
#移除提示框
def destroy_prompt(self):
if self.__destroyPrompt== True:
self.__prompt.destroy()
self.__destroyPrompt = False
#读取对话文件，存成数组，按part形成结构如下的数组
# [{id:,dialogue:[]},{},{}]
def dialogue_list(self):
# 按行读取文件内容
part = -1
index = 0
for line in self.__content:
# 去掉首三个字符
if line[:3] == codecs.BOM_UTF8:
line = line[3:]
#如果行中包含Part，则扩充数组
if (line[4] == "1" or line[4] == "2" or line[4] == "3" or line[4] == "4" or line[4] == "5"
or line[4] == "6" or line[4] == "7" or line[4] == "8" or line[4] == "9"):
part=part+1
self.__dialogueList.append({"id":part+1,"dialogue":[]})
index = 0
continue
line = line.strip('\n')
self.__dialogueList[part]["dialogue"].append(line)
index=index+1
#选择第几部分对话
def selectPart(self):
if self.__id==9:
self.__part = self.__id
self.__index = 1
return True
else:
self.__path = self.__path+str(self.__id)
if self.__dialogueTree.search(self.__path,self.__id)[0] ==True:
self.__part = self.__id
self.__index = 1
return True
else:
self.__path=self.__path[:-1]
return False
#读取下一句对话
def dialogue_next(self):
length=len(self.__dialogueList[self.__part-1]["dialogue"])
#判断是否读到part最后一句对话
if self.__index-1>=length:#将对应part标记，增加剧情树路径
self.__dialogueTree.search(self.__path,self.__id)[1].set_flag(True)
# self.__destroy()
return False
else:#继续显示对话与对应头像
line=self.__dialogueList[self.__part-1]["dialogue"][self.__index-1]
char=0
#分离角色名与对话内容
char = line.find(":")
# for f in line:
# char = char + 1
# if (f == ":"):
# break
role = line[:char]
dia = line[char+1:]
# # 判断角色
# if role.decode('gb2312').encode('utf-8') == "猎人":
# self.__image.setImage("../../resources/images/1.jpg")
# elif role.decode('gb2312').encode('utf-8') == "修女":
# self.__image.setImage("../../resources/images/2.jpg")
# else:
# self.__image.setImage("../../resources/images/3.jpg")
# 显示人物头像
self.showRole(role)
self.__dialogue.setText(dia.decode('gb2312'))
self.__index = self.__index+1
return True
#根据人物对象显示头像
def showRole(self,role):
# 判断角色
if role.decode('gb2312').encode('utf-8') == "猎人":
self.__image.setImage("../../resources/images/1.jpg")
elif role.decode('gb2312').encode('utf-8') == "修女":
self.__image.setImage("../../resources/images/2.jpg")
else:
self.__image.setImage("../../resources/images/3.jpg")
#初始化剧情树
def init_tree(self):
#剧情树路径
self.__path=""
dialoguePart=[]
for part in self.__dialogueList:
dialoguePart.append(Node(part["id"],False))
# print dialoguePart[1].get_data()
index = 0
for node in dialoguePart:
if(index<len(dialoguePart)-2):
node.add(dialoguePart[index+1])
index=index+1
# dialoguePart[0].add(dialoguePart[1])
# dialoguePart[1].add(dialoguePart[2])
# dialoguePart[2].add(dialoguePart[3])
# dialoguePart[3].add(dialoguePart[4])
# dialoguePart[4].add(dialoguePart[5])
# dialoguePart[5].add(dialoguePart[6])
# dialoguePart[6].add(dialoguePart[7])
dialoguePart[0].add(dialoguePart[8])
self.__dialogueTree = Tree()
self.__dialogueTree.link_to_head(dialoguePart[0])
# print 'Node', self.__dialogueTree.search("123").get_data()
# print 'Node', self.__dialogueTree.search("1234").get_data()
# print 'Node', self.__dialogueTree.search("19").get_data()
#返回剧情树路径
def get_path(self):
return self.__path
def set_path(self,path):
self.__path=path
for i in range(len(self.__path)):
self.__id=int(self.__path[i])
# self.__path=self.__path[:i+1]
# self.selectPart()
self.__dialogueTree.search(self.__path[:i+1], self.__id)[1].set_flag(True)
if self.__destroy==True:
self.__destroy=False
class App(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self._setup_menu()
self.disableMouse()
self.stop_loop = False
self.loading = False
base.accept(S.control_keys['close_window'], self.esc_handler)
if S.show_control_keys:
display_control_keys(S)
def _load_map_infos(self):
for fname in sorted(glob(os.path.join(S.map_dir, '*.yaml'))):
with open(fname, 'r') as f:
map_data = yaml.load(f)
title = map_data.get('title', 'unnamed').capitalize()
ident = os.path.basename(fname)
thumbnail = S.map_thumbnail(map_data.get('thumbnail', 'unknown'))
yield dict(title=title,
thumbnail=thumbnail,
ident=ident)
def _setup_menu(self):
parent = render2d.attachNewNode(PGTop('menu_node'))
parent.node().setMouseWatcher(base.mouseWatcherNode)
OnscreenImage(image=S.menu_backg, scale=(1, 1, 1)).reparentTo(parent)
def start():
if self.loading:
return
self.loading = True
parent.removeNode()
self.set_manager(self.map_infos[0]['ident'])
DirectButton(command=start,
text='Start',
borderWidth=(0, 0),
frameColor=(1, 1, 1, 1),
pos=(0, 0, -0.4),
scale=0.1).reparentTo(parent)
self._make_exit_button(parent)
self.map_infos = map_infos = deque(self._load_map_infos())
self.map_thumbnail = OnscreenImage(image=map_infos[0]['thumbnail'],
scale=0.3)
self.map_thumbnail.reparentTo(parent)
self.map_title = OnscreenText(text=map_infos[0]['title'],
pos=(0, 0.35),
fg=(1, 1, 1, 1),
scale = 0.05)
self.map_title.reparentTo(parent)
self._make_switch_button(True, parent)
self._make_switch_button(False, parent)
def _make_switch_button(self, right, parent):
def switch():
self.map_infos.rotate(-1 if right else 1)
self.map_thumbnail.setImage(self.map_infos[0]['thumbnail'])
self.map_title.setText(self.map_infos[0]['title'])
DirectButton(command=switch,
text='>' if right else '<',
borderWidth=(0, 0),
frameColor=(1, 1, 1, 1),
pos=(0.4 if right else -0.4, 0, 0),
scale=0.1).reparentTo(parent)
def _make_exit_button(self, parent):
def exit():
self.stop_loop = True
DirectButton(command=exit,
text='Exit',
borderWidth=(0, 0),
frameColor=(1, 1, 1, 1),
pos=(0, 0, -0.52),
scale=0.1).reparentTo(parent)
def set_manager(self, *args, **kwargs):
preloader = OnscreenImage(image=S.preloader, scale=(1, 1, 1))
preloader.reparentTo(render2d)
def callback(task):
self.manager = Manager(*args, **kwargs)
taskMgr.add(self.manager, 'manager')
preloader.destroy()
taskMgr.doMethodLater(0.1, callback, 'set_manager')
def finish_game(self, win):
taskMgr.remove('manager')
parent = render2d.attachNewNode(PGTop('finish_node'))
parent.node().setMouseWatcher(base.mouseWatcherNode)
backg = S.win_backg if win else S.fail_backg
OnscreenImage(image=backg, scale=(1, 1, 1)).reparentTo(parent)
self._make_exit_button(parent)
def esc_handler(self):
def handler(yes):
if yes:
self.stop_loop = True
else:
dialog.cleanup()
dialog = YesNoDialog(dialogName="ExitDialog",
text="Do you want to exit?",
command=handler)
def loop(self):
while not self.stop_loop:
taskMgr.step()
class GuiButton2:
def __init__(self, hugpos, offset, aspect, plane, name):
self.enabled = True
self.name = name
self.frame = DirectFrame( relief = DGG.FLAT
, frameColor = (0, 0, 0, 0)
, scale = 1
, frameSize = (-0.3, 0.3, -0.3, 0.3) ) #32/600=0.05333
self.frame.setScale(0.0533)
self.imageObject = OnscreenImage(image = name+".png", pos = (0, 0, 0))
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.imageObject.setAlphaScale(1)
self.imageObject.reparentTo(self.frame)
self.hugpos = hugpos
self.offset = offset
self.redraw(aspect)
def redraw(self, aspect, flag="wide"):
if self.hugpos == "top":
p = base.a2dTopLeft.getPos()#@UndefinedVariable
p.setX(p.getX() + self.offset.getX() + 0.05)
p.setZ(p.getZ() + self.offset.getZ() - GUI_TOP_OFFSET - 0.05)
elif self.hugpos == "bottom":
p = base.a2dBottomLeft.getPos()#@UndefinedVariable
p.setX(p.getX() + self.offset.getX() + 0.05)
p.setZ(p.getZ() + self.offset.getZ() + GUI_BOTTOM_OFFSET - 0.05)
elif self.hugpos == "right":
p = base.a2dBottomRight.getPos()#@UndefinedVariable
p.setX(p.getX() + self.offset.getX() + 0.05)
p.setZ(p.getZ() + self.offset.getZ() + GUI_BOTTOM_OFFSET - 0.05)
self.frame.setPos(p)
if flag == "wide":
posx, posy = self.frame.getTightBounds()
self.pos_min_x = posx.getX() / aspect
self.pos_min_y = posx.getZ()
self.pos_max_x = posy.getX() / aspect
self.pos_max_y = posy.getZ()
elif flag == "tall":
posx, posy = self.frame.getTightBounds()
self.pos_min_x = posx.getX()
self.pos_min_y = posx.getZ() / aspect
self.pos_max_x = posy.getX()
self.pos_max_y = posy.getZ() / aspect
def turnOn(self):
self.imageObject.setImage(self.name+"_on.png")#@UndefinedVariable
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
def turnOff(self):
self.imageObject.setImage(self.name+".png")#@UndefinedVariable
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
def enable(self):
self.imageObject.setImage(self.name+".png")#@UndefinedVariable
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.enabled = True
def disable(self):
self.imageObject.setImage("empty.png")#@UndefinedVariable
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.enabled = False
def removeNode(self):
self.frame.removeNode()
def setAbility(self, ability):
self.name = ability
self.imageObject.setImage(self.name+".png")
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.imageObject.setAlphaScale(1)
class ScreenshotViewer:
notify = DirectNotifyGlobal.directNotify.newCategory('ScreenshotViewer')
def __init__(self):
self.resetImages()
imageFrame = PDialog(parent=aspect2dp,
pos=(0, 0, 0.10000000000000001),
image_scale=(1.3 * 4 / 3.0, 1, 1.3),
fadeScreen=0.84999999999999998,
scale=1.1000000000000001)
imageFrame.hide()
imX = 0.84999999999999998
imY = imX * 3 / 4.0
self.imageObj = OnscreenImage(parent=imageFrame,
image=self.screens[0],
scale=(imX, 1, imY),
pos=(0, 0, -0.025000000000000001))
self.imageLabel = DirectLabel(parent=imageFrame,
relief=None,
state=DGG.DISABLED,
pos=(0, 0, -0.75),
textMayChange=1,
text_fg=(0.59999999999999998,
0.59999999999999998,
0.59999999999999998, 1),
text_scale=0.040000000000000001)
self.imageLabel.hide()
topGui = loader.loadModel('models/gui/toplevel_gui')
arrow = topGui.find('**/generic_arrow')
buttons = loader.loadModel('models/gui/lookout_gui')
closeButton = (buttons.find('**/lookout_close_window'),
buttons.find('**/lookout_close_window_down'),
buttons.find('**/lookout_close_window_over'))
xs = 1.2
self.nextButton = DirectButton(parent=imageFrame,
relief=None,
command=self.next,
pos=(0.69999999999999996, 0, 0),
image=arrow,
image_scale=(-xs, xs, xs),
sortOrder=-5)
self.prevButton = DirectButton(parent=imageFrame,
relief=None,
command=self.prev,
pos=(-0.69999999999999996, 0, 0),
image=arrow,
image_scale=xs,
sortOrder=-5)
self.closeButton = DirectButton(parent=imageFrame,
relief=None,
command=self.close,
pos=(0.78000000000000003, 0, -0.5),
image=closeButton,
image_scale=0.29999999999999999,
text=PLocalizer.lClose,
text_fg=PiratesGuiGlobals.TextFG1,
text_scale=0.050000000000000003,
text_pos=(0, -0.10000000000000001),
sortOrder=-5)
self.showIval = Sequence(
Func(imageFrame.show), Wait(1),
Parallel(
LerpPosInterval(
self.closeButton, 0.20000000000000001,
Vec3(0.78000000000000003, 0, -0.80000000000000004),
Vec3(0.78000000000000003, 0, -0.5)),
LerpPosInterval(self.nextButton, 0.20000000000000001,
Vec3(1, 0, 0), Vec3(0.69999999999999996, 0,
0)),
LerpPosInterval(self.prevButton, 0.20000000000000001,
Vec3(-1, 0, 0), Vec3(-0.69999999999999996, 0,
0))),
Func(self.imageLabel.show))
self.imageFrame = imageFrame
base.transitions.fadeScreen(0.84999999999999998)
def destroy(self):
self.imageFrame.destroy()
def resetImages(self):
filenames = os.listdir(os.curdir + '/' + PLocalizer.ScreenshotDir)
continue
self.screens = _[1]
self.currentIndex = 0
def resetButtons(self):
self.closeButton.setPos(Vec3(0.78000000000000003, 0, -0.5))
self.nextButton.setPos(Vec3(0.69999999999999996, 0, 0))
self.prevButton.setPos(Vec3(-0.69999999999999996, 0, 0))
def showImage(self, index):
if index >= 0 and index < len(self.screens):
self.imageFrame.show()
self.imageObj.setImage(self.screens[index])
pandafile = Filename(str(ExecutionEnvironment.getCwd()))
winfile = pandafile.toOsSpecific()
self.imageLabel['text'] = '%s:\n%s\n%s\n[%s/%s]' % (
PLocalizer.ScreenshotLocation, winfile, self.screens[index],
index + 1, len(self.screens))
self.imageLabel['text_fg'] = (0.59999999999999998,
0.59999999999999998,
0.59999999999999998, 1)
self.imageLabel['text_scale'] = 0.040000000000000001
if len(self.screens) == 1:
self.prevButton['state'] = DGG.DISABLED
self.nextButton['state'] = DGG.DISABLED
else:
self.prevButton['state'] = DGG.NORMAL
self.nextButton['state'] = DGG.NORMAL
def next(self):
self.currentIndex = (self.currentIndex + 1) % len(self.screens)
try:
self.showImage(self.currentIndex)
except:
self.notify.error('Bad image')
def prev(self):
self.currentIndex = (self.currentIndex - 1) % len(self.screens)
try:
self.showImage(self.currentIndex)
except:
self.notify.error('Bad Image')
def close(self):
self.imageFrame.hide()
def show(self):
self.resetImages()
self.resetButtons()
self.showImage(0)
self.showIval.start()
def toggleShow(self):
if self.imageFrame.isHidden():
self.show()
else:
self.close()
class Player(DirectObject):
#using this to be our player
#define tehings like health in here
#have to tie the camera to this
#game manager ->player ->camera as far as instantiating goes
def __init__(self):
#Color values
self.red = 0
self.green = 1
self.blue = 1
self.oRed = 0
self.oGreen = 1
self.oBlue = 1
#Limits use of weapons on menus
self.canUseWeapons = True
#Current overheat value
self.overHeat = 0
#Amount of overheat reduced per cycle
self.overHeatCount = .1
#Flag for overheated weapons
self.isOverHeated = False
#Flag for ccritical health
self.down = True
#Create player node
self.playerNode = NodePath('player')
self.playerNode.reparentTo(render)
self.playerNode.setPos(0,-30,30)
self.playerNode.setScale(1.0)
#Create player model and reparent it to playerNode
self.playerModel = loader.loadModel("./resources/player")
self.playerModel.reparentTo(self.playerNode)
self.playerModel.setPos(0,0,2)
#Create weapons and store them in a map
self.rRifle = RecursionRifle(base.camera, len(base.projectileList))
self.mhBlunder = MHB(base.camera, len(base.projectileList))
self.kvDuals = KeyValue(base.camera, len(base.projectileList))
self.weaponMap = {1:self.rRifle, 2:self.mhBlunder, 3:self.kvDuals}
self.curWeapon = 1
#Names of weapons for switcching images
self.weaponNameMap = {1:"./resources/rrName.png", 2:"./resources/mhbName.png", 3:"./resources/kvdName.png"}
#Load all weaponName images in so it doesn't stutter on swap
self.weaponName = OnscreenImage(self.weaponNameMap[3])
self.weaponName.setTransparency(True)
self.weaponName.setImage(self.weaponNameMap[2])
self.weaponName.setTransparency(True)
self.weaponName.setImage(self.weaponNameMap[1])
self.weaponName.setTransparency(True)
self.weaponName.reparentTo(render2d)
#Hide weapons currently not in use
self.mhBlunder.hide()
self.kvDuals.hide()
#Weapon controls
self.accept("mouse1", self.fireWeapon)
self.accept("mouse3", self.swapWeapon)
#Display HUD
self.hud = OnscreenImage("resources/hud.png")
self.hud.setTransparency(True)
self.hud.reparentTo(render2d)
# define player health here
# try not to re-create the player object, will alter reset these values
# alernatively, dump player stats off in save file before recreating
print "Mod:",base.damageMod
self.maxEnergy = 100/base.damageMod
self.curEnergy = self.maxEnergy
self.accept("cnode", self.hit)
self.accept("pickuphealth", self.energyUpgrade)
#Load font for text nodes
font = loader.loadFont("./resources/ni7seg.ttf")
#Text node for health bar
self.healthLable = TextNode('health field name')
self.healthLable.setFont(font)
self.healthLable.setText("Abstraction")
self.textNodePath = aspect2d.attachNewNode(self.healthLable)
self.textNodePath.setScale(0.05)
self.healthLable.setAlign(TextNode.ACenter)
self.textNodePath.setPos(0, 0, .68)
self.healthLable.setTextColor(self.red, self.green, self.blue, 1)
#TextNode for enemy counter
self.enemiesLeft = TextNode('monsters to kill')
self.enemiesLeft.setFont(font)
self.enemiesLeft.setText(str(len(base.enemyList)))
self.texnp = aspect2d.attachNewNode(self.enemiesLeft)
self.texnp.setScale(.1)
self.texnp.setPos(-1.68, 0, -.75)
self.enemiesLeft.setTextColor(1, 1, 0, 1)
#Health bar
self.bar = DirectWaitBar(text = "", value = self.curEnergy, range = self.maxEnergy, pos = (0,.4,.95), barColor = (self.red, self.green, self.blue, 1))
self.bar.setScale(0.5)
#Usage bar
self.usageBar = DirectWaitBar(text = "", value = self.overHeat, range = 100, pos = (1.25, -.4, -.95), barColor =(1, 0, 0,1))
self.usageBar.setScale(0.5)
#Initailize player collision
self.createColision()
#Add player tasks
base.taskMgr.add(self.updateUsage, "usagePaint", taskChain='Gametasks')
base.taskMgr.add(self.hFlicker, "hflicker", taskChain='GameTasks')
base.taskMgr.add(self.updateCount, "Ecount", taskChain='GameTasks')
base.taskMgr.add(CameraMovement(self.playerModel).cameraControl, "cameraControl", taskChain='GameTasks')
base.taskMgr.add(self.overHeatTask, "overHeatTask")
base.taskMgr.add(self.killFloor, "Kill Floor")
#Deducts health and updates health bar
def hit(self, damage):
self.curEnergy = self.curEnergy-damage
self.bar['value'] = self.curEnergy
#If the player dies
if self.curEnergy <= 0:
#Hide player HUD elements
self.hide()
#Player can't use weapons while dead
self.canUseWeapons = False
#Request game over menu from fsm
base.fsm.request('GameOver', 1)
#Hides all visable elements attached to the player
def hide(self):
self.weaponMap[self.curWeapon].reticle.setScale(0)
self.weaponMap[self.curWeapon].curScale = 0
self.weaponMap[self.curWeapon].step = False
self.textNodePath.hide()
self.texnp.hide()
self.hud.setScale(0)
self.weaponName.setScale(0)
self.usageBar.hide()
self.bar.hide()
#Display all visable elements attached to the player
def show(self):
self.textNodePath.show()
self.texnp.show()
self.hud.setScale(1)
self.weaponName.setScale(1)
self.usageBar.show()
self.bar.show()
#Reset the reticle for the current weapon
if self.curWeapon == 1:
self.weaponMap[1].reticle.setScale(.025)
self.weaponMap[1].curScale = .025
elif self.curWeapon == 2:
self.weaponMap[2].reticle.setScale(.075)
self.weaponMap[2].curScale = .075
else:
self.weaponMap[3].reticle.setScale(.025)
self.weaponMap[3].curScale = .025
# set the player health to a specific value
def adjustHealth(self, value):
self.curEnergy = value
self.bar['value'] = self.curEnergy
#Update enemy counter
def updateCount(self, task):
self.enemiesLeft.setText(str(len(base.enemyList)))
return task.cont
#Update usage bar and color
def updateUsage(self, task):
if self.curEnergy > 0:
if self.overHeat < 50:
self.usageBar['barColor'] = (.2, 1, .5, 1)
elif self.overHeat >=50 and self.overHeat <70:
self.usageBar['barColor'] = (1, 1, .2, 1)
elif self.overHeat >= 70:
self.usageBar['barColor'] = (1, 0, 0, 1)
self.usageBar['value'] = self.overHeat
if self.isOverHeated:
self.usageBar['barColor'] = (1, 0, 0, 1)
return task.cont
#Swaps to next weapon in the map
def swapWeapon(self):
#If you're not in a menu
if self.canUseWeapons:
#Reset weapon delay
self.weaponMap[self.curWeapon].resetWeapon
#Change to next weapon and hide reticles
if self.curWeapon == 1:
self.weaponName.setImage(self.weaponNameMap[2])
self.weaponName.setTransparency(True)
self.weaponMap[1].reticle.setScale(0)
self.weaponMap[1].curScale = 0
self.weaponMap[1].step = False
self.rRifle.hide()
self.mhBlunder.show()
self.curWeapon = 2
self.weaponMap[2].reticle.setScale(.075)
self.weaponMap[2].curScale = .075
elif self.curWeapon == 2:
self.weaponName.setImage(self.weaponNameMap[3])
self.weaponName.setTransparency(True)
self.weaponMap[2].reticle.setScale(0)
self.weaponMap[2].curScale = 0
self.weaponMap[2].step = False
self.mhBlunder.hide()
self.kvDuals.show()
self.curWeapon = 3
self.weaponMap[3].reticle.setScale(.025)
self.weaponMap[3].curScale = .025
elif self.curWeapon == 3:
self.weaponName.setImage(self.weaponNameMap[1])
self.weaponName.setTransparency(True)
self.weaponMap[3].reticle.setScale(0)
self.weaponMap[3].curScale = 0
self.weaponMap[3].step = False
self.kvDuals.hide()
self.rRifle.show()
self.curWeapon = 1
self.weaponMap[1].reticle.setScale(.025)
self.weaponMap[1].curScale = .025
base.taskMgr.remove("weaponDelay")
#Fires current weapon
def fireWeapon(self):
#If the player is not in a menu
if self.canUseWeapons:
#If there isn't a weapon delay task add one
if base.taskMgr.hasTaskNamed("weaponDelay") == False:
#If your not overheated
if not self.isOverHeated:
base.taskMgr.add(self.weaponMap[self.curWeapon].fire, "fire")
#If you can shoot as defined by weapon delay
elif self.weaponMap[self.curWeapon].canShoot() == True:
#and if your not overheated
if not self.isOverHeated:
base.taskMgr.remove("weaponDelay")
base.taskMgr.add(self.weaponMap[self.curWeapon].fire, "fire")
#Handles weapon overheat
def overHeatTask(self, task):
#Every cycle decrement your overheat by the specified amount
self.overHeat -= self.overHeatCount
#If you exceed the limit
if self.overHeat >= 100:
#Increase cooldown amount and set overheated flag
self.overHeatCount = .5
self.isOverHeated = True
#If your are not overheated anymore reset not default cooldown values
elif self.overHeat < 0:
self.overHeatCount = .1
self.overHeat = 0
self.isOverHeated = False
return task.cont
#Initialize player collision
def createColision(self):
#Set up floor collision handler
base.floor = CollisionHandlerGravity()
base.floor.setGravity(9.8)
#Create player collision node and add to traverser
self.playerCollNodePath = self.initCollisionSphere(self.playerNode.getChild(0))
base.cTrav.addCollider(self.playerCollNodePath, base.pusher)
base.pusher.addCollider(self.playerCollNodePath, self.playerNode)
# Create Floor Ray - for gravity / floor
floorCollRayPath = self.initCollisionRay(1,-1)
base.floor.addCollider(floorCollRayPath, self.playerNode)
base.cTrav.addCollider(floorCollRayPath, base.floor)
floorCollRayPath.reparentTo(self.playerModel)
#Initialize player collision sphere
def initCollisionSphere(self, obj):
# Create sphere and attach to player
cNode = CollisionNode('player')
cs = CollisionSphere(0, 0, 4, 2)
cNodePath = obj.attachNewNode(CollisionNode('cnode'))
cNodePath.node().addSolid(cs)
cNodePath.show()
return cNodePath
#Attach player to a collision ray
def initCollisionRay(self, originZ, dirZ):
ray = CollisionRay(0,0,originZ,0,0,dirZ)
collNode = CollisionNode('playerRay')
collNode.addSolid(ray)
collNode.setFromCollideMask(BitMask32.bit(1))
collNode.setIntoCollideMask(BitMask32.allOff())
collRayNP = self.playerNode.attachNewNode(collNode)
collRayNP.show()
return collRayNP
#call this method when collide with a health upgrade
def energyUpgrade(self):
self.maxEnergy +=(10/base.damageMod)
self.curEnergy = self.curEnergy+(10/base.damageMod)
self.bar['range'] = self.maxEnergy
self.adjustHealth(self.curEnergy)
#Hurts player and resets the to the levels origin upon falliong in a pit.
def killFloor(self, task):
z = int(self.playerNode.getPos()[2])
if(z < -7):
self.playerNode.setPos(0, 0, 6) #resets height
self.playerModel.setPos(base.xPos, base.yPos, base.zPos) #resets position
self.hit(10)
return task.cont
#Makes the health bar flicker when your health is critical
def hFlicker(self, task):
if self.curEnergy <=30:
if self.down:
self.red = self.red+0.1
self.blue = self.blue-.01
self.green = self.green-.01
else:
self.red = self.red-0.1
self.blue = self.green+0.1
self.green = self.green+0.1
else:
self.red = self.oRed
self.blue = self.oBlue
self.green = self.oGreen
if self.red >=1:
self.down = False
if self.red <=0:
self.down = True
self.healthLable.setTextColor(self.red, self.green, self.blue, 1)
self.bar['barColor']=(self.red, self.green, self.blue, 1)
return task.cont
#Resets players health and signifies they have restarted level after death
def resetEnergy(self):
self.canUseWeapons = True
self.curEnergy = self.maxEnergy
self.adjustHealth(self.curEnergy)
class Tutorial (DirectObject):
def __init__(self, background, cursor, pointer):
#-----------------------------------------------------------------------------------------------------------------------------------------------
#---------------------------------------------------VARIABLE DECLARATION------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Background
self.back = background
# Level
self.level = Level_Tutorial(background)
# Graphic components
#Blackboard
self.blackboard = OnscreenImage(image="./tex/blackboard_empty.png", pos = (0, 0, 0),hpr=None, scale = (1.25,1.0,0.90), color=None, parent=None, sort=0)
self.blackboard.setTransparency(TransparencyAttrib.MAlpha)
self.blackboard.hide()
#Main Character
self.char = CMain(-18,-5,59)
#Energy Bar
self.energyBar = BEnergy()
self.energyBar.increase(50)
#Abilies Bar
self.grainAbility = BAbility("GRAIN")
self.fruitAbility = BAbility("FRUIT")
self.milkAbility = BAbility("MILK")
self.vegetableAbility = BAbility("VEGETABLE")
self.fishAbility = BAbility("FISH")
#Shape
self.shape = OnscreenImage(image="./tex/cereal_ability_shape.png", pos = (-0.75, 0, 0),hpr=None, scale = 0.25, color=None, parent=None, sort=1)
self.shape.setTransparency(TransparencyAttrib.MAlpha)
self.shape.hide()
#Item
self.item = OnscreenImage(image="./tex/rice.png", pos = (-0.75, 0, -0.4),hpr=None, scale = 0.09, color=None, parent=None, sort=1)
self.item.setTransparency(TransparencyAttrib.MAlpha)
self.item.hide()
#Texts
self.text = OnscreenImage(image="./tex/tryToDrawThisShape.png", pos = (-0.75, 0, 0.6),hpr=None, scale = 0.35, color=None, parent=None, sort=1)
self.text.setTransparency(TransparencyAttrib.MAlpha)
self.text.hide()
self.grassText = OnscreenImage(image="./tex/moveThroughTheGrass.png", pos = (0, 0, 0),hpr=None, scale = 0.7, color=None, parent=None, sort=1)
self.grassText.setTransparency(TransparencyAttrib.MAlpha)
#Info
self.infError = OnscreenImage(image="./tex/wrong_attack.png", pos = (0.4, 0, 0),hpr=None, scale=(0.47,1.0,0.55), color=None, parent=None, sort=5)
self.infError.setTransparency(TransparencyAttrib.MAlpha)
self.infError.hide()
self.infCereal = OnscreenImage(image="./tex/cereal_attack.png", pos = (0.4, 0, 0),hpr=None, scale=0.45, color=None, parent=None, sort=5)
self.infCereal.setTransparency(TransparencyAttrib.MAlpha)
self.infCereal.hide()
self.infFish = OnscreenImage(image="./tex/fish_attack.png", pos = (0.4, 0, 0),hpr=None, scale=0.5, color=None, parent=None, sort=5)
self.infFish.setTransparency(TransparencyAttrib.MAlpha)
self.infFish.hide()
self.infMilk = OnscreenImage(image="./tex/milk_attack.png", pos = (0.4, 0, 0),hpr=None, scale=0.5, color=None, parent=None, sort=5)
self.infMilk.setTransparency(TransparencyAttrib.MAlpha)
self.infMilk.hide()
self.infVege = OnscreenImage(image="./tex/vege_attack.png", pos = (0.4, 0, 0),hpr=None, scale=0.4, color=None, parent=None, sort=5)
self.infVege.setTransparency(TransparencyAttrib.MAlpha)
self.infVege.hide()
self.infFruit = OnscreenImage(image="./tex/fruit_attack.png", pos = (0.4, 0, 0),hpr=None, scale=0.4, color=None, parent=None, sort=5)
self.infFruit.setTransparency(TransparencyAttrib.MAlpha)
self.infFruit.hide()
#Logo
self.logo = OnscreenImage(image="./tex/laSalleAlpha.png", pos = (1.05, 0, -0.85),hpr=None, scale=(0.22,1.0,0.075), color=None, parent=None, sort=5)
self.logo.setTransparency(TransparencyAttrib.MAlpha)
# Others
self.shapeNum = 0
self.drawedOK = 0
self.finished = False
self.drawing = False
self.readyForGame = False
self.inGame = False
self.busy = False
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------TUTORIAL INIT------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Glove gestures configuration
self.cursor = cursor
self.gestureHandler = GestureRecognition("Gesture_Handler",
[("1",0), ("2",0), ("3",0), ("4",0), ("6",0), ("7",0), ("8",0), ("9",0), #NONE
("12",0), ("13",0), ("16",0), ("18",0), ("17",0), ("14",0), #NONE
("23",0), ("26",0), ("29",0), ("27",0), ("24",0), ("21",0), #NONE
("36",0), ("39",0), ("38",0), ("34",0), ("31",0), ("32",0), #NONE
("41",0), ("42",0), ("43",0), ("49",0), ("48",0), ("47",0), #NONE
("69",0), ("68",0), ("67",0), ("61",0), ("62",0), ("63",0), #NONE
("74",0), ("71",0), ("72",0), ("76",0), ("79",0), ("78",0), #NONE
("87",0), ("84",0), ("81",0), ("83",0), ("86",0), ("89",0), #NONE
("98",0), ("97",0), ("94",0), ("92",0), ("93",0), ("96",0), #NONE
("93934",1), #FRUIT
("7624",2), #MILK
("67616",3), #VEGETABLE
("183",4), #FISH
("3434",5)], #CEREAL
self.cursor, True, 1, 0, 0)
self.accept("Gesture_Handler", self.gestureProcessing)
self.pointer = pointer
# Events declaration
self.accept("WM_BUTTON_PRESSED", self.handleBtnPress)
self.accept("WM_BUTTON_RELEASED", self.handleBtnRelease)
taskMgr.add(self.taskMove, 'taskMove')
taskMgr.add(self.taskCollision, 'taskCollision' )
taskMgr.add(self.taskTextGrass, 'taskTextGrass' )
#end __init__
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------FUNCTIONS----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# WiiMote button pressed handler
def handleBtnPress(self, btn, dev, index):
if( self.finished == False ):
if(index == 1):
if(btn == wiiuse.BUTTON_A):
if self.drawing == True:
# We're on the second part of the tutorial
if( self.readyForGame == False ):
# We're ready for playing
if( self.inGame == False ):
if( self.busy == False ): self.gestureHandler.beginGesture()
#end handleBrnPress
# WiiMote button released handler
def handleBtnRelease(self, btn, dev, index):
if( self.finished == False ):
if(index == 1):
if(btn == wiiuse.BUTTON_A):
if self.drawing == True:
# We're on the second part of the tutorial
if( self.readyForGame == True ):
# We're going to play the game
self.hide()
self.game = Game(self.back, self.cursor, self.pointer)
self.inGame = True
self.readyForGame = False
else:
#We're on the second part of the tutorial
if( self.inGame == False ):
if( self.busy == False ): self.gestureHandler.endGesture()
else:
#We're on the first part of the tutorial
self.showBlackboard()
#end handleBtnRelease
# It makes appear the blackboard
def showBlackboard(self):
if self.level.scene2 == 2:
self.grassText.hide()
taskMgr.remove('taskMove')
taskMgr.remove('taskGlowing6')
self.energyBar.hide()
self.blackboard.show()
self.shape.show()
self.item.show()
self.text.show()
self.drawing = True
#end showBlackboard
# It hides the tutorial application
def hide(self):
self.blackboard.hide()
self.shape.hide()
self.shape = None
self.text.hide()
self.text = None
self.grassText.hide()
self.grassText = None
self.char.hide()
taskMgr.remove('taskMove')
self.char = None
self.energyBar.hide()
self.energyBar = None
self.grainAbility.hide()
self.grainAbility = None
self.fruitAbility.hide()
self.fruitAbility = None
self.milkAbility.hide()
self.milkAbility = None
self.vegetableAbility.hide()
self.vegetableAbility = None
self.fishAbility.hide()
self.fishAbility = None
taskMgr.remove('taskCollision')
self.level.removeItems()
self.level = None
self.item.hide()
self.item = None
#end hide
# It identifies the shapes drawn.
def gestureProcessing(self, id, x, y):
if(self.inGame == False):
#------------------------------------------------------------------FRUIT---------------------------------------------------------------------
if id==1:
if(self.shapeNum == 4):
self.infFruit.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add( self.taskCorrect, 'taskCorrect' )
else:
self.infError.show()
taskMgr.add( self.taskError, 'taskError' )
#------------------------------------------------------------------MILK----------------------------------------------------------------------
elif id==2:
if(self.shapeNum == 2):
self.infMilk.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add( self.taskCorrect, 'taskCorrect' )
else:
self.infError.show()
taskMgr.add( self.taskError, 'taskError' )
#---------------------------------------------------------------VEGETABLE-------------------------------------------------------------------
elif id==3:
if(self.shapeNum == 3):
self.infVege.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add( self.taskCorrect, 'taskCorrect' )
else:
self.infError.show()
taskMgr.add( self.taskError, 'taskError' )
#------------------------------------------------------------------FISH---------------------------------------------------------------------
elif id==4:
if(self.shapeNum == 1):
self.infFish.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add( self.taskCorrect, 'taskCorrect' )
else:
self.infError.show()
taskMgr.add( self.taskError, 'taskError' )
#----------------------------------------------------------------CEREAL--------------------------------------------------------------------
elif id==5:
if(self.shapeNum == 0):
self.infCereal.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add( self.taskCorrect, 'taskCorrect' )
else:
self.infError.show()
taskMgr.add( self.taskError, 'taskError' )
#------------------------------------------------------------------NONE-------------------------------------------------------------------
else:
taskMgr.add( self.taskError, 'taskError' )
self.infError.show()
self.gestureHandler.clearGestures();
self.busy = True
#end gestureProcessing
# It changes the shape showed to the user, depending on the shape practised.
def changeShape(self):
if( self.shapeNum == 0 ):
self.shape.setImage("./tex/cereal_ability_shape.png")
self.item.setImage("./tex/rice.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if( self.shapeNum == 1 ):
self.shape.setImage("./tex/fish_ability_shape.png")
self.item.setImage("./tex/fish.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if( self.shapeNum == 2 ):
self.shape.setImage("./tex/milk_ability_shape.png")
self.item.setImage("./tex/milk.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if( self.shapeNum == 3 ):
self.shape.setImage("./tex/vegetable_ability_shape.png")
self.item.setImage("./tex/letuce.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if( self.shapeNum == 4 ):
self.shape.setImage("./tex/fruit_ability_shape.png")
self.item.setImage("./tex/straw.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if( self.shapeNum == 5 ):
self.shape.hide()
self.text.setImage("./tex/youAreReady.png")
self.text.setTransparency(TransparencyAttrib.MAlpha)
self.item.hide()
#end changeShape
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------TASKS,THREADS------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# It moves the main character to the sun pointer point.
def taskMove(self, task):
mpos = self.cursor.getCursorPos()
# Moving the main character
self.char.movement(mpos.getX(),mpos.getY())
if self.level.scene2 == 1:
self.grassText.setImage("./tex/PressAButton.png")
self.grassText.setTransparency(TransparencyAttrib.MAlpha)
self.grassText.show()
self.level.scene2 = 2
return task.cont
#end taskCursor
# It checks Character-Item collision
def taskCollision(self, task):
#Character-Item collision
for x in self.level.items:
if x.collide(self.char):
self.char.itemCollect(x)
self.level.items.remove(x)
x.posX = -100
x.model.setX(x.posX)
x.posY = -100
x.model.setZ(x.posY)
x.collectIt = True
self.energyBar.increase(x.energy)
if x.specialItem==True: self.specialItems.itemCollected(x.type)
# Producing glowing on abilities bar
if x.type == "GRAIN":
self.grainAbility.itemCollected(1)
taskMgr.add(self.grainAbility.taskGlowing, 'taskGlowing1')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
if x.type == "FRUIT":
self.fruitAbility.itemCollected(1)
taskMgr.add(self.fruitAbility.taskGlowing, 'taskGlowing2')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
if x.type == "MILK":
self.milkAbility.itemCollected(1)
taskMgr.add(self.milkAbility.taskGlowing, 'taskGlowing3')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
if x.type == "VEGETABLE":
self.vegetableAbility.itemCollected(1)
taskMgr.add(self.vegetableAbility.taskGlowing, 'taskGlowing4')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
if x.type == "FISH":
self.fishAbility.itemCollected(1)
taskMgr.add(self.fishAbility.taskGlowing, 'taskGlowing5')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
return task.cont
#end taskCollision
# It manages the tutorial in order to teach all the shapes to the user.
# Each shape is practised two times.
def taskCorrect(self, task):
if( task.time > 1 ):
if(self.shapeNum == 0): self.infCereal.hide()
if(self.shapeNum == 1): self.infFish.hide()
if(self.shapeNum == 2): self.infMilk.hide()
if(self.shapeNum == 3): self.infVege.hide()
if(self.shapeNum == 4): self.infFruit.hide()
self.busy = False
self.text.setImage("./tex/onceAgain.png")
self.text.setTransparency(TransparencyAttrib.MAlpha)
if( self.drawedOK > 1 ):
self.shapeNum = self.shapeNum + 1
if( self.shapeNum == 5 ): self.readyForGame = True
self.drawedOK = 0
self.text.setImage("./tex/tryNewOne.png")
self.text.setTransparency(TransparencyAttrib.MAlpha)
self.changeShape()
return task.done
else: return task.cont
#end taskCursor
# It shows a message of don't worry to the user.
def taskError(self, task):
if( task.time > 1 ):
self.busy = False
self.infError.hide()
self.text.setImage("./tex/dontWorry.png")
self.text.setTransparency(TransparencyAttrib.MAlpha)
return task.done
else: return task.cont
#end taskCursor
# It shows a determined text for 3 seconds.
def taskTextGrass(self, task):
if( task.time > 3):
self.grassText.hide()
return task.done
else: return task.cont
#end taskTextGrass
class MainMenu:
def __init__(self, main):
self.main = main
self.mainFrame = DirectFrame(parent = base.render2d,
frameColor = (1,0,0,0), pos = (0,0,0),
frameSize = (-1,1,-1,1))
self.mainImage = OnscreenImage(parent = self.mainFrame,
image = 'Models/menu/menu.png', pos = (0, 0, 0))
self.startImage = OnscreenImage(image = 'Models/menu/Start.png', pos = (-0.8,0,0), scale = 0.3)
self.startImage.setTransparency(TransparencyAttrib.MMultisampleMask)
self.exitImage = OnscreenImage(image = 'Models/menu/Exit.png', pos = (0.8,0,0), scale = 0.3)
self.exitImage.setTransparency(TransparencyAttrib.MMultisampleMask)
self.menuFrame = DirectFrame(frameColor=(0,0,0,0), pos = (0,0,-0.2),
frameSize=(-0.5,0.5,0.7,-0.4 ))
self.start = DirectButton(parent = self.menuFrame,
pos = (-0.8,0,0.2),
frameColor = (0,0,0,0),
frameSize = (-1,1,-1,1),
scale = 0.3,
command = self.start)
self.start.guiItem.setActive(True)
self.start.bind(DGG.WITHIN, self.mouseOverStart, [self.start])
self.start.bind(DGG.WITHOUT, self.mouseOutStart, [self.start])
self.exit = DirectButton(parent = self.menuFrame,
pos = (0.8,0,0.2),
frameColor = (0,0,0,0),
frameSize = (-1,1,-1,1),
scale = 0.3,
command = main.exit)
self.exit.guiItem.setActive(True)
self.exit.bind(DGG.WITHIN, self.mouseOverExit, [self.exit])
self.exit.bind(DGG.WITHOUT, self.mouseOutExit, [self.exit])
def mouseOverStart(self, frame, mousePos):
self.startImage.setImage('Models/menu/Start2.png')
self.startImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def mouseOutStart(self, frame, mousePos):
self.startImage.setImage('Models/menu/Start.png')
self.startImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def mouseOverExit(self, frame, mousePos):
self.exitImage.setImage('Models/menu/Exit2.png')
self.exitImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def mouseOutExit(self, frame, mousePos):
self.exitImage.setImage('Models/menu/Exit.png')
self.exitImage.setTransparency(TransparencyAttrib.MMultisampleMask)
def hide(self):
self.mainFrame.hide()
self.menuFrame.hide()
def show(self):
self.mainFrame.show()
self.menuFrame.show()
def start(self):
self.hide()
self.startImage.destroy()
self.exitImage.destroy()
self.main.startGame()
def __del__(self):
self.start.destroy()
self.exit.destroy()
self.mainFrame.destroy()
class BetterOnscreenImage(DebugObject):
""" Simple wrapper arroun OnscreenImage, providing a simpler interface and
better visuals """
def __init__(self, image=None, parent=None, x=0, y=0, w=10, h=10,
transparent=True, nearFilter=True, anyFilter=True):
""" Creates a new image, taking (x,y) as topleft coordinates.
When nearFilter is set to true, a near filter will be set to the
texture passed. This provides sharper images.
When anyFilter is set to false, the passed image won't be modified at
all. This enables you to display existing textures, otherwise the
texture would get a near filter in the 3D View, too. """
DebugObject.__init__(self, "BetterOnscreenImage")
self.w, self.h = w, h
self.initialPos = self.translatePos(x, y)
self._node = OnscreenImage(
image=image, parent=parent, pos=self.initialPos,
scale=(w / 2.0, 1, h / 2.0))
if transparent:
self._node.setTransparency(TransparencyAttrib.MAlpha)
tex = self._node.getTexture()
if nearFilter and anyFilter:
tex.setMinfilter(Texture.FTNearest)
tex.setMagfilter(Texture.FTNearest)
if anyFilter:
tex.setAnisotropicDegree(8)
tex.setWrapU(Texture.WMClamp)
tex.setWrapV(Texture.WMClamp)
def getInitialPos(self):
""" Returns the initial position of the image. This can be used for
animations """
return self.initialPos
def posInterval(self, *args, **kwargs):
""" Returns a pos interval, this is a wrapper arround
NodePath.posInterval """
return self._node.posInterval(*args, **kwargs)
def setImage(self, img):
""" Sets the current image """
self._node.setImage(img)
def setPos(self, x, y):
""" Sets the position """
self.initialPos = self.translatePos(x, y)
self._node.setPos(self.initialPos)
def translatePos(self, x, y):
""" Converts 2d coordinates to pandas coordinate system """
return Vec3(x + self.w / 2.0, 1, -y - self.h / 2.0)
def hide(self):
self._node.hide()
def show(self):
self._node.show()
class Game(DirectObject):
def __init__(self):
self.background = OnscreenImage(image='image/title_screen.png',
scale=1.0,
pos=(0, 0, 0),
parent=render2d)
self.foreground = OnscreenImage(image='image/we_are_number_one.png',
scale=(256, 1, 256),
pos=(640, 0, -360),
parent=pixel2d)
self.foreground.wrt_reparent_to(aspect2d)
self.foreground.set_transparency(TransparencyAttrib.M_alpha)
self.foreground.set_bin("fixed", 10)
self.foreground.hide()
font = loader.load_font('font/oh_whale.otf')
font.set_outline(outline_color=(0, 0, 0, 1),
outline_width=1.0,
outline_feather=0.5)
font.setPixelsPerUnit(96)
font64 = font.make_copy()
font64.setPixelsPerUnit(64)
self.text_node = TextNode('silly_text_node')
self.text_node.set_font(font)
self.text_node.set_text('Press any key to start!')
self.text_node.set_align(TextNode.A_center)
self.text_node.set_text_color(0.4, 0.5, 1, 1)
self.text_node.set_shadow(0.03, 0.03)
self.text_node.set_shadow_color(0, 0, 0, 0.5)
self.text_path = aspect2d.attach_new_node(self.text_node)
self.text_path.set_scale(0.15)
self.text_path.set_z(-0.9)
self.text_path.set_transparency(TransparencyAttrib.M_alpha)
self.score_text_node = TextNode('score_text_node')
self.score_text_node.set_font(font)
self.score_text_node.set_text('Score: 0')
self.score_text_node.set_align(TextNode.A_left)
self.score_text_node.set_text_color(1.0, 1.0, 1.0, 1)
self.score_text_node.set_shadow(0.03, 0.03)
self.score_text_node.set_shadow_color(0, 0, 0, 0.5)
self.score_text_node_path = base.a2dTopLeft.attach_new_node(
self.score_text_node)
self.score_text_node_path.set_scale(0.15)
self.score_text_node_path.set_pos(0, 0, -0.13)
self.score_text_node_path.set_transparency(TransparencyAttrib.M_alpha)
self.button = DirectFrame(frameColor=(1.0, 1.0, 1.0, 1.0),
frameTexture='image/button.png',
frameSize=(0, 128, -128, 0),
text='1',
text_font=font64,
text_scale=64,
text_fg=Vec4(1.0),
text_align=TextNode.A_center,
text_pos=(64, -79),
textMayChange=1,
pos=(-64, 0, 64),
state=DGG.NORMAL,
suppressMouse=True,
parent=pixel2d)
self.button.flatten_light()
self.button.bind(DGG.B1PRESS, self.on_button_click)
self.button.wrt_reparent_to(aspect2d)
self.button.set_transparency(TransparencyAttrib.M_alpha)
self.button.set_pos(0, 0, 0)
self.button.set_bin("fixed", 11)
self.button.hide()
self.last_number = None
self.points = []
self.fake_button = DirectFrame(frameColor=(1.0, 1.0, 1.0, 1.0),
frameTexture='image/button.png',
frameSize=(0, 128, -128, 0),
text='1',
text_font=font64,
text_scale=64,
text_fg=Vec4(1.0),
text_align=TextNode.A_center,
text_pos=(64, -79),
textMayChange=1,
pos=(-64, 0, 64),
parent=pixel2d)
self.fake_button.flatten_light()
self.fake_button.wrt_reparent_to(aspect2d)
self.fake_button.set_transparency(TransparencyAttrib.M_alpha)
self.fake_button.set_pos(0, 0, 0)
self.button.set_bin("fixed", 11)
self.fake_button.hide()
base.buttonThrowers[0].node().setButtonDownEvent('buttonDown')
self.accept('buttonDown', self.start)
self.music = loader.load_music('music/the_silly_number_song.ogg')
self.beat_count = 0
self.beat_tsk = None
self.images_seq = make_image_sequence(self.foreground)
self.buttons_seq = make_button_sequence(self.button, self.fake_button)
self.stubtitles_seq = make_song_sequence(self.text_node, self.music)
self.stubtitles_seq.append(Wait(7.0))
self.stubtitles_seq.append(Func(self.reset))
def reset(self):
taskMgr.remove(self.beat_tsk)
self.text_node.set_text('Press any key to start!')
self.foreground.hide()
self.background.setImage('image/title_screen.png')
self.fake_button.hide()
self.button.hide()
self.points = []
self.beat_count = 0
self.last_number = None
base.buttonThrowers[0].node().setButtonDownEvent('buttonDown')
self.accept('buttonDown', self.start)
def hide_button(self, task):
if self.last_number == self.button['text']:
self.button.hide()
return task.done
def reset_button(self, task):
self.button['frameTexture'] = 'image/button.png'
return task.done
def on_button_click(self, event=None):
self.button['frameTexture'] = 'image/button_down.png'
self.last_number = self.button['text']
if self.last_number not in self.points:
self.points.append(self.last_number)
self.fake_button.hide()
#update displayed score:
self.score_text_node.set_text('Score: {0}'.format(len(
self.points)))
taskMgr.doMethodLater(0.1, self.reset_button, 'reset_tsk')
taskMgr.doMethodLater(0.2, self.hide_button, 'hide_tsk')
def beat(self, task):
self.beat_count += 1
if self.beat_count % 2 == 0:
self.background.setImage(
loader.load_texture('image/background2.png'))
else:
self.background.setImage(
loader.load_texture('image/background.png'))
return task.again
def start(self, event=None):
self.score_text_node.set_text('Score: 0')
self.ignore('buttonDown')
self.beat_tsk = taskMgr.doMethodLater(0.24, self.beat, 'beat_tsk')
self.buttons_seq.start()
self.stubtitles_seq.start()
self.images_seq.start()
class Tutorial(DirectObject):
def __init__(self, background, cursor, pointer):
#-----------------------------------------------------------------------------------------------------------------------------------------------
#---------------------------------------------------VARIABLE DECLARATION------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Background
self.back = background
# Level
self.level = Level_Tutorial(background)
# Graphic components
#Blackboard
self.blackboard = OnscreenImage(image="./tex/blackboard_empty.png",
pos=(0, 0, 0),
hpr=None,
scale=(1.25, 1.0, 0.90),
color=None,
parent=None,
sort=0)
self.blackboard.setTransparency(TransparencyAttrib.MAlpha)
self.blackboard.hide()
#Main Character
self.char = CMain(-18, -5, 59)
#Energy Bar
self.energyBar = BEnergy()
self.energyBar.increase(50)
#Abilies Bar
self.grainAbility = BAbility("GRAIN")
self.fruitAbility = BAbility("FRUIT")
self.milkAbility = BAbility("MILK")
self.vegetableAbility = BAbility("VEGETABLE")
self.fishAbility = BAbility("FISH")
#Shape
self.shape = OnscreenImage(image="./tex/cereal_ability_shape.png",
pos=(-0.75, 0, 0),
hpr=None,
scale=0.25,
color=None,
parent=None,
sort=1)
self.shape.setTransparency(TransparencyAttrib.MAlpha)
self.shape.hide()
#Item
self.item = OnscreenImage(image="./tex/rice.png",
pos=(-0.75, 0, -0.4),
hpr=None,
scale=0.09,
color=None,
parent=None,
sort=1)
self.item.setTransparency(TransparencyAttrib.MAlpha)
self.item.hide()
#Texts
self.text = OnscreenImage(image="./tex/tryToDrawThisShape.png",
pos=(-0.75, 0, 0.6),
hpr=None,
scale=0.35,
color=None,
parent=None,
sort=1)
self.text.setTransparency(TransparencyAttrib.MAlpha)
self.text.hide()
self.grassText = OnscreenImage(image="./tex/moveThroughTheGrass.png",
pos=(0, 0, 0),
hpr=None,
scale=0.7,
color=None,
parent=None,
sort=1)
self.grassText.setTransparency(TransparencyAttrib.MAlpha)
#Info
self.infError = OnscreenImage(image="./tex/wrong_attack.png",
pos=(0.4, 0, 0),
hpr=None,
scale=(0.47, 1.0, 0.55),
color=None,
parent=None,
sort=5)
self.infError.setTransparency(TransparencyAttrib.MAlpha)
self.infError.hide()
self.infCereal = OnscreenImage(image="./tex/cereal_attack.png",
pos=(0.4, 0, 0),
hpr=None,
scale=0.45,
color=None,
parent=None,
sort=5)
self.infCereal.setTransparency(TransparencyAttrib.MAlpha)
self.infCereal.hide()
self.infFish = OnscreenImage(image="./tex/fish_attack.png",
pos=(0.4, 0, 0),
hpr=None,
scale=0.5,
color=None,
parent=None,
sort=5)
self.infFish.setTransparency(TransparencyAttrib.MAlpha)
self.infFish.hide()
self.infMilk = OnscreenImage(image="./tex/milk_attack.png",
pos=(0.4, 0, 0),
hpr=None,
scale=0.5,
color=None,
parent=None,
sort=5)
self.infMilk.setTransparency(TransparencyAttrib.MAlpha)
self.infMilk.hide()
self.infVege = OnscreenImage(image="./tex/vege_attack.png",
pos=(0.4, 0, 0),
hpr=None,
scale=0.4,
color=None,
parent=None,
sort=5)
self.infVege.setTransparency(TransparencyAttrib.MAlpha)
self.infVege.hide()
self.infFruit = OnscreenImage(image="./tex/fruit_attack.png",
pos=(0.4, 0, 0),
hpr=None,
scale=0.4,
color=None,
parent=None,
sort=5)
self.infFruit.setTransparency(TransparencyAttrib.MAlpha)
self.infFruit.hide()
#Logo
self.logo = OnscreenImage(image="./tex/laSalleAlpha.png",
pos=(1.05, 0, -0.85),
hpr=None,
scale=(0.22, 1.0, 0.075),
color=None,
parent=None,
sort=5)
self.logo.setTransparency(TransparencyAttrib.MAlpha)
# Others
self.shapeNum = 0
self.drawedOK = 0
self.finished = False
self.drawing = False
self.readyForGame = False
self.inGame = False
self.busy = False
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------TUTORIAL INIT------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Glove gestures configuration
self.cursor = cursor
self.gestureHandler = GestureRecognition(
"Gesture_Handler",
[
("1", 0),
("2", 0),
("3", 0),
("4", 0),
("6", 0),
("7", 0),
("8", 0),
("9", 0), #NONE
("12", 0),
("13", 0),
("16", 0),
("18", 0),
("17", 0),
("14", 0), #NONE
("23", 0),
("26", 0),
("29", 0),
("27", 0),
("24", 0),
("21", 0), #NONE
("36", 0),
("39", 0),
("38", 0),
("34", 0),
("31", 0),
("32", 0), #NONE
("41", 0),
("42", 0),
("43", 0),
("49", 0),
("48", 0),
("47", 0), #NONE
("69", 0),
("68", 0),
("67", 0),
("61", 0),
("62", 0),
("63", 0), #NONE
("74", 0),
("71", 0),
("72", 0),
("76", 0),
("79", 0),
("78", 0), #NONE
("87", 0),
("84", 0),
("81", 0),
("83", 0),
("86", 0),
("89", 0), #NONE
("98", 0),
("97", 0),
("94", 0),
("92", 0),
("93", 0),
("96", 0), #NONE
("93934", 1), #FRUIT
("7624", 2), #MILK
("67616", 3), #VEGETABLE
("183", 4), #FISH
("3434", 5)
], #CEREAL
self.cursor,
True,
1,
0,
0)
self.accept("Gesture_Handler", self.gestureProcessing)
self.pointer = pointer
# Events declaration
self.accept("WM_BUTTON_PRESSED", self.handleBtnPress)
self.accept("WM_BUTTON_RELEASED", self.handleBtnRelease)
taskMgr.add(self.taskMove, 'taskMove')
taskMgr.add(self.taskCollision, 'taskCollision')
taskMgr.add(self.taskTextGrass, 'taskTextGrass')
#end __init__
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------FUNCTIONS----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# WiiMote button pressed handler
def handleBtnPress(self, btn, dev, index):
if (self.finished == False):
if (index == 1):
if (btn == wiiuse.BUTTON_A):
if self.drawing == True:
# We're on the second part of the tutorial
if (self.readyForGame == False):
# We're ready for playing
if (self.inGame == False):
if (self.busy == False):
self.gestureHandler.beginGesture()
#end handleBrnPress
# WiiMote button released handler
def handleBtnRelease(self, btn, dev, index):
if (self.finished == False):
if (index == 1):
if (btn == wiiuse.BUTTON_A):
if self.drawing == True:
# We're on the second part of the tutorial
if (self.readyForGame == True):
# We're going to play the game
self.hide()
self.game = Game(self.back, self.cursor,
self.pointer)
self.inGame = True
self.readyForGame = False
else:
#We're on the second part of the tutorial
if (self.inGame == False):
if (self.busy == False):
self.gestureHandler.endGesture()
else:
#We're on the first part of the tutorial
self.showBlackboard()
#end handleBtnRelease
# It makes appear the blackboard
def showBlackboard(self):
if self.level.scene2 == 2:
self.grassText.hide()
taskMgr.remove('taskMove')
taskMgr.remove('taskGlowing6')
self.energyBar.hide()
self.blackboard.show()
self.shape.show()
self.item.show()
self.text.show()
self.drawing = True
#end showBlackboard
# It hides the tutorial application
def hide(self):
self.blackboard.hide()
self.shape.hide()
self.shape = None
self.text.hide()
self.text = None
self.grassText.hide()
self.grassText = None
self.char.hide()
taskMgr.remove('taskMove')
self.char = None
self.energyBar.hide()
self.energyBar = None
self.grainAbility.hide()
self.grainAbility = None
self.fruitAbility.hide()
self.fruitAbility = None
self.milkAbility.hide()
self.milkAbility = None
self.vegetableAbility.hide()
self.vegetableAbility = None
self.fishAbility.hide()
self.fishAbility = None
taskMgr.remove('taskCollision')
self.level.removeItems()
self.level = None
self.item.hide()
self.item = None
#end hide
# It identifies the shapes drawn.
def gestureProcessing(self, id, x, y):
if (self.inGame == False):
#------------------------------------------------------------------FRUIT---------------------------------------------------------------------
if id == 1:
if (self.shapeNum == 4):
self.infFruit.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add(self.taskCorrect, 'taskCorrect')
else:
self.infError.show()
taskMgr.add(self.taskError, 'taskError')
#------------------------------------------------------------------MILK----------------------------------------------------------------------
elif id == 2:
if (self.shapeNum == 2):
self.infMilk.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add(self.taskCorrect, 'taskCorrect')
else:
self.infError.show()
taskMgr.add(self.taskError, 'taskError')
#---------------------------------------------------------------VEGETABLE-------------------------------------------------------------------
elif id == 3:
if (self.shapeNum == 3):
self.infVege.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add(self.taskCorrect, 'taskCorrect')
else:
self.infError.show()
taskMgr.add(self.taskError, 'taskError')
#------------------------------------------------------------------FISH---------------------------------------------------------------------
elif id == 4:
if (self.shapeNum == 1):
self.infFish.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add(self.taskCorrect, 'taskCorrect')
else:
self.infError.show()
taskMgr.add(self.taskError, 'taskError')
#----------------------------------------------------------------CEREAL--------------------------------------------------------------------
elif id == 5:
if (self.shapeNum == 0):
self.infCereal.show()
self.drawedOK = self.drawedOK + 1
taskMgr.add(self.taskCorrect, 'taskCorrect')
else:
self.infError.show()
taskMgr.add(self.taskError, 'taskError')
#------------------------------------------------------------------NONE-------------------------------------------------------------------
else:
taskMgr.add(self.taskError, 'taskError')
self.infError.show()
self.gestureHandler.clearGestures()
self.busy = True
#end gestureProcessing
# It changes the shape showed to the user, depending on the shape practised.
def changeShape(self):
if (self.shapeNum == 0):
self.shape.setImage("./tex/cereal_ability_shape.png")
self.item.setImage("./tex/rice.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if (self.shapeNum == 1):
self.shape.setImage("./tex/fish_ability_shape.png")
self.item.setImage("./tex/fish.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if (self.shapeNum == 2):
self.shape.setImage("./tex/milk_ability_shape.png")
self.item.setImage("./tex/milk.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if (self.shapeNum == 3):
self.shape.setImage("./tex/vegetable_ability_shape.png")
self.item.setImage("./tex/letuce.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if (self.shapeNum == 4):
self.shape.setImage("./tex/fruit_ability_shape.png")
self.item.setImage("./tex/straw.png")
self.item.setTransparency(TransparencyAttrib.MAlpha)
if (self.shapeNum == 5):
self.shape.hide()
self.text.setImage("./tex/youAreReady.png")
self.text.setTransparency(TransparencyAttrib.MAlpha)
self.item.hide()
#end changeShape
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------TASKS,THREADS------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# It moves the main character to the sun pointer point.
def taskMove(self, task):
mpos = self.cursor.getCursorPos()
# Moving the main character
self.char.movement(mpos.getX(), mpos.getY())
if self.level.scene2 == 1:
self.grassText.setImage("./tex/PressAButton.png")
self.grassText.setTransparency(TransparencyAttrib.MAlpha)
self.grassText.show()
self.level.scene2 = 2
return task.cont
#end taskCursor
# It checks Character-Item collision
def taskCollision(self, task):
#Character-Item collision
for x in self.level.items:
if x.collide(self.char):
self.char.itemCollect(x)
self.level.items.remove(x)
x.posX = -100
x.model.setX(x.posX)
x.posY = -100
x.model.setZ(x.posY)
x.collectIt = True
self.energyBar.increase(x.energy)
if x.specialItem == True:
self.specialItems.itemCollected(x.type)
# Producing glowing on abilities bar
if x.type == "GRAIN":
self.grainAbility.itemCollected(1)
taskMgr.add(self.grainAbility.taskGlowing, 'taskGlowing1')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
if x.type == "FRUIT":
self.fruitAbility.itemCollected(1)
taskMgr.add(self.fruitAbility.taskGlowing, 'taskGlowing2')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
if x.type == "MILK":
self.milkAbility.itemCollected(1)
taskMgr.add(self.milkAbility.taskGlowing, 'taskGlowing3')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
if x.type == "VEGETABLE":
self.vegetableAbility.itemCollected(1)
taskMgr.add(self.vegetableAbility.taskGlowing,
'taskGlowing4')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
if x.type == "FISH":
self.fishAbility.itemCollected(1)
taskMgr.add(self.fishAbility.taskGlowing, 'taskGlowing5')
taskMgr.add(self.energyBar.taskGlowing, 'taskGlowing6')
return task.cont
#end taskCollision
# It manages the tutorial in order to teach all the shapes to the user.
# Each shape is practised two times.
def taskCorrect(self, task):
if (task.time > 1):
if (self.shapeNum == 0): self.infCereal.hide()
if (self.shapeNum == 1): self.infFish.hide()
if (self.shapeNum == 2): self.infMilk.hide()
if (self.shapeNum == 3): self.infVege.hide()
if (self.shapeNum == 4): self.infFruit.hide()
self.busy = False
self.text.setImage("./tex/onceAgain.png")
self.text.setTransparency(TransparencyAttrib.MAlpha)
if (self.drawedOK > 1):
self.shapeNum = self.shapeNum + 1
if (self.shapeNum == 5): self.readyForGame = True
self.drawedOK = 0
self.text.setImage("./tex/tryNewOne.png")
self.text.setTransparency(TransparencyAttrib.MAlpha)
self.changeShape()
return task.done
else:
return task.cont
#end taskCursor
# It shows a message of don't worry to the user.
def taskError(self, task):
if (task.time > 1):
self.busy = False
self.infError.hide()
self.text.setImage("./tex/dontWorry.png")
self.text.setTransparency(TransparencyAttrib.MAlpha)
return task.done
else:
return task.cont
#end taskCursor
# It shows a determined text for 3 seconds.
def taskTextGrass(self, task):
if (task.time > 3):
self.grassText.hide()
return task.done
else:
return task.cont
class HUD(DirectObject):
#TODO: Preload all images
def __init__(self, base, player):
self.base = base
self.player = player
self.heartmax = 160
self.heartmin = 80
self.heartbpm = self.heartmin
self.heartaccum = 0
self.last = 0
self.heartbasis = 'assets/images/heartbeat2-%d.png'
self.heartframe = 0
self.heartimage = OnscreenImage(self.heartbasis % (1,), scale=(0.1,0.1,0.1), pos=(-1,0, 0.8))
self.keyimage = OnscreenImage('assets/images/key.png', scale=(0.08,0.08,0.08), pos=(-1,0,0.60))
self.keyimage.setTransparency(TransparencyAttrib.MAlpha)
self.text = OnscreenText('', pos=(-0.8, 0.8), scale=0.05, fg=(0,1,0,1), bg=(0,0,0,0))
self.hasKey = False
self.base.taskMgr.add(self.update, 'hud')
def __del__(self):
self.base = None
self.player = None
self.heartimage.destroy()
self.text.destroy()
def update(self, task):
if self.player.isAlive():
elapsed = task.time - self.last
self.last = task.time
# After a certain point, it should be cleared
# Fear must also increase heartbeat
f, b = self.player.fear, self.player.breath
bpm = 80 + 200 * (0.75 + 0.25 * f) * (1 - b) + 40 * f
self.heartaccum += elapsed * (bpm + self.heartbpm) / 2.0
self.heartbpm = bpm
self.heartframe = int(8 * self.heartaccum / 60) % 8
self.heartimage.setImage(self.heartbasis % (self.heartframe + 1,))
self.heartimage.setTransparency(TransparencyAttrib.MAlpha)
#TODO: Update parameters
heartampl = self.heartmax - self.heartmin
if self.heartbpm < self.heartmax:
s = float(self.heartbpm - self.heartmin) / heartampl
self.text.setFg((s,1,0,1))
else:
s = float(self.heartbpm - self.heartmax) / heartampl
self.text.setFg((1,1-s,0,1))
self.text.setText('%d BPM' % (self.heartbpm,))
else:
self.text.setFg((1,1,1,1))
self.text.setText('0 BPM')
#TODO: send a 'death' event and, possibly, play back a nice heart stopping animation
#return task.done
if (self.hasKey):
self.keyimage.show()
else:
self.keyimage.hide()
self.heartimage.show()
self.text.show()
return task.cont
def hide(self):
self.heartimage.hide()
self.text.hide()
def setKey(self, key):
self.hasKey = key
