class Text(Billboard):
def __init__(self,
name,
nodePath,
offset,
text,
stencilId,
scale=0.025000000000000001,
*args,
**kwargs):
Billboard.__init__(self, name, nodePath, *args, **kwargs)
self.setBin('fixed', 110)
self.scale = scale
self.textNode = OnscreenText(text=text,
fg=Vec4(0, 0, 0, 1),
scale=scale,
shadow=Vec4(0, 0, 0, 0),
mayChange=True,
font=PiratesGlobals.getPirateFont())
self.textNode.detachNode()
sNode = self.attachNewNode('stencil')
sNode.setY(-offset)
self.textNode.instanceTo(sNode)
sNode.setDepthTest(False)
def setBold(self, bold):
self.textNode.setShadow(Vec4(0, 0, 0, bold))
def setTextScale(self, scale):
self.textNode.setScale(self.scale * scale)
class Text(Billboard):
def __init__(self, name, nodePath, offset, text, stencilId, scale = 0.025000000000000001, *args, **kwargs):
Billboard.__init__(self, name, nodePath, *args, **kwargs)
self.setBin('fixed', 110)
self.scale = scale
self.textNode = OnscreenText(text = text, fg = Vec4(0, 0, 0, 1), scale = scale, shadow = Vec4(0, 0, 0, 0), mayChange = True, font = PiratesGlobals.getPirateFont())
self.textNode.detachNode()
sNode = self.attachNewNode('stencil')
sNode.setY(-offset)
self.textNode.instanceTo(sNode)
sNode.setDepthTest(False)
def setBold(self, bold):
self.textNode.setShadow(Vec4(0, 0, 0, bold))
def setTextScale(self, scale):
self.textNode.setScale(self.scale * scale)
class DebugOptions(DirectObject):
def __init__(self, parent):
self.parent = parent
self.textPlayerPos = OnscreenText(text = '', parent=base.a2dTopLeft, pos = (0, -0.1), scale = 0.04,fg=(1, 1, 1, 1),align=TextNode.ALeft)
self.showFps = True
base.setFrameRateMeter(True)
self.ambientLight = True
self.parent.alight.setColor(VBase4(0.43, 0.43, 0.43, 1.0))
self.flashlightFrustum = False
self.autoShader = True
render.setShaderAuto()
self.playerPos = True
taskMgr.add(self.refreshPlayerPos, 'RefreshPlayerPosTask')
self.textPlayerPos.reparentTo(base.a2dTopLeft)
self.bloom = False
self.blur = False
self.ao = False
self.walls = True
#spotlightpanel
self.spot_light_panel = SpotlightPanel(self, self.parent.player.slight)
base.accept('f1', self.toggleFps)
base.accept('f2', self.toggleAmbientLight)
base.accept('f3', self.toggleFlashlightFrustum)
base.accept('f4', self.parent.player.getDamage)
base.accept('f5', self.toggleAutoShader)
base.accept('f6', self.togglePlayerPos)
base.accept('f7', self.toggleBloom)
base.accept('f8', self.toggleBlur)
base.accept('f9', self.toggleAO)
base.accept('f10', self.toggleWalls)
base.accept('f11', render.analyze)
base.accept('f12', self.debugPrint)
def toggleFps(self):
if self.showFps == False:
self.showFps = True
base.setFrameRateMeter(True)
else:
self.showFps = False
base.setFrameRateMeter(False)
def toggleAmbientLight(self):
if self.ambientLight == False:
self.ambientLight = True
self.parent.alight.setColor(VBase4(0.43, 0.43, 0.43, 1.0))
else:
self.ambientLight = False
self.parent.alight.setColor(VBase4(0.03, 0.03, 0.03, 1.0))
def toggleFlashlightFrustum(self):
if self.flashlightFrustum == False:
self.flashlightFrustum = True
self.parent.slight.showFrustum()
else:
self.flashlightFrustum = False
self.parent.slight.hideFrustum()
def toggleAutoShader(self):
if self.autoShader == False:
self.autoShader = True
render.setShaderAuto()
else:
self.autoShader = False
render.setShaderOff()
def toggleWalls(self):
if self.walls == False:
self.walls = True
self.parent.level.wall_node.reparentTo(self.parent.level.node)
else:
self.walls = False
self.parent.level.wall_node.detachNode()
def togglePlayerPos(self):
if self.playerPos == False:
self.playerPos = True
taskMgr.add(self.refreshPlayerPos, 'RefreshPlayerPosTask')
self.textPlayerPos.reparentTo(base.a2dTopLeft)
else:
self.playerPos = False
taskMgr.remove('RefreshPlayerPosTask')
self.textPlayerPos.detachNode()
def toggleBloom(self):
if self.bloom == False:
self.bloom = True
self.parent.filters.setBloom()
else:
self.bloom = False
self.parent.filters.delBloom()
def toggleBlur(self):
if self.blur == False:
self.blur = True
self.parent.filters.setBlurSharpen()
else:
self.blur = False
self.parent.filters.delBlurSharpen()
def toggleAO(self):
if self.ao == False:
self.ao = True
self.parent.filters.setAmbientOcclusion()
else:
self.ao = False
self.parent.filters.delAmbientOcclusion()
def refreshPlayerPos(self, task):
px, py, pz = self.parent.player.node.getPos()
self.textPlayerPos.setText('Player pos: (%0.3f, %0.3f, %0.3f)' % (px, py, pz))
return task.cont
def debugPrint(self):
print taskMgr
class InputControlStim(ShowBase):
"""
Generic input-controll stimulus class: takes in list of texture classes, and stimulus parameters.
Stimulus shown, in real-time, depends on events produced by utils.Monitor() class.
Inputs:
Positional
tex_classes: m-element list of texture classes
stim_params: m-element list of dictionaries: each contains parameters (e.g., velocity)
Keyword
initial_tex_ind (0): index for first stim to show
window_size (512): size of the panda3d window (pixels)
window_name ('InputControlStim'): title of window in gui
profile_on (False): will show actual fps, profiler, and little x at center if True
fps (30): controls frame rate of display
save_path (None): if set to a file path, will save data about stimuli, and time they are delivered
"""
def __init__(self,
tex_classes,
stim_params,
initial_tex_ind=0,
window_size=512,
window_name="InputControlStim",
profile_on=False,
fps=30,
save_path=None):
super().__init__()
self.current_tex_num = initial_tex_ind
self.previous_tex_num = None
self.tex_classes = tex_classes
self.stim_params = stim_params
self.window_size = window_size
self.stimulus_initialized = False # for setting up first stim (don't clear cards they don't exist)
self.fps = fps
self.profile_on = profile_on
self.save_path = save_path
if self.save_path:
self.filestream = utils.save_initialize(save_path, tex_classes,
stim_params)
else:
self.filestream = None
self.scale = np.sqrt(
8) #so it can handle arbitrary rotations and shifts
self.window_name = window_name
#Window properties
self.window_props = WindowProperties()
self.window_props.setSize(self.window_size, self.window_size)
self.set_title(self.window_name)
# Set frame rate
ShowBaseGlobal.globalClock.setMode(ClockObject.MLimited)
ShowBaseGlobal.globalClock.setFrameRate(self.fps)
#Set up profiling if desired
if self.profile_on:
PStatClient.connect() # this will only work if pstats is running
ShowBaseGlobal.base.setFrameRateMeter(True) #Show frame rate
#Set initial texture(s)
self.set_stimulus(str(self.current_tex_num))
# Set up event handlers (accept) and tasks (taskMgr) for dynamics
self.accept('stim0', self.set_stimulus, ['0'])
self.accept('stim1', self.set_stimulus, ['1'])
self.accept('stim2', self.set_stimulus, ['2'])
# Wrinkle: should we set this here or there?
self.taskMgr.add(self.move_textures, "move textures")
def set_tasks(self):
if self.current_stim_params['stim_type'] == 'b':
self.taskMgr.add(self.textures_update, "move_both")
#Move textures
def move_textures(self, task):
if self.current_stim_params['stim_type'] == 'b':
left_tex_position = -task.time * self.current_stim_params[
'velocities'][0] #negative b/c texture stage
right_tex_position = -task.time * self.current_stim_params[
'velocities'][1]
try:
self.left_card.setTexPos(self.left_texture_stage,
left_tex_position, 0, 0)
self.right_card.setTexPos(self.right_texture_stage,
right_tex_position, 0, 0)
except Exception as e:
logger.error(e)
elif self.current_stim_params['stim_type'] == 's':
if self.current_stim_params['velocity'] == 0:
pass
else:
new_position = -task.time * self.current_stim_params['velocity']
# Sometimes setting position fails when the texture stage isn't fully set
try:
self.card.setTexPos(self.texture_stage, new_position, 0,
0) #u, v, w
except Exception as e:
logger.error(e)
return task.cont
@property
def texture_size(self):
return self.tex_classes[self.current_tex_num].texture_size
@property
def current_stim_params(self):
"""
Parameters of current texture (e.g., velocity, stim_type)
"""
return self.stim_params[self.current_tex_num]
def create_cards(self):
"""
Create cards: these are panda3d objects that are required for displaying textures.
You can't just have a disembodied texture. In pandastim (at least for now) we are
only showing 2d projections of textures, so we use cards.
"""
cardmaker = CardMaker("stimcard")
cardmaker.setFrameFullscreenQuad()
#Binocular cards
if self.current_stim_params['stim_type'] == 'b':
self.setBackgroundColor(
(0, 0, 0, 1)) # without this the cards will appear washed out
self.left_card = self.aspect2d.attachNewNode(cardmaker.generate())
self.left_card.setAttrib(
ColorBlendAttrib.make(
ColorBlendAttrib.M_add)) # otherwise only right card shows
self.right_card = self.aspect2d.attachNewNode(cardmaker.generate())
self.right_card.setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.M_add))
if self.profile_on:
self.center_indicator = OnscreenText(
"x",
style=1,
fg=(1, 1, 1, 1),
bg=(0, 0, 0, .8),
pos=self.current_stim_params['position'],
scale=0.05)
# Tex card
elif self.current_stim_params['stim_type'] == 's':
self.card = self.aspect2d.attachNewNode(cardmaker.generate())
self.card.setColor((1, 1, 1, 1)) #?
self.card.setScale(self.scale)
return
def create_texture_stages(self):
"""
Create the texture stages: these are basically textures that you can apply
to cards (sometimes mulitple textures at the same time -- is useful with
masks).
For more on texture stages:
https://docs.panda3d.org/1.10/python/programming/texturing/multitexture-introduction
"""
#Binocular cards
if self.current_stim_params['stim_type'] == 'b':
#TEXTURE STAGES FOR LEFT CARD
# Texture itself
self.left_texture_stage = TextureStage('left_texture_stage')
# Mask
self.left_mask = Texture("left_mask_texture")
self.left_mask.setup2dTexture(self.texture_size, self.texture_size,
Texture.T_unsigned_byte,
Texture.F_luminance)
self.left_mask_stage = TextureStage('left_mask_array')
#TEXTURE STAGES FOR RIGHT CARD
self.right_texture_stage = TextureStage('right_texture_stage')
#Mask
self.right_mask = Texture("right_mask_texture")
self.right_mask.setup2dTexture(self.texture_size,
self.texture_size,
Texture.T_unsigned_byte,
Texture.F_luminance)
self.right_mask_stage = TextureStage('right_mask_stage')
# Tex card
elif self.current_stim_params['stim_type'] == 's':
self.texture_stage = TextureStage("texture_stage")
return
def set_stimulus(self, data):
"""
Uses events from zmq to set the stimulus value.
"""
logger.debug("\tset_stimulus(%s)", data)
if not self.stimulus_initialized:
# If this is first stim, then toggle initialization to on, and
# do not clear previous texture (there is no previous texture).
self.stimulus_initialized = True
self.data_previous = data
elif data == self.data_previous:
return
else:
self.data_previous = data
self.clear_cards() #clear the textures before adding new ones
# This assumes data streaming is string numbers 0, 1, etc.
self.current_tex_num = int(data)
# Set new texture stages/cards etc
self.tex = self.tex_classes[self.current_tex_num]
logger.debug("\t%d: %s", self.current_tex_num, self.tex)
self.create_texture_stages()
self.create_cards()
self.set_texture_stages()
self.set_transforms()
#Save stim to file (put this last as you want to set transforms quickly)
if self.filestream:
self.filestream.write(f"{str(datetime.now())}\t{data}\n")
self.filestream.flush()
return
def clear_cards(self):
"""
Clear cards when new stimulus: stim-class sensitive
"""
if self.current_stim_params['stim_type'] == 'b':
self.left_card.detachNode()
self.right_card.detachNode()
if self.profile_on:
self.center_indicator.detachNode()
elif self.current_stim_params['stim_type'] == 's':
self.card.detachNode()
return
def set_transforms(self):
"""
Set up the transforms to apply to textures/cards (e.g., rotations/scales)
This is different from the framewise movement handled by the task manager
"""
if self.current_stim_params['stim_type'] == 'b':
#masks
self.mask_transform = self.trs_transform()
self.left_card.setTexTransform(self.left_mask_stage,
self.mask_transform)
self.right_card.setTexTransform(self.right_mask_stage,
self.mask_transform)
#Left texture
self.left_card.setTexScale(self.left_texture_stage, 1 / self.scale)
self.left_card.setTexRotate(self.left_texture_stage,
self.current_stim_params['angles'][0])
#Right texture
self.right_card.setTexScale(self.right_texture_stage,
1 / self.scale)
self.right_card.setTexRotate(self.right_texture_stage,
self.current_stim_params['angles'][1])
if self.current_stim_params['stim_type'] == 's':
self.card.setTexRotate(self.texture_stage,
self.current_stim_params['angle'])
return
def set_texture_stages(self):
"""
Add texture stages to cards
"""
if self.current_stim_params['stim_type'] == 'b':
self.mask_position_uv = (
utils.card2uv(self.current_stim_params['position'][0]),
utils.card2uv(self.current_stim_params['position'][1]))
#CREATE MASK ARRAYS
self.left_mask_array = 255 * np.ones(
(self.texture_size, self.texture_size), dtype=np.uint8)
self.left_mask_array[:, self.texture_size // 2 -
self.current_stim_params['strip_width'] //
2:] = 0
self.right_mask_array = 255 * np.ones(
(self.texture_size, self.texture_size), dtype=np.uint8)
self.right_mask_array[:, :self.texture_size // 2 +
self.current_stim_params['strip_width'] //
2] = 0
#ADD TEXTURE STAGES TO CARDS
self.left_mask.setRamImage(self.left_mask_array)
self.left_card.setTexture(self.left_texture_stage,
self.tex.texture)
self.left_card.setTexture(self.left_mask_stage, self.left_mask)
#Multiply the texture stages together
self.left_mask_stage.setCombineRgb(TextureStage.CMModulate,
TextureStage.CSTexture,
TextureStage.COSrcColor,
TextureStage.CSPrevious,
TextureStage.COSrcColor)
self.right_mask.setRamImage(self.right_mask_array)
self.right_card.setTexture(self.right_texture_stage,
self.tex.texture)
self.right_card.setTexture(self.right_mask_stage, self.right_mask)
#Multiply the texture stages together
self.right_mask_stage.setCombineRgb(TextureStage.CMModulate,
TextureStage.CSTexture,
TextureStage.COSrcColor,
TextureStage.CSPrevious,
TextureStage.COSrcColor)
elif self.current_stim_params['stim_type'] == 's':
self.card.setTexture(self.texture_stage, self.tex.texture)
return
def trs_transform(self):
"""
trs = translate-rotate-scale transform for mask stage
panda3d developer rdb contributed to this code
"""
pos = 0.5 + self.mask_position_uv[0], 0.5 + self.mask_position_uv[1]
center_shift = TransformState.make_pos2d((-pos[0], -pos[1]))
scale = TransformState.make_scale2d(1 / self.scale)
rotate = TransformState.make_rotate2d(
self.current_stim_params['strip_angle'])
translate = TransformState.make_pos2d((0.5, 0.5))
return translate.compose(rotate.compose(scale.compose(center_shift)))
def set_title(self, title):
self.window_props.setTitle(title)
ShowBaseGlobal.base.win.requestProperties(
self.window_props) #base is a panda3d global
class StabilityExperiment(ViewTowers):
def __init__(self, *args, **kwargs):
ViewTowers.__init__(self, *args, **kwargs)
# ignore keys set by viewer
for key in self.getAllAccepting():
if key in ("s", "escape"):
continue
self.ignore(key)
self.permanent_events = self.getAllAccepting()
# global variables
self.text_bg = (1, 1, 1, 0.7)
self.font = self.loader.loadFont('cmr12.egg')
self.question = [
"Will this tower fall?",
[[1, "definitely will not fall"],
[2, "probably will not fall"],
[3, "might not fall"],
[4, "don't know"],
[5, "might fall"],
[6, "probably will fall"],
[7, "definitely will fall"]]]
self.question_keys = ["1", "2", "3", "4", "5", "6", "7"]
self.choice_text_start = 0.65
self.feedback_time = 3.0
self.buffer_time = 0.75
# create text
self.create_all_text()
def run(self):
# Show the start screen
self.toggle_task("show_start_screen")
# Call parent's run().
ShowBase.run(self)
def create_all_text(self):
self.continue_text = OnscreenText(**{
"text": (
"In a moment, you will be asked the question displayed on "
"the left. When you are ready, press the spacebar to begin."),
"style": 1,
"fg": (.75, 0, 0, 1),
"bg": self.text_bg,
"pos": (.4, .4),
"align": TextNode.ACenter,
"scale": .08,
"font": self.font,
"wordwrap": 20
})
self.text_parent = self.continue_text.getParent()
self.continue_text.detachNode()
xpos = -1.25
skip = .15
self.question_text = OnscreenText(**{
"text": self.question[0],
"style": 1,
"fg": (0, 0, .8, 1),
"bg": self.text_bg,
"pos": ((xpos + .05), .8),
"align": TextNode.ALeft,
"scale": .075,
"font": self.font,
"wordwrap": 35})
self.question_choice_text = []
for i in xrange(len(self.question[1])):
n = len(self.question[1]) - i - 1
ypos = self.choice_text_start - (skip * n)
t1 = OnscreenText(**{
"text": "%s" % self.question[1][i][0],
"style": 1,
"fg": (0, .1, 0, 1),
"bg": self.text_bg,
"pos": ((xpos + .1), ypos),
"align": TextNode.ALeft,
"scale": .075,
"font": self.font})
t2 = OnscreenText(**{
"text": "%s" % self.question[1][i][1],
"style": 1,
"fg": (0, .1, 0, 1),
"bg": self.text_bg,
"pos": ((xpos + 0.17), ypos),
"align": TextNode.ALeft,
"scale": .05,
"font": self.font})
t = NodePath("choice_%s" % i)
t.reparentTo(self.text_parent)
t1.reparentTo(t)
t2.reparentTo(t)
self.question_choice_text.append(t)
for t in self.question_choice_text:
t.detachNode()
self.trials_remaining_text = OnscreenText(**{
"text": "",
"style": 1,
"fg": (0, 0, 0, 1),
"bg": self.text_bg,
"pos": (-xpos, -.95),
"align": TextNode.ARight,
"scale": .05,
"font": self.font})
def show_start_screen(self, task):
self.continue_text.reparentTo(self.text_parent)
for t in self.question_choice_text:
t.reparentTo(self.text_parent)
self.accept("space", self.toggle_task, ["show_trial"])
def show_trial(self, task):
if self.sso is None:
self.goto_sso(0)
elif self.ssos.index(self.sso) == (self.n_ssos - 1):
self.exit()
else:
self.next()
n = self.n_ssos - self.ssos.index(self.sso)
self.trials_remaining_text.setText("Trials remaining: %d" % n)
self.continue_text.detachNode()
for t in self.question_choice_text:
t.detachNode()
self.camera_rot.setH(np.random.randint(0, 360))
self.cam_spin = 270
self.taskMgr.doMethodLater(self.buffer_time, self.rotate, "rotate")
def rotate(self, task):
""" Task: rotate camera."""
H = (self.camera_rot.getH() + 1) % 360
self.camera_rot.setH(H)
self.cam_spin -= 1
if self.cam_spin == 0:
self.toggle_task("show_question")
return task.done
else:
return task.cont
def show_question(self, task):
for t in self.question_choice_text:
t.reparentTo(self.text_parent)
for key in self.question_keys:
self.accept(key, self.record_response, [key])
def record_response(self, key):
for k in self.question_keys:
self.ignore(k)
for i, t in enumerate(self.question_choice_text):
if i != (int(key) - 1):
t.detachNode()
self.toggle_task("physics")
def physics(self, task):
""" Task: simulate physics."""
# Elapsed time.
dt = self._get_elapsed() - self.old_elapsed
# Update amount of time simulated so far.
self.old_elapsed += dt
# Step the physics dt time.
size_sub = self.bbase.sim_par["size_sub"]
n_subs = int(dt / size_sub)
self.bbase.step(dt, n_subs, size_sub)
if self.old_elapsed >= self.feedback_time:
self.toggle_task("show_trial")
return task.done
else:
return task.cont
class DirectionExperiment(ViewTowers):
def __init__(self, *args, **kwargs):
ViewTowers.__init__(self, *args, **kwargs)
# ignore keys set by viewer
for key in self.getAllAccepting():
if key in ("s", "escape"):
continue
self.ignore(key)
self.permanent_events = self.getAllAccepting()
# global variables
self.text_bg = (1, 1, 1, 0.7)
self.font = self.loader.loadFont('cmr12.egg')
self.question = (
"Use the mouse to indicate the direction that "
"the tower will fall.")
self.feedback_time = 3.0
self.buffer_time = 0.75
# create text
self.create_all_text()
# create direction line
self.line = LineSegs()
self.line_node = None
self.angle = None
alight = AmbientLight('alight3')
alight.setColor((0.8, 0.8, 0.8, 1))
self.line_light = self.lights.attachNewNode(alight)
def place_camera(self):
self.cameras.setPos(0, -12, 2.5)
self.look_at.setPos(0, 0, 1.5)
self.cameras.lookAt(self.look_at)
def run(self):
# Show the start screen
self.toggle_task("show_start_screen")
# Call parent's run().
ShowBase.run(self)
def create_all_text(self):
self.continue_text = OnscreenText(**{
"text": (
"In a moment, you will be asked the question displayed on "
"the left. When you are ready, press the spacebar to begin."),
"style": 1,
"fg": (.75, 0, 0, 1),
"bg": self.text_bg,
"pos": (.4, .4),
"align": TextNode.ACenter,
"scale": .08,
"font": self.font,
"wordwrap": 20
})
self.text_parent = self.continue_text.getParent()
self.continue_text.detachNode()
xpos = -1.25
self.question_text = OnscreenText(**{
"text": self.question,
"style": 1,
"fg": (0, 0, .8, 1),
"bg": self.text_bg,
"pos": ((xpos + .05), .8),
"align": TextNode.ALeft,
"scale": .075,
"font": self.font,
"wordwrap": 35})
self.trials_remaining_text = OnscreenText(**{
"text": "",
"style": 1,
"fg": (0, 0, 0, 1),
"bg": self.text_bg,
"pos": (-xpos, -.95),
"align": TextNode.ARight,
"scale": .05,
"font": self.font})
def show_start_screen(self, task):
self.continue_text.reparentTo(self.text_parent)
self.accept("space", self.toggle_task, ["show_trial"])
def show_trial(self, task):
if self.line_node is not None:
self.line_node.removeNode()
self.line_node = None
if self.sso is None:
self.goto_sso(0)
elif self.ssos.index(self.sso) == (self.n_ssos - 1):
self.exit()
else:
self.next()
n = self.n_ssos - self.ssos.index(self.sso)
self.trials_remaining_text.setText("Trials remaining: %d" % n)
self.continue_text.detachNode()
self.camera_rot.setH(np.random.randint(0, 360))
self.cam_spin = 270
self.taskMgr.doMethodLater(self.buffer_time, self.rotate, "rotate")
def rotate(self, task):
""" Task: rotate camera."""
H = (self.camera_rot.getH() + 1) % 360
self.camera_rot.setH(H)
self.cam_spin -= 1
if self.cam_spin == 0:
self.toggle_task("show_question")
return task.done
else:
return task.cont
def show_question(self, task):
self.toggle_task("draw_direction")
self.accept("mouse1", self.record_response)
def record_response(self):
self.ignore("mouse1")
self.taskMgr.remove("draw_direction")
self.toggle_task("physics")
def physics(self, task):
""" Task: simulate physics."""
# Elapsed time.
dt = self._get_elapsed() - self.old_elapsed
# Update amount of time simulated so far.
self.old_elapsed += dt
# Step the physics dt time.
size_sub = self.bbase.sim_par["size_sub"]
n_subs = int(dt / size_sub)
self.bbase.step(dt, n_subs, size_sub)
if self.old_elapsed >= self.feedback_time:
self.toggle_task("show_trial")
return task.done
else:
return task.cont
def draw_direction(self, task):
if self.mouseWatcherNode.hasMouse():
cv = self._get_collision(self.floor)
cv = cv / np.linalg.norm(cv)
self.angle = np.arctan2(cv[1], cv[0])
sx, sy, sz = self.floor.getScale() / 2.0
gx, gy, gz = self.floor.getPos()
gz += sz + 0.01
if self.line_node is not None:
self.line_node.removeNode()
self.line_node = None
self.line.reset()
self.line.setColor(1, 1, 1, 1)
self.line.setThickness(5)
self.line.moveTo(gx, gy, gz)
self.line.drawTo(cv[0] * sx, cv[1] * sy, gz)
self.line_node = self.render.attachNewNode(self.line.create())
self.line_node.setLight(self.line_light)
return task.cont
def _get_collision(self, node, debug=False):
mx = self.mouseWatcherNode.getMouseX()
my = self.mouseWatcherNode.getMouseY()
if debug:
print "mouse:", (mx, my)
# get the origin and direction of the ray extending from the
# camera to the mouse pointer
cm = np.array(self.cam.getNetTransform().getMat())
cr = CollisionRay()
cr.setFromLens(self.cam.node(), (mx, my))
cp = np.hstack([cr.getOrigin(), 1])
cd = np.hstack([cr.getDirection(), 0])
cp = np.dot(cm.T, cp)[:3]
cd = np.dot(cm.T, cd)[:3]
if cd[2] > -1:
cd[2] = -1
if debug:
print "direction:", cd
print "origin:", cp
# point on the plane, z-axis
pz = node.getPos(self.render)[2]
sz = node.getScale(self.render)[2] / 2.0
p0 = np.array([0, 0, pz + sz])
if debug:
print "p0:", p0
# this is the intersection equation that we want to solve,
# where s is the point on the line that intersects
# e_z(cp + s*cd - p0) = 0
s = (p0[2] - cp[2]) / cd[2]
if debug:
print "s:", s
# transform the collision point from line coordinates to world
# coordinates
cv = cp + s * cd
if debug:
print "collision:", cv
return cv
class Lvl03(DirectObject):
def start(self):
base.disableMouse() #turn off mouse camera control
base.enableParticles()
self.music = loader.loadMusic("models/gamedev/DEC.mp3")
self.music.play()
camera.setPosHpr(Vec3(98,-390,90), Vec3(0,-5,0))
self.ballNum = 10
self.setupStage()
self.loadModels()
self.setupLighting()
self.setupCollisions()
self.setupIntervals()
taskMgr.add(self.ballMovementTask,'ballMoveTask')
self.gameLen = 30
self.player1Weapon = ""
self.player2Weapon = ""
#hud = OnscreenImage(image = 'models/gamedev/lvl2hud.jpg', pos = (0,1,20),scale=5.0)
#hud.reparentTo(render)
globalClock.reset()
self.timer = OnscreenText("%d" % (self.gameLen-globalClock.getRealTime(),), pos = (98,145), scale = 18.0)
self.timer.setColor(1,1,1)
taskMgr.add(self.clockTask,"clockTask")
self.player1Score = 0
self.player2Score = 0
self.nodeCount1 = 0
self.nodeCount2 = 0
self.player1Invincible = 0
self.player2Invincible = 0
self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP2 = self.playerModel2.exposeJoint(None,"modelRoot","ikHandle2")
self.climbing1 = 0
self.climbing2 = 0
self.speed1 = 3.0
self.speed2 = 3.0
self.ignoreColl= 0
self.player1IsColliding = 0
self.player2IsColliding = 0
taskMgr.doMethodLater(self.gameLen, self.endGame,'gameFinished')
#taskMgr.doMethodLater(self.gameLen/2.0,self.changeMusic,'musicSwitch')
#setup key controls
self.accept("escape",sys.exit)
#self.acceptOnce("space",self.drop)
# Player 1 movement
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.acceptOnce("w", self.jump)
#Player 2 movement keys
#self.accept("l",self.fall2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.acceptOnce("o", self.jumpT2)
def setupStage(self):
self.ball = []
self.movement = []
for i in range(self.ballNum+1):
z=random.randint(1,2)
if z ==1:
z=-1
else:
z=1
weapBalls.define(self.ball,i,render)
self.movement.append(Vec3(random.random()*z,0,random.random()*z))
#self.movement[i].Vec3(random.randint(1,3),0,random.randint(1,3))
self.background2 = OnscreenImage(image = 'models/gamedev/frozenbg.JPG', pos = (98,10,0),scale=500)
self.background2.detachNode()
self.background = OnscreenImage(image = 'models/gamedev/moltenbg.JPG', pos = (98,10,0),scale=500)
self.background.reparentTo(render)
self.lava = loader.loadModel("models/gamedev/lava")
self.lava.setPosHpr(Vec3(98,0,-18),Vec3(0,5,0))
self.lava.setScale(50)
self.lava.reparentTo(render)
x1= 196
x2 = 0
m1 = 98
m2 = 107.8
len = 9.8
h = 0
a = 0
p = 0
for j in range(4):
if j > 0:
x1Old = x1
x2Old = x2
x1 = 196-(random.randint(0,3)*9.8)
x2 = 0+random.randint(0,3)*9.8
m1=98-(random.randint(0,3)*9.8)
m2= 107.8+random.randint(0,3)*9.8
for count in range(1):
l = random.randint(2,5)
r = random.randint(2,5)
c1 = random.randint(2,5)
c2 = random.randint(2,5)
if l+r < 4:
count = 0
else:
l = 4
r = 4
c1 = 2
c2 = 2
'''
if j ==1 or j == 3:
self.ladder = loader.loadModel("models/gamedev/ladder")
self.ladder.reparentTo(render)
self.ladder.setScale(1.5)
self.ladder.setPos(x2+4.9,0,h-20)
self.ladder2 = loader.loadModel("models/gamedev/ladder")
self.ladder2.reparentTo(render)
self.ladder2.setScale(1.5)
self.ladder2.setPos(x1-4.9,0,h-20)
if j == 2:
self.ladder = loader.loadModel("models/gamedev/ladder")
self.ladder.reparentTo(render)
self.ladder.setScale(1.5)
self.ladder.setPos(m1-4.9,0,h-20)
self.ladder2 = loader.loadModel("models/gamedev/ladder")
self.ladder2.reparentTo(render)
self.ladder2.setScale(1.5)
self.ladder2.setPos(m2+4.9,0,h-20)
'''
self.first = 1
for i in range(r):
'''Right half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(x1,0,h)
if self.first == 1:
self.first = 0
bounds = self.environment.getChild(0).getBounds()
center = bounds.getCenter()
poly1 = Point3(center.getX()+1, center.getY()-.5, center.getZ()+.2)
poly2 = Point3(center.getX()-(2*r-1), center.getY()-.5, center.getZ()+.2)
poly3 = Point3(center.getX()+1, center.getY()+.5, center.getZ()+.2)
poly4 = Point3(center.getX()-(2*r-1), center.getY()+.5, center.getZ()+.2)
cPoly = CollisionPolygon(poly4, poly2, poly1, poly3)
cNode = CollisionNode("platform")
cNode.addSolid(cPoly)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath.show()
x1 = x1 - len
self.first = 1
for i in range(l):
'''Left Half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(x2,0,h)
if self.first == 1:
self.first = 0
bounds = self.environment.getChild(0).getBounds()
center = bounds.getCenter()
poly1 = Point3(center.getX()+(2*l-1), center.getY()-.5, center.getZ()+.2)
poly2 = Point3(center.getX()-1, center.getY()-.5, center.getZ()+.2)
poly3 = Point3(center.getX()+(2*l-1), center.getY()+.5, center.getZ()+.2)
poly4 = Point3(center.getX()-1, center.getY()+.5, center.getZ()+.2)
cPoly = CollisionPolygon(poly4, poly2, poly1, poly3)
cNode = CollisionNode("platform")
cNode.addSolid(cPoly)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath.show()
x2 = x2 + len
self.first = 1
for i in range(c1):
'''Right half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(m1,0,h)
if self.first == 1:
self.first = 0
bounds = self.environment.getChild(0).getBounds()
center = bounds.getCenter()
poly1 = Point3(center.getX()+1, center.getY()-.5, center.getZ()+.2)
poly2 = Point3(center.getX()-(2*c1-1), center.getY()-.5, center.getZ()+.2)
poly3 = Point3(center.getX()+1, center.getY()+.5, center.getZ()+.2)
poly4 = Point3(center.getX()-(2*c1-1), center.getY()+.5, center.getZ()+.2)
cPoly = CollisionPolygon(poly4, poly2, poly1, poly3)
cNode = CollisionNode("platform")
cNode.addSolid(cPoly)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath.show()
m1 = m1 - len
self.first = 1
for i in range(c2):
'''Left Half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(m2,0,h)
if self.first == 1:
self.first = 0
bounds = self.environment.getChild(0).getBounds()
center = bounds.getCenter()
poly1 = Point3(center.getX()+(2*c2-1), center.getY()-.5, center.getZ()+.2)
poly2 = Point3(center.getX()-1, center.getY()-.5, center.getZ()+.2)
poly3 = Point3(center.getX()+(2*c2-1), center.getY()+.5, center.getZ()+.2)
poly4 = Point3(center.getX()-1, center.getY()+.5, center.getZ()+.2)
cPoly = CollisionPolygon(poly4, poly2, poly1, poly3)
cNode = CollisionNode("platform")
cNode.addSolid(cPoly)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath.show()
m2 = m2 + len
h = h+40
a = 0
def loadModels(self):
# ** Load female character that will represent first player** #
self.playerModel = Actor("models/gamedev/redguy-model",{"walk":"models/gamedev/redguy-run"})
self.playerModel.reparentTo(render)
self.playerModel.setScale(.6)
self.playerModel.setH(90)
# ** Position player at center of the field with it lying directly above the field. ** #
self.playerModel.setPos(0,0,1.76)
# ** Load female character that will represent second player** #
self.playerModel2 = Actor("models/gamedev/bluegirl-model",{"walk2":"models/gamedev/bluegirl-run"})
self.playerModel2.reparentTo(render)
self.playerModel2.setScale(.6)
self.playerModel2.setH(0)
# ** Position player at center of the field with it lying directly above the field. ** #
self.playerModel2.setPos(196,0,2.0)
def reset(self):
self.an1.getPhysicsObject().setVelocity(Vec3(0,0,0))
self.an2.getPhysicsObject().setVelocity(Vec3(0,0,0))
self.an1.getPhysicsObject().setPosition(Point3(0,0,11.76))
self.an2.getPhysicsObject().setPosition(Point3(196,0,22.0))
self.playerModel.setH(90)
self.playerModel.detachNode()
self.playerModel.setPos(0,0,1.76)
self.anp.setFluidPos(Point3(0,0,1.76))
self.playerModel.reparentTo(self.anp)
self.playerModel2.setH(0)
self.playerModel2.detachNode()
self.playerModel2.setPos(196,0,22.0)
self.anp2.setFluidPos(Point3(196,0,22.0))
self.playerModel2.reparentTo(self.anp2)
def setupLighting(self):
ambientLight = AmbientLight('ambientLight')
ambientLight.setColor(Vec4(0.55,0.55,0.55,1.0))
ambientLightNP = render.attachNewNode(ambientLight)
render.setLight(ambientLightNP)
dirLight = DirectionalLight('dirLight')
dirLight.setColor(Vec4(0.6,0.6,0.6,1))
dirLightNP = render.attachNewNode(dirLight)
dirLightNP.setHpr(Vec3(0.0,-26.0,0.0))
render.setLight(dirLightNP)
def setupIntervals(self):
self.charWalk1l = self.playerModel.actorInterval("walk")
self.charWalk1l.loop( )
self.charWalk1l.pause( )
self.charWalk1r = self.playerModel.actorInterval("walk")
self.charWalk1r.loop( )
self.charWalk1r.pause( )
self.charWalk2l = self.playerModel2.actorInterval("walk2")
self.charWalk2l.loop( )
self.charWalk2l.pause( )
self.charWalk2r = self.playerModel2.actorInterval("walk2")
self.charWalk2r.loop( )
self.charWalk2r.pause( )
self.jump1 = self.playerModel.actorInterval("jump")
self.jump1.loop()
self.jump1.pause()
self.jump2 = self.playerModel2.actorInterval("jump2")
self.jump2.loop()
self.jump2.pause()
self.climb1 = self.playerModel.actorInterval("climb")
self.climb1.loop()
self.climb1.pause()
self.climb2 = self.playerModel2.actorInterval("climb2")
self.climb2.loop()
self.climb2.pause()
# end setupIntervals
# ############################
# Actual Working movement code
# ############################
def rise(self):
dist = 40
self.playerModel.setH(0)
playerJump = self.playerModel.posInterval(1.0,Vec3(self.playerModel.getX(), self.playerModel.getY(),self.playerModel.getZ()+dist))
playerJump.start()
def rise2(self):
dist = 40
self.playerModel2.setH(90)
playerJump2 = self.playerModel2.posInterval(1.0,Vec3(self.playerModel2.getX(), self.playerModel2.getY(),self.playerModel2.getZ()+dist))
playerJump2.start()
# PLAYER ONE #
def left(self):
taskMgr.add(self.leftTask,'leftTask')
self.charWalk1l.loop()
#end left
def leftTask(self,task):
if self.climbing1 == 0:
self.playerModel.setH(270)
self.playerModel.setPos(Vec3(self.playerModel.getX()-self.speed1, self.playerModel.getY(), self.playerModel.getZ()))
return Task.cont
def right(self):
taskMgr.add(self.rightTask,'rightTask')
self.charWalk1r.loop()
#end right
def rightTask(self,task):
if self.climbing1 == 0:
self.playerModel.setH(90)
self.playerModel.setPos(Vec3(self.playerModel.getX()+self.speed1, self.playerModel.getY(), self.playerModel.getZ()))
return Task.cont
def climbable(self,cEntry):
self.nodeCount1+=1
print self.nodeCount1
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.climb,[1])
self.accept("w-up",self.noClimb)
self.acceptOnce("s",self.climb,[-1])
self.accept("s-up",self.noClimb)
def climb(self,dir):
self.dir1 = dir
self.climbing1 = 1
self.climbSpeed1 = 1
self.ignore("a")
self.ignore("a-up")
self.ignore("d")
self.ignore("d-up")
taskMgr.add(self.climbTask,'climbTask')
self.climb1.loop()
def noClimb(self):
taskMgr.remove('climbTask')
self.climb1.pause()
if self.nodeCount1 == 0:
self.climbing = 0
self.climbSpeed1 = 0
self.acceptOnce("w",self.climb,[1])
self.acceptOnce("s",self.climb,[-1])
def jumpable(self,cEntry):
self.nodeCount1+=-1
print self.nodeCount1
if self.nodeCount1 == 0:
taskMgr.remove('climbTask')
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.jump)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.climbing1 = 0
self.climbSpeed1 = 0
self.climb1.pause()
def walkable(self,cEntry):
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.climb,[1])
self.accept("w-up",self.noClimb)
self.acceptOnce("s",self.climb,[-1])
self.accept("s-up",self.noClimb)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.climbing1 = 0
self.climbSpeed1 = 0
self.climb1.pause()
def climbTask(self,task):
if self.playerModel.getZ() >=0:
self.playerModel.setH(0)
self.playerModel.setPos(Vec3(self.playerModel.getX(), self.playerModel.getY(), self.playerModel.getZ()+self.climbSpeed1*self.dir1))
return Task.cont
def jump(self):
if self.nodeCount1 == 0:
self.ignore("w")
self.ignore("w-up")
z = self.playerModel.getZ()
j = ProjectileInterval(self.playerModel, startPos = self.playerModel.getPos(), startVel = Point3(5,0,30), duration = 2.0)
j.start()
taskMgr.doMethodLater(2,self.jumpTask,"jumpTask")
else:
self.acceptOnce("w",self.climb,[1])
def jumpTask(self, task):
if self.climbing1 == 0:
self.jump1.pause()
self.acceptOnce("w",self.jump)
#return task.cont
def allowRight(self):
self.acceptOnce("d",self.right)
def noRight(self):
taskMgr.remove('rightTask')
self.charWalk1r.pause()
self.acceptOnce("d",self.right)
def stopRight(self):
self.noRight()
#self.allowRight()
def rightWall(self,cEntry):
self.ignore("d")
self.noRight()
def rightEdge(self,cEntry):
self.ignore("d")
self.noRight()
def rightOK(self,cEntry):
self.allowRight()
def allowLeft(self):
self.acceptOnce("a",self.left)
def noLeft(self):
taskMgr.remove('leftTask')
self.charWalk1l.pause()
self.acceptOnce("a",self.left)
def stopLeft(self):
self.noLeft()
#self.allowLeft()
def leftWall(self,cEntry):
self.ignore("a")
self.noLeft()
def leftEdge(self,cEntry):
self.ignore("a")
self.noLeft()
def leftOK(self,cEntry):
self.allowLeft()
# PLAYERTWO #
def left2(self):
taskMgr.add(self.leftTask2,'leftTask2')
self.charWalk2l.loop()
#end left
def leftTask2(self,task):
if self.climbing2 == 0:
self.playerModel2.setH(0)
self.playerModel2.setPos(Vec3(self.playerModel2.getX()-self.speed2, self.playerModel2.getY(), self.playerModel2.getZ()))
return Task.cont
def right2(self):
taskMgr.add(self.rightTask2,'rightTask2')
self.charWalk2r.loop()
#end right
def rightTask2(self,task):
if self.climbing2 == 0:
self.playerModel2.setH(180)
self.playerModel2.setPos(Vec3(self.playerModel2.getX()+self.speed2, self.playerModel2.getY(), self.playerModel2.getZ()))
return Task.cont
def climbable2(self,cEntry):
self.nodeCount2+=1
#print self.nodeCount1
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.climbT2,[1])
self.accept("o-up",self.noClimb2)
self.acceptOnce("l",self.climbT2,[-1])
self.accept("l-up",self.noClimb2)
def climbT2(self,dir):
self.dir2 = dir
self.climbing2 = 1
self.climbSpeed2 = 1
self.ignore("k")
self.ignore("k-up")
self.ignore(";")
self.ignore(";-up")
taskMgr.add(self.climbTask2,'climbTask2')
self.climb2.loop()
def noClimb2(self):
taskMgr.remove('climbTask2')
self.climb2.pause()
if self.nodeCount2 == 0:
self.climbing2 = 0
self.climbSpeed2 = 0
self.acceptOnce("o",self.climbT2,[1])
self.acceptOnce("l",self.climbT2,[-1])
def jumpable2(self,cEntry):
self.nodeCount2+=-1
#print self.nodeCount2
if self.nodeCount2 == 0:
taskMgr.remove('climbTask2')
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.jumpT2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.climbing2 = 0
self.climbSpeed2 = 0
self.climb2.pause()
def walkable2(self,cEntry):
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.climbT2,[1])
self.accept("o-up",self.noClimb2)
self.acceptOnce("l",self.climbT2,[-1])
self.accept("l-up",self.noClimb2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft)
self.accept(";-up",self.stopRight)
self.climbing2 = 0
self.climbSpeed2 = 0
self.climb2.pause()
def climbTask2(self,task):
if self.playerModel2.getZ() >=0:
self.playerModel2.setH(90)
self.playerModel2.setPos(Vec3(self.playerModel2.getX(), self.playerModel2.getY(), self.playerModel2.getZ()+self.climbSpeed2*self.dir2))
return Task.cont
def jumpT2(self):
if self.nodeCount2 == 0:
self.ignore("o")
self.ignore("o-up")
z = self.playerModel2.getZ()
j = ProjectileInterval(self.playerModel2, startPos = self.playerModel2.getPos(), startVel = Point3(3,0,30), duration = 2.0)
j.start()
taskMgr.doMethodLater(3,self.jumpTask2,"jumpTask2")
else:
self.acceptOnce("w",self.climb,[1])
def jumpTask2(self, task):
if self.climbing2 == 0:
self.jump2.pause()
self.acceptOnce("o",self.jumpT2)
#return task.cont
def allowRight2(self):
self.acceptOnce(";",self.right2)
def noRight2(self):
taskMgr.remove('rightTask2')
self.charWalk2r.pause()
self.acceptOnce(";",self.right2)
def stopRight2(self):
self.noRight2()
#self.allowRight()
def rightWall2(self,cEntry):
self.ignore(";")
self.noRight2()
def rightEdge2(self,cEntry):
self.ignore(";")
self.noRight2()
def rightOK2(self,cEntry):
self.allowRight2()
def allowLeft2(self):
self.acceptOnce("k",self.left2)
def noLeft2(self):
taskMgr.remove('leftTask2')
self.charWalk2l.pause()
self.acceptOnce("k",self.left2)
def stopLeft2(self):
self.noLeft2()
#self.allowLeft()
def leftWall2(self,cEntry):
self.ignore("k")
self.noLeft2()
def leftEdge2(self,cEntry):
self.ignore("k")
self.noLeft2()
def leftOK2(self,cEntry):
self.allowLeft2()
def setupCollisions(self):
self.cHandler = PhysicsCollisionHandler()
#self.cHandler.setInPattern("ate-%in")
self.cHandler.addInPattern('%fn-into-%in')
#self.cHandler2.addInPattern('%fn-into-%in')
self.cHandler.setAgainPattern('%fn-again-%in')
self.cHandler.setOutPattern('%fn-outof-%in')
self.cTrav = CollisionTraverser()
#self.cTrav2 = CollisionTraverser()
base.cTrav = self.cTrav
#Player 1 collision solid
bounds = self.playerModel.getChild(0).getBounds()
center = bounds.getCenter()-Vec3(0,0,12)
radius = bounds.getRadius()-18
boundsB = self.playerModel.getChild(0).getBounds()
centerB = bounds.getCenter()-Vec3(0,0,-4)
radiusB = bounds.getRadius()-20
cSphere = CollisionSphere(center,radius)
cSphereB = CollisionSphere(centerB,radiusB)
cNode = CollisionNode("player1")
#print radius, radiusB
cNode.addSolid(cSphere)
cNode.addSolid(cSphereB)
cNodePath = self.playerModel.attachNewNode(cNode)
cNodePath.show()
Node=NodePath(PandaNode("PhysicsNode"))
Node.reparentTo(render)
self.an1=ActorNode("player1-physics")
self.anp=Node.attachNewNode(self.an1)
base.physicsMgr.attachPhysicalNode(self.an1)
self.playerModel.reparentTo(self.anp)
#self.anp.reparentTo(self.playerModel)
#Player 2 collision solid
bounds2 = self.playerModel2.getChild(0).getBounds()
center2 = bounds2.getCenter()-Vec3(0,0,-4)
radius2 = bounds2.getRadius()-20
cSphere2 = CollisionSphere(center2,radius2)
bounds2B = self.playerModel2.getChild(0).getBounds()
center2B = bounds2B.getCenter()-Vec3(0,0,12)
radius2B = bounds2B.getRadius()-18
cSphere2B = CollisionSphere(center2B,radius2B)
cNode2 = CollisionNode("player2")
#print radius2, radius2B
cNode2.addSolid(cSphere2)
cNode2.addSolid(cSphere2B)
cNodePath2 = self.playerModel2.attachNewNode(cNode2)
cNodePath2.show()
Node2=NodePath(PandaNode("PhysicsNode"))
Node2.reparentTo(render)
self.an2=ActorNode("player2-physics")
self.anp2=Node2.attachNewNode(self.an2)
base.physicsMgr.attachPhysicalNode(self.an2)
self.playerModel2.reparentTo(self.anp2)
#self.anp2.reparentTo(self.playerModel2)
gravityFN=ForceNode('world-forces')
gravityFNP=render.attachNewNode(gravityFN)
gravityForce=LinearVectorForce(0,0,-9.8) #gravity acceleration
gravityFN.addForce(gravityForce)
base.physicsMgr.addLinearForce(gravityForce)
self.an1.getPhysicsObject().setMass(15)
self.an2.getPhysicsObject().setMass(15)
gravityForce.setMassDependent(1)
self.cHandler.addCollider(cNodePath, self.anp)
self.cHandler.addCollider(cNodePath2, self.anp2)
self.cTrav.addCollider(cNodePath,self.cHandler)
self.cTrav.addCollider(cNodePath2,self.cHandler)
self.cTrav.addCollider(cNodePath,self.cHandler)
self.cTrav.addCollider(cNodePath2,self.cHandler)
#self.cTrav.addCollider(cNodePath,self.cHandler2)
#self.cTrav.addCollider(cNodePath2,self.cHandler2)
#self.cTrav2.addCollider(cNodePath,self.cHandler2)
#self.cTrav2.addCollider(cNodePath2,self.cHandler2)
#cHandler2 = CollisionHandlerEvent()
#cHandler2.addInPattern('%fn-into-%in')
#self.cTrav.addCollider(cNodePath1,cHandler2)
#self.cTrav.addCollider(cNodePath2,cHandler2)
for i in range(self.ballNum+1):
boundsB = self.ball[i].getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*0.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("ball")
cNodeB.addSolid(cSphereB)
cNodePathB = self.ball[i].attachNewNode(cNodeB)
#self.cTrav.addCollider(cNodePathB,self.cHandler)
#cNodePathB.show()
self.accept("player1-into-ball",self.acquire1)
#self.accept("ball-into-player1",self.acquire1)
self.accept("player2-into-ball",self.acquire2)
#self.accept("ball-into-player2",self.acquire2)
#self.accept( 'player1-into2-platform', self.wall1)
#self.accept( 'player2-into2-platform', self.wall2)
def wall1(self,cEntry):
self.an1.getPhysicsObject().setVelocity(Vec3(0,0,0))
def wall2(self,cEntry):
self.an2.getPhysicsObject().setVelocity(Vec3(0,0,0))
def player1Wins(self,cEntry):
if self.player2Invincible == 0:
self.player1Score+=10
self.reset()
def player2Wins(self,cEntry):
if self.player1Invincible == 0:
self.player2Score+=10
self.reset()
def acquire1(self,cEntry):
self.playerModel.setY(0)
if str(cEntry.getIntoNodePath().getParent()) == "render/sawball":
self.player1Weapon = "saw"
saw = loader.loadModel("models/gamedev/saw")
saw.setScale(2.5)
self.jNP.getChildren().detach()
saw.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/moltovball":
self.player1Weapon = "molotov"
molo = loader.loadModel("models/gamedev/moltov")
molo.setScale(2.5)
#self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP.getChildren().detach()
molo.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/grenadeball":
self.player1Weapon = "grenade"
gren = loader.loadModel("models/gamedev/grenade")
gren.setScale(2.5)
#self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP.getChildren().detach()
gren.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/pogo": #done
self.jNP.getChildren().detach()
self.player1Weapon = "jump"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/golden": #done
self.jNP.getChildren().detach()
self.player1Weapon = "speedUp"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/crystalball":
self.jNP.getChildren().detach()
self.player1Weapon = "icestage"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/fireball": #done
self.jNP.getChildren().detach()
self.player1Weapon = "meteo"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/blackball": #done
self.jNP.getChildren().detach()
self.player1Weapon = "blind"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/translucent":
self.jNP.getChildren().detach()
self.player1Weapon = "invis"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/superball": #done
self.jNP.getChildren().detach()
self.player1Weapon = "invincible"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/death": #done
self.jNP.getChildren().detach()
if self.player1Invincible == 0:
self.player2Deaths+= 1
self.reset()
cEntry.getIntoNodePath().getParent().removeNode()
#Drop a New Ball
self.ballNum+=1
z=random.randint(1,2)
if z ==1:
z=-1
else:
z=1
self.movement.append(Vec3(random.random()*z,0,random.random()*z))
weapBalls.define(self.ball,self.ballNum,render)
boundsB = self.ball[self.ballNum].getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("ball")
cNodeB.addSolid(cSphereB)
cNodePathB = self.ball[self.ballNum].attachNewNode(cNodeB)
def acquire2(self,cEntry):
if str(cEntry.getIntoNodePath().getParent()) == "render/sawball":
self.player2Weapon = "saw"
saw = loader.loadModel("models/gamedev/saw")
saw.setScale(2.5)
self.jNP2.getChildren().detach()
saw.reparentTo(self.jNP2)
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/moltovball":
self.player2Weapon = "molotov"
molo = loader.loadModel("models/gamedev/moltov")
molo.setScale(2.5)
#self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP.getChildren().detach()
molo.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/grenadeball":
self.player2Weapon = "grenade"
gren = loader.loadModel("models/gamedev/grenade")
gren.setScale(2.5)
#self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP.getChildren().detach()
gren.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/pogo": #done
self.jNP.getChildren().detach()
self.player2Weapon = "jump"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/golden": #done
self.jNP.getChildren().detach()
self.player2Weapon = "speedUp"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/crystalball":
self.jNP.getChildren().detach()
self.player2Weapon = "icestage"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/fireball": #done
self.jNP.getChildren().detach()
self.player2Weapon = "meteo"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/blackball": #done
self.jNP.getChildren().detach()
self.player2Weapon = "blind"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/translucent":
self.jNP.getChildren().detach()
self.player2Weapon = "invis"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/superball": #done
self.jNP.getChildren().detach()
self.player2Weapon = "invincible"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/death": #done
self.jNP.getChildren().detach()
if self.player2Invincible == 0:
self.player1Score+=3
self.reset()
cEntry.getIntoNodePath().getParent().removeNode()
#Drop a New Ball
self.ballNum+=1
z=random.randint(1,2)
if z ==1:
z=-1
else:
z=1
self.movement.append(Vec3(random.random()*z,0,random.random()*z))
weapBalls.define(self.ball,self.ballNum,render)
boundsB = self.ball[self.ballNum].getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("ball")
cNodeB.addSolid(cSphereB)
cNodePathB = self.ball[self.ballNum].attachNewNode(cNodeB)
def useWeapon1(self):
if self.player1Weapon == "meteo":
fireRain = Sequence(Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5),
Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain))
fireRain.start()
elif self.player1Weapon == "jump":
self.playerModel.detachNode()
self.playerModel.reparentTo(render)
angle = (self.playerModel.getH())*math.pi/180.0
ProjectileInterval(self.playerModel, startPos = Point3(self.playerModel.getPos()),startVel = Point3(math.sin(angle)*30,0,100), duration= 4.0).start()
elif self.player1Weapon == "speedUp":
self.speed1 = 6
taskMgr.doMethodLater(5,self.restoreSpeedBG,"restoreStuff")
elif self.player1Weapon == "blind":
camera.setPos(Vec3(-50,0,0))
taskMgr.doMethodLater(5,self.restoreCamera,"restoreCamera")
elif self.player1Weapon == "invincible":
self.player1Invincible = 1
taskMgr.doMethodLater(5,self.notInvince1,"mortal1")
elif self.player1Weapon == "grenade":
self.jNP.getChildren().detach()
gren = loader.loadModel("models/gamedev/grenade")
gren.setScale(2.5)
gren.reparentTo(render)
angle = (self.playerModel.getH())*math.pi/180.0
ProjectileInterval(gren, startPos = Point3(self.playerModel.getPos()),startVel = Point3(math.sin(angle)*30,0,10), endZ = -50).start()
if gren.getZ() == -50:
gren.removeNode()
cHandler = CollisionHandlerEvent()
cHandler.addInPattern('%fn-into-%in')
boundsB = gren.getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*0.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("grenade")
cNodeB.addSolid(cSphereB)
cNodePathB = gren.attachNewNode(cNodeB)
self.cTrav.addCollider(cNodePathB,cHandler)
self.acceptOnce("grenade-into-platform",self.explode)
elif self.player1Weapon == "molotov":
self.jNP.getChildren().detach()
elif self.player1Weapon == "saw":
self.jNP.getChildren().detach()
elif self.player1Weapon == "invis":
self.jNP.getChildren().detach()
self.playerModel2.hide()
taskMgr.doMethodLater(4.0,self.showPlayer,"showPlayer")
elif self.player1Weapon == "icestage":
self.jNP.getChildren().detach()
self.speed1 = 6
self.speed2 = 6
self.background.detachNode()
self.background2.reparentTo(render)
taskMgr.doMethodLater(5,self.restoreSpeedBG,"restoreStuff")
def restoreSpeedBG(self,task):
self.speed1 = 3
self.speed2 = 3
self.background2.detachNode()
self.background.reparentTo(render)
def showPlayer(self,task):
self.playerModel.show()
self.playerModel2.show()
def useWeapon2(self):
if self.player2Weapon == "meteo":
fireRain = Sequence(Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5),
Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain))
fireRain.start()
elif self.player2Weapon == "jump":
angle = self.playerModel2.getH()/90
ProjectileInterval(self.playerModel2, startPos = Point3(self.playerModel2.getPos()),startVel = Point3(angle*30,0,100), endZ = self.playerModel2.getZ()).start()
elif self.player2Weapon == "speedUp":
self.speed2 = 6
elif self.player2Weapon == "blind":
camera.setPos(Vec3(-50,0,0))
taskMgr.doMethodLater(5,self.restoreCamera,"restoreCamera")
elif self.player2Weapon == "invincible":
self.player2Invincible = 1
taskMgr.doMethodLater(5,self.notInvince2,"mortal2")
elif self.player2Weapon == "grenade":
self.jNP2.getChildren().detach()
gren = loader.loadModel("models/gamedev/grenade")
gren.setScale(2.5)
gren.reparentTo(render)
angle = (self.playerModel2.getH())*math.pi/180.0
ProjectileInterval(gren, startPos = Point3(self.playerModel2.getPos()),startVel = Point3(math.sin(angle)*30,0,10), endZ = -50).start()
if gren.getZ() == -50:
gren.removeNode()
cHandler = CollisionHandlerEvent()
cHandler.addInPattern('%fn-into-%in')
boundsB = gren.getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*0.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("grenade")
cNodeB.addSolid(cSphereB)
cNodePathB = gren.attachNewNode(cNodeB)
self.cTrav.addCollider(cNodePathB,cHandler)
self.acceptOnce("grenade-into-platform",self.explode)
elif self.player2Weapon == "molotov":
self.jNP.getChildren().detach()
elif self.player2Weapon == "saw":
self.jNP.getChildren().detach()
elif self.player2Weapon == "invis":
self.jNP.getChildren().detach()
self.playerModel1.hide()
taskMgr.doMethodLater(4.0,self.showPlayer,"showPlayer")
elif self.player2Weapon == "icestage":
self.jNP2.getChildren().detach()
self.speed1 = 6
self.speed2 = 6
self.background.detachNode()
self.background2.reparentTo(render)
taskMgr.doMethodLater(5,self.restoreSpeedBG,"restoreStuff")
def rain(self):
meteoBall = Actor("models/gamedev/fireball")
meteoBall.reparentTo(render)
meteoBall.setScale(2)
meteoBall.setH(-15)
boundsB = meteoBall.getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*0.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("meteor")
cNodeB.addSolid(cSphereB)
cNodePathB = meteoBall.attachNewNode(cNodeB)
#cNodePathB.show()
ProjectileInterval(meteoBall, startPos = Point3(random.randint(15,211),0,170),startVel = Point3(-12,0,0), endZ = -50).start()
cHandler = CollisionHandlerEvent()
cHandler.addInPattern('%fn-into-%in')
self.cTrav.addCollider(cNodePathB,cHandler)
self.accept("meteor-into-player1",self.player2Wins)
self.accept("meteor-into-player2",self.player1Wins)
def showBalls(self,task):
for i in self.ball:
i.show()
def notInvince1(self,task):
self.player1Invincible = 0
def notInvince2(self,task):
self.player2Invincible = 0
def restoreCamera(self,task):
camera.setPosHpr(Vec3(98,-390,90), Vec3(0,-5,0))
def switch(self,task):
self.environment.setColor(0,1,0.3)
def colliding1( self, collEntry ): # accept a collision entry argument
if self.ignoreColl == 0:
self.player1IsColliding = 1 # we are colliding
self.stopWalk( ) # pause all walking animation and movement
disp = ( collEntry.getSurfacePoint( render ) - collEntry.getInteriorPoint( render ) )
newPos = self.playerModel2.getPos( ) + disp # get new position
self.playerModel2.setPos( newPos ) # and set it to tiny's position
# end colliding
def notColliding1( self, collEntry ):
self.player1IsColliding = 0
def colliding2( self, collEntry ): # accept a collision entry argument
if self.ignoreColl == 0:
self.player2IsColliding = 1 # we are colliding
self.stopWalk2( ) # pause all walking animation and movement
disp = ( collEntry.getSurfacePoint( render ) - collEntry.getInteriorPoint( render ) )
newPos = self.playerModel2B.getPos( ) + disp # get new position
self.playerModel2B.setPos( newPos ) # and set it to tiny's position
# end colliding
def notColliding2( self, collEntry ):
self.player2IsColliding = 0
def returnSpeeds(self,task):
self.speed1 = 8.0
self.speed2 = 8.0
self.turnSpeed1 = 80.0
self.turnSpeed2 = 80.0
def returnSpeeds2(self,task):
self.acceptOnce("w",self.walk)
self.acceptOnce("o",self.walk2)
self.speed1 = 8.0
self.speed2 = 8.0
self.turnSpeed1 = 80.0
self.turnSpeed2 = 80.0
def returnSpeeds3(self,task):
self.speed1 = 8.0
self.speed2 = 8.0
self.turnSpeed1 = 80.0
self.turnSpeed2 = 80.0
def changeMusic(self,task):
self.music.stop()
self.music2 = loader.loadMusic("models/gamedev/ADRENALINE.mp3")
self.music2.play()
def clockTask(self,task):
self.timer.detachNode()
self.timer = OnscreenText("%d" % (self.gameLen-globalClock.getRealTime(),), pos = (98,145), scale = 18.0)
self.timer.setColor(1,1,1)
self.timer.reparentTo(render)
return Task.cont
def ballMovementTask(self,task):
self.anp.setY(0)
self.anp2.setY(0)
for i in range(self.ballNum+1):
if i < len(self.ball):
if self.ball[i].getX() > 234 or self.ball[i].getX() < -38 or self.ball[i].getZ() < -10 or self.ball[i].getZ() > 132:
self.ball[i].setPos(self.ball[i].getPos()/1.005)
z=random.randint(1,2)
if z ==1:
z=-1
else:
z=1
self.movement[i]=Vec3(random.random()*z,0,random.random()*z)
else:
self.ball[i].setPos(self.ball[i].getPos()+self.movement[i])
return Task.cont
def fire(self):
self.fire = ParticleEffect()
self.fire.reset()
self.fire.setPos(0.000, 0.000, 0.000)
self.fire.setHpr(0.000, 0.000, 0.000)
self.fire.setScale(10.000, 10.000, 10.000)
p0 = Particles('particles-1')
# Particles parameters
p0.setFactory("PointParticleFactory")
p0.setRenderer("SpriteParticleRenderer")
p0.setEmitter("DiscEmitter")
p0.setPoolSize(1024)
p0.setBirthRate(0.0200)
p0.setLitterSize(10)
p0.setLitterSpread(0)
p0.setSystemLifespan(1200.0000)
p0.setLocalVelocityFlag(1)
p0.setSystemGrowsOlderFlag(0)
# Factory parameters
p0.factory.setLifespanBase(2.0000)
p0.factory.setLifespanSpread(0.0000)
p0.factory.setMassBase(1.0000)
p0.factory.setMassSpread(0.0000)
p0.factory.setTerminalVelocityBase(400.0000)
p0.factory.setTerminalVelocitySpread(0.0000)
# Point factory parameters
# Renderer parameters
p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
p0.renderer.setUserAlpha(0.22)
# Sprite parameters
p0.renderer.addTextureFromFile('models/gamedev/sparkle.png')
p0.renderer.setColor(Vec4(1.00, 1.00, 1.00, 1.00))
p0.renderer.setXScaleFlag(1)
p0.renderer.setYScaleFlag(1)
p0.renderer.setAnimAngleFlag(0)
p0.renderer.setInitialXScale(0.5000)
p0.renderer.setFinalXScale(2.0000)
p0.renderer.setInitialYScale(1.0000)
p0.renderer.setFinalYScale(2.0000)
p0.renderer.setNonanimatedTheta(0.0000)
p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
p0.renderer.setAlphaDisable(0)
# Emitter parameters
p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
p0.emitter.setAmplitude(1.0000)
p0.emitter.setAmplitudeSpread(0.0000)
p0.emitter.setOffsetForce(Vec3(0.0000, 0.0000, 3.0000))
p0.emitter.setExplicitLaunchVector(Vec3(1.0000, 0.0000, 0.0000))
p0.emitter.setRadiateOrigin(Point3(0.0000, 0.0000, 0.0000))
# Disc parameters
p0.emitter.setRadius(0.5000)
self.fire.addParticles(p0)
self.fire.setPos(self.playerModel2.getPos())
t = Sequence(Func(self.fire.start, render, render),Wait(20),Func(self.cleanFire))
t.start()
def cleanFire(self):
self.fire.cleanup()
def explode(self,cEntry):
self.explosion = ParticleEffect()
self.explosion.reset()
self.explosion.setPos(cEntry.getIntoNodePath().getParent().getPos())
self.explosion.setHpr(0.000, 0.000, 0.000)
self.explosion.setScale(10.000, 10.000, 10.000)
p0 = Particles('particles-1')
# Particles parameters
p0.setFactory("PointParticleFactory")
p0.setRenderer("LineParticleRenderer")
p0.setEmitter("SphereVolumeEmitter")
p0.setPoolSize(10000)
p0.setBirthRate(0.0500)
p0.setLitterSize(10000)
p0.setLitterSpread(0)
p0.setSystemLifespan(2.0000)
p0.setLocalVelocityFlag(1)
p0.setSystemGrowsOlderFlag(1)
# Factory parameters
p0.factory.setLifespanBase(2.0000)
p0.factory.setLifespanSpread(0.0000)
p0.factory.setMassBase(.5000)
p0.factory.setMassSpread(0.0500)
p0.factory.setTerminalVelocityBase(400.0000)
p0.factory.setTerminalVelocitySpread(0.0000)
# Point factory parameters
# Renderer parameters
p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
p0.renderer.setUserAlpha(1.00)
# Line parameters
p0.renderer.setHeadColor(Vec4(1.00, 0.00, 0.00, 1.00))
p0.renderer.setTailColor(Vec4(1.00, 1.00, 0.00, 1.00))
p0.renderer.setLineScaleFactor(3.00)
# Emitter parameters
p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
p0.emitter.setAmplitude(10.0000)
p0.emitter.setAmplitudeSpread(0.0000)
p0.emitter.setOffsetForce(Vec3(0.0000, 0.0000, -0.4930))
p0.emitter.setExplicitLaunchVector(Vec3(1.0000, 0.0000, 0.0000))
p0.emitter.setRadiateOrigin(Point3(0.0000, 0.0000, 0.0000))
# Sphere Volume parameters
p0.emitter.setRadius(0.5000)
self.explosion.addParticles(p0)
f0 = ForceGroup('gravity')
# Force parameters
self.explosion.addForceGroup(f0)
cHandler = CollisionHandlerEvent()
cHandler.addInPattern('%fn-into-%in')
cSphereB = CollisionSphere(cEntry.getIntoNodePath().getParent().getPos(),1)
cNodeB = CollisionNode("explosion")
cNodeB.addSolid(cSphereB)
cNodePathB = self.explosion.attachNewNode(cNodeB)
self.cTrav.addCollider(cNodePathB,cHandler)
cNodePathB.show()
self.accept("player1-into-explosion",self.player2Wins)
self.accept("player2-into-explosion",self.player1Wins)
#f.reparentTo(self.playerModel)
#self.explosion.setPos(self.playerModel.getPos())
t = Sequence(Func(self.explosion.start, render, render),Wait(2),Func(self.cleanExplo))
t.start()
cEntry.getFromNodePath().getParent().removeNode()
def cleanExplo(self):
self.explosion.cleanup()
def endGame(self,task):
taskMgr.removeTasksMatching('returnSpeedsToNormal')
taskMgr.removeTasksMatching('restoreCamera')
taskMgr.removeTasksMatching('clockTask')
taskMgr.removeTasksMatching('ballMoveTask')
self.music.stop()
self.music3 = loader.loadMusic("models/gamedev/CSTAR.mp3")
self.music3.play()
self.speed1 = 0
self.speed2 = 0
def getScores(self):
return (self.player1Score, self.player2Score)
def getGameLen(self):
return self.gameLen
def stopMusic(self):
self.music3.stop()
def destroy(self):
self.playerModel.detachNode()
self.playerModel2.detachNode()
self.background.destroy()
self.lava.detachNode()
self.ladder.detachNode()
self.ladder2.detachNode()
for i in range(self.ballNum+1):
self.ball[i].detachNode()
def stopMusic(self):
self.music3.stop()
#world = Lvl03()
#world.start()
#run()
class DirectionExperiment(ViewTowers):
def __init__(self, *args, **kwargs):
ViewTowers.__init__(self, *args, **kwargs)
# ignore keys set by viewer
for key in self.getAllAccepting():
if key in ("s", "escape"):
continue
self.ignore(key)
self.permanent_events = self.getAllAccepting()
# global variables
self.text_bg = (1, 1, 1, 0.7)
self.font = self.loader.loadFont("cmr12.egg")
self.question = "Use the mouse to indicate the direction that " "the tower will fall."
self.feedback_time = 3.0
self.buffer_time = 0.75
# create text
self.create_all_text()
# create direction line
self.line = LineSegs()
self.line_node = None
self.angle = None
alight = AmbientLight("alight3")
alight.setColor((0.8, 0.8, 0.8, 1))
self.line_light = self.lights.attachNewNode(alight)
def place_camera(self):
self.cameras.setPos(0, -12, 2.5)
self.look_at.setPos(0, 0, 1.5)
self.cameras.lookAt(self.look_at)
def run(self):
# Show the start screen
self.toggle_task("show_start_screen")
# Call parent's run().
ShowBase.run(self)
def create_all_text(self):
self.continue_text = OnscreenText(
**{
"text": (
"In a moment, you will be asked the question displayed on "
"the left. When you are ready, press the spacebar to begin."
),
"style": 1,
"fg": (0.75, 0, 0, 1),
"bg": self.text_bg,
"pos": (0.4, 0.4),
"align": TextNode.ACenter,
"scale": 0.08,
"font": self.font,
"wordwrap": 20,
}
)
self.text_parent = self.continue_text.getParent()
self.continue_text.detachNode()
xpos = -1.25
self.question_text = OnscreenText(
**{
"text": self.question,
"style": 1,
"fg": (0, 0, 0.8, 1),
"bg": self.text_bg,
"pos": ((xpos + 0.05), 0.8),
"align": TextNode.ALeft,
"scale": 0.075,
"font": self.font,
"wordwrap": 35,
}
)
self.trials_remaining_text = OnscreenText(
**{
"text": "",
"style": 1,
"fg": (0, 0, 0, 1),
"bg": self.text_bg,
"pos": (-xpos, -0.95),
"align": TextNode.ARight,
"scale": 0.05,
"font": self.font,
}
)
def show_start_screen(self, task):
self.continue_text.reparentTo(self.text_parent)
self.accept("space", self.toggle_task, ["show_trial"])
def show_trial(self, task):
if self.line_node is not None:
self.line_node.removeNode()
self.line_node = None
if self.sso is None:
self.goto_sso(0)
elif self.ssos.index(self.sso) == (self.n_ssos - 1):
self.exit()
else:
self.next()
n = self.n_ssos - self.ssos.index(self.sso)
self.trials_remaining_text.setText("Trials remaining: %d" % n)
self.continue_text.detachNode()
self.camera_rot.setH(np.random.randint(0, 360))
self.cam_spin = 270
self.taskMgr.doMethodLater(self.buffer_time, self.rotate, "rotate")
def rotate(self, task):
""" Task: rotate camera."""
H = (self.camera_rot.getH() + 1) % 360
self.camera_rot.setH(H)
self.cam_spin -= 1
if self.cam_spin == 0:
self.toggle_task("show_question")
return task.done
else:
return task.cont
def show_question(self, task):
self.toggle_task("draw_direction")
self.accept("mouse1", self.record_response)
def record_response(self):
self.ignore("mouse1")
self.taskMgr.remove("draw_direction")
self.toggle_task("physics")
def physics(self, task):
""" Task: simulate physics."""
# Elapsed time.
dt = self._get_elapsed() - self.old_elapsed
# Update amount of time simulated so far.
self.old_elapsed += dt
# Step the physics dt time.
size_sub = self.bbase.sim_par["size_sub"]
n_subs = int(dt / size_sub)
self.bbase.step(dt, n_subs, size_sub)
if self.old_elapsed >= self.feedback_time:
self.toggle_task("show_trial")
return task.done
else:
return task.cont
def draw_direction(self, task):
if self.mouseWatcherNode.hasMouse():
cv = self._get_collision(self.floor)
cv = cv / np.linalg.norm(cv)
self.angle = np.arctan2(cv[1], cv[0])
sx, sy, sz = self.floor.getScale() / 2.0
gx, gy, gz = self.floor.getPos()
gz += sz + 0.01
if self.line_node is not None:
self.line_node.removeNode()
self.line_node = None
self.line.reset()
self.line.setColor(1, 1, 1, 1)
self.line.setThickness(5)
self.line.moveTo(gx, gy, gz)
self.line.drawTo(cv[0] * sx, cv[1] * sy, gz)
self.line_node = self.render.attachNewNode(self.line.create())
self.line_node.setLight(self.line_light)
return task.cont
def _get_collision(self, node, debug=False):
mx = self.mouseWatcherNode.getMouseX()
my = self.mouseWatcherNode.getMouseY()
if debug:
print "mouse:", (mx, my)
# get the origin and direction of the ray extending from the
# camera to the mouse pointer
cm = np.array(self.cam.getNetTransform().getMat())
cr = CollisionRay()
cr.setFromLens(self.cam.node(), (mx, my))
cp = np.hstack([cr.getOrigin(), 1])
cd = np.hstack([cr.getDirection(), 0])
cp = np.dot(cm.T, cp)[:3]
cd = np.dot(cm.T, cd)[:3]
if cd[2] > -1:
cd[2] = -1
if debug:
print "direction:", cd
print "origin:", cp
# point on the plane, z-axis
pz = node.getPos(self.render)[2]
sz = node.getScale(self.render)[2] / 2.0
p0 = np.array([0, 0, pz + sz])
if debug:
print "p0:", p0
# this is the intersection equation that we want to solve,
# where s is the point on the line that intersects
# e_z(cp + s*cd - p0) = 0
s = (p0[2] - cp[2]) / cd[2]
if debug:
print "s:", s
# transform the collision point from line coordinates to world
# coordinates
cv = cp + s * cd
if debug:
print "collision:", cv
return cv
class MyApp(ShowBase):
def cleanUpStartScreen( self ):
self.startButton.destroy( ) # get rid of the button
self.logoModel.detachNode( ) # detach the logo model from the render
self.loadGame( ) # load the actual game
# end cleanUpStartScreen
def addInstructions(pos, msg):
return OnscreenText(text=msg, style=1, fg=(1,1,1,1),pos=(-1.3, pos), align=TextNode.ALeft, scale = .05)
def __init__(self):
global x,y,z
#self.loadStartScreen()
ShowBase.__init__(self)
#self.setupBackgroundColor(1,1,1)
# set the camera position
#camera.setPosHpr( Vec3( 0, -10, 0 ), Vec3( 0, 0, 0 ) )
# load our logo model
self.logoModel = loader.loadModel("bvw-f2004--truck/cartruck.egg")
self.logoModel.reparentTo( render )
# set the logo model's position
self.logoModel.setPosHpr( Vec3( 0, 15, 0 ), Vec3( 0, 0, 0 ) )
# create and display a start button
self.startButton = DirectButton( text = "Go!", relief = DGG.RAISED, scale = .1, pad = ( .5, .5 ), pos = Vec3( 1.0, 0.0, -0.8 ), command = self.cleanUpStartScreen )
self.disableMouse()
self.obs = [None] * 100
self.keyMap = {"forward":0, "slow":0, "left":0, "right":0}
#self.environ = [None]*100
self.grb= [None] * 100
self.env= [None] * 20
self.env1= [None] * 20
self.envx= [None] * 20
self.envy= [None] * 20
self.title = OnscreenText(text="SCORE: " + str(score), style=1, fg=(1,1,0,1), pos=(-0.95,0.85), scale = .07, mayChange = True)
self.title1 = OnscreenText(text="LIVES: " + str(int (gameover/2)), style=1, fg=(1,1,0,1), pos=(-0.95,0.7), scale = .07, mayChange = True)
self.timeleft = OnscreenText(text="TIME LEFT: " + str(int(time/60)) + " : " + str(int(time%60)), style=1, fg=(1,1,0,1), pos=(-0.95,0.55), scale = .07, mayChange = True)
self.model= self.loader.loadModel("alice-farm--cornfield/cornfield.egg")
self.model.reparentTo(self.render)
self.model.setPos(-8, 42, 0)
self.model.setScale(20,1000,20)
# Reparent the model to render.
self.environ2 = self.loader.loadModel("bvw-f2004--building/building.egg")
self.environ2.reparentTo(self.render)
self.environ2.setPos(S1x, S1y, S1z)
self.environ2.setScale(0.2, 0.2, 0.2)
for i in range(0,100):
self.obs[i]= self.loader.loadModel("alice-objects--anvil/anvil.egg")
self.obs[i].reparentTo(self.render)
self.obs[i].setX(random.choice([0, 10]))
self.obs[i].setY(random.randint(100,100000))
self.obs[i].setZ(3)
self.obs[i].setScale(10,20,10)
for j in range(0,100):
self.grb[j]= self.loader.loadModel("alice-shapes--icosahedron/icosahedron.egg")
self.grb[j].reparentTo(self.render)
self.grb[j].setX(random.choice([0, 10]))
self.grb[j].setY(random.randint(100, 100000))
self.grb[j].setZ(3)
self.grb[j].setScale(0.8,3,0.8)
for k in range(0,20):
self.envx[k]= self.loader.loadModel("bvw-f2004--building/building.egg")
self.envx[k].reparentTo(self.render)
self.envx[k].setX(random.choice([-60, 60]))
self.envx[k].setY(random.randint(13000, 35000))
self.envx[k].setZ(0)
self.envx[k].setScale(0.8, 0.8, 0.8)
for k in range(0,20):
self.envy[k]= self.loader.loadModel("bvw-f2004--russianbuilding/tetris-building.egg")
self.envy[k].reparentTo(self.render)
self.envy[k].setX(random.choice([-100, 100]))
self.envy[k].setY(random.randint(38000, 60000))
self.envy[k].setZ(0)
self.envy[k].setScale(0.8, 0.8, 0.8)
self.environ4 = self.loader.loadModel("alice-city--townhouse1/townhouse1.egg")
self.environ4.reparentTo(self.render)
self.environ4.setPos(T1x, T1y, T1z)
self.environ4.setScale(0.6, 0.6, 0.6)
self.BS = self.loader.loadModel("alice-skies--bluesky/bluesky.egg")
self.BS.reparentTo(self.render)
self.BS.setScale(10,10,10)
self.BS.setPos(-180,0,0)
self.barn= self.loader.loadModel("alice-farm--farmhouse/farmhouse.egg")
self.barn.reparentTo(self.render)
self.barn.setScale(0.5, 0.5, 0.5)
self.barn.setPos(30,500,0)
self.barn1= self.loader.loadModel("alice-beach--beachhouse2/beachhouse2.egg")
self.barn1.reparentTo(self.render)
self.barn1.setScale(0.5, 0.5, 0.5)
self.barn1.setPos(40,200,0)
self.barn2= self.loader.loadModel("alice-beach--beachhouse2/beachhouse2.egg")
self.barn2.reparentTo(self.render)
self.barn2.setScale(0.5,0.5,0.5)
self.barn2.setPos(70,1700,0)
self.barn3= self.loader.loadModel("bvw-f2004--russianbuilding/tetris-building.egg")
self.barn3.reparentTo(self.render)
self.barn3.setScale(0.5,0.5,0.5)
self.barn3.setPos(-90,1500,0)
self.barn5= self.loader.loadModel("bvw-f2004--course1/course1.egg")
self.barn5.reparentTo(self.render)
self.barn5.setScale(0.25, 0.25, 0.25)
self.barn5.setPos(-100,900,0)
# Apply scale and position transforms on the model.
self.environ1= self.loader.loadModel("alice-vehicles--zamboni/zamboni.egg")
self.environ1.reparentTo(self.render)
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.environ1.setScale(0.3, 0.3, 0.3)
print E1posY
def loadGame(self):
self.camera.setPos(CposX, CposY, CposZ)
self.camera.setHpr(0,0,0)
#for j in range(0, 100):
#self.environ[j] = self.loader.loadModel("CityTerrain/CityTerrain")
#self.environ[j].reparentTo(self.render)
#self.environ[j].setPos(-8,42 + 210*j,0)
#self.environ[j].setScale(0.25,0.25,0.25)
self.accept("arrow_up-repeat", self.setKey, ["forward", 1])
self.accept("arrow_down-repeat", self.setKey, ["slow", 1])
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
base.cTrav = CollisionTraverser()
self.collHandEvent = CollisionHandlerEvent()
self.collCount=0
self.collHandEvent.addInPattern('into-%in')
self.collHandEvent.addOutPattern('outof-%in')
sColl = self.initCollisionSphere(self.environ1, True)
base.cTrav.addCollider(sColl[0], self.collHandEvent)
for child in render.getChildren():
if child != camera and child != self.environ2 and child!= self.environ4 and child != self.BS and child!= self.model and child!= self.barn and child!= self.barn1 and child!= self.barn2 and child!= self.barn3 and child!= self.barn5:
#print child
tColl = self.initCollisionSphere(child, True)
base.cTrav.addCollider(tColl[0], self.collHandEvent)
self.accept('into-' + tColl[1] , self.collide)
## for m in range(0,100):
## tgrb= self.initCollisionSphere(self.grb[i], True)
## base.cTrav.addCollider(tgrb[0], self.collHandEvent)
## self.accept('into-' + tgrb[1], self.collide)
##
## for n in range(0,100):
## tobs= self.initCollisionSphere(self.obs[i], True)
## base.cTrav.addCollider(tobs[0], self.collHandEvent)
## self.accept('into-' + tobs[1], self.collide)
self.taskMgr.add(self.move, "moveTask")
def initCollisionSphere(self, obj,show=False):
# Get the size of the object for the collision sphere.
bounds = obj.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius() *0.5
# Create a collison sphere
collSphereStr = 'CollisionHull' + str(self.collCount) + "_" + obj.getName()
self.collCount += 1
cNode = CollisionNode(collSphereStr)
cNode.addSolid(CollisionSphere(center, radius))
cNodepath = obj.attachNewNode(cNode)
#cNodepath.show()
# Return a tuple with the collision node and its corrsponding string so
# that the bitmask can be set.
return (cNodepath, collSphereStr)
def collide(self, collEntry):
global score,E1posY,gameover,adj, CposY
if self.environ1.getY()==-100:
return
if(collEntry.getIntoNodePath().getParent().getName()== "icosahedron.egg"):
#print collEntry.getIntoNodePath().getParent().getName()
collEntry.getIntoNodePath().getParent().remove()
score= score +10
print score
self.title.detachNode()
self.title = OnscreenText(text="SCORE: " + str(score), style=1, fg=(1,1,0,1), pos=(-0.95,0.85), scale = .07, mayChange = True)
elif(collEntry.getIntoNodePath().getParent().getName()== "anvil.egg"):
E1posY= E1posY-50
CposY= CposY-50
self.camera.setPos(CposX, CposY, CposZ)
self.environ1.setPos(E1posX, E1posY, E1posZ)
gameover= gameover - 1
self.title1.detachNode()
self.title1= OnscreenText(text="LIVES: " + str(int(gameover/2)), style=1, fg=(1,1,0,1), pos=(-0.95, 0.7), scale = .07, mayChange = True)
print gameover
if(gameover<=0):
print "Game Over"
## time2= int(time-(task.time*0.5))
## if time1!=time2:
## self.inst2.detachNode()
## self.inst2 = addInstructions(0.89, "Time: "+str(time2))
## time1=time2
## if time2==0:
OnscreenText(text= "GAME OVER", style=1, fg=(1,1,1,1),pos=(-0.9,0), align=TextNode.ALeft, scale = 0.35)
OnscreenText(text= "Your Final Score is " + str(score), style=1, fg=(1,1,0,1), pos=(-0.95, -0.05), align=TextNode.ALeft, scale=0.015)
#time.sleep(10)
#sys.exit
self.environ1.detachNode()
self.camera.detachNode()
def setKey(self, key, value):
self.keyMap[key]= value
def move(self, task):
global E1posX, E1posY, E1posY, CposX, CposY, CposZ, S1y, S2y, T1y, n, y,speed, time
self.over=0
ts= int(task.time)
time= 120 -ts
print time,ts
self.timeleft.detachNode()
self.timeleft= OnscreenText(text="TIME LEFT: " + str(int(time/60)) + " : " + str(int(time%60)), style=1, fg=(1,1,0,1), pos=(-0.95,0.55), scale = .07, mayChange = True)
if(time<=0):
time=0
OnscreenText(text= "GAME OVER", style=1, fg=(1,1,1,1),pos=(-0.9,0), align=TextNode.ALeft, scale = 0.35)
OnscreenText(text= "Your Final Score is " + str(score), style=1,fg=(1,1,0,1), pos=(-0.95, -0.05), align=TextNode.ALeft, scale=0.02)
#time.sleep(10)
#sys.exit
self.environ1.detachNode()
self.over=1
if(self.keyMap["forward"]==1):
self.keyMap["forward"]=0
speed= 10
if speed>=10:
speed= 20
elif speed>=20:
speed= 30
dist= speed
print dist
E1posY= E1posY + dist
CposY= CposY + dist
S1y= S1y + dist
S2y= S2y + dist
T1y= T1y + dist
y= y+ dist
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
if(E1posY==7500 * n or E1posY== 7500 *n +20):
n= n+1
self.environ4.setPos(T1x, T1y, T1z)
#self.environ3.setPos(S2x, S2y, S2z)
self.environ2.setPos(S1x, S1y, S1z)
self.model.setPos(x,y + 550,z)
print E1posX, E1posY, E1posZ, CposX, CposY, CposZ, x, y, z
elif(self.keyMap["slow"]==1):
global slowadj
self.keyMap["slow"]=0
if slowadj<100:
slowadj+= slowadj
speed= speed-10
if speed<0:
speed=0
elif slowadj<200:
slowadj+= slowadj
speed= speed-10
if speed<0:
speed=0
elif slowadj<300:
slowadj+= slowadj
speed= speed-10
if speed<0:
speed=0
elif slowadj>=300:
speed=0
print speed
E1posY= E1posY + speed
CposY= CposY + speed
S1y= S1y + speed
S2y= S2y + speed
T1y= T1y + speed
y= y + speed
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
if(E1posY>=7700 * n and E1posY<= 7700 *n + 30):
n= n+1
self.environ4.setPos(T1x, T1y, T1z)
self.environ3.setPos(S2x, S2y, S2z)
self.environ2.setPos(S1x, S1y, S1z)
self.model.setPos(x,y + 550,z)
print E1posX, E1posY, E1posZ, CposX, CposY, CposZ
elif(self.keyMap["left"]==1):
self.keyMap["left"]=0
if(E1posX!=0):
E1posX=0
CposX=0
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
elif(self.keyMap["right"]==1):
self.keyMap["right"]=0
if(E1posX!=10):
E1posX=10
CposX=10
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
elif(self.keyMap["forward"]==0):
if(self.over==1):
CposY= CposY
elif(self.over==0):
print E1posY, CposY, speed
E1posY= E1posY + speed
CposY= CposY + speed
S1y= S1y + speed
S2y= S2y + speed
T1y= T1y + speed
y= y + speed
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
if(E1posY>=7500 * n and E1posY<= 7500 *n + 30):
n= n+1
self.environ4.setPos(T1x, T1y, T1z)
#self.environ3.setPos(S2x, S2y, S2z)
self.environ2.setPos(S1x, S1y, S1z)
self.model.setPos(x,y + 550,z)
return Task.cont
class Lvl01(DirectObject):
#constructor
def start(self):
base.disableMouse() #turn off mouse camera control
#camera.setPosHpr(Vec3(93,-90,0), Vec3(0,0,0))
# Turn off the default camera and replace it with two new cameras, with
# side-by-side DisplayRegions.
base.camNode.setActive(0)
base.makeCamera(base.win, displayRegion = (0, 0.48, 0, 1))
base.makeCamera(base.win, displayRegion = (0.52, 1, 0, 1))
base.makeCamera(base.win, displayRegion = (0.48,0.52,0,1))
base.camList[3].setPos(Vec3(144,0,-1000))
self.gameLen = 100
self.numActuator = 10
self.music = loader.loadMusic("models/gamedev/AD.mp3")
self.music.play()
globalClock.reset()
self.timer = OnscreenText("%d" % (self.gameLen-globalClock.getRealTime(),), pos = (98,145), scale = 18.0)
self.timer.setColor(1,1,1)
taskMgr.add(self.clockTask,"clockTask")
self.actCount = 0
self.speed1 = 3
self.speed2 = 3
self.climbSpeed1 = 1
self.climbSpeed2 = 1
self.climbing1 = 0
self.climbing2 = 0
self.array = []
self.loadModels()
self.setupLighting()
self.setupStage()
self.setupCollisions()
self.setupIntervals()
self.player1Score = 0
self.player2Score = 0
self.dir1 = 1
self.dir2 = 1
self.nodeCount1 = 0
self.nodeCount2 = 0
taskMgr.add(self.cameraFollowTask,"cameraFollowTask")
taskMgr.add(self.boulderTask,"boulderTask")
taskMgr.doMethodLater(self.gameLen,self.endGame,'endGame')
#setup key controls
self.accept("escape",sys.exit)
#self.accept("w",self.rise)
#self.accept("o",self.rise2)
#Player 1 movement keys
#self.accept("s",self.fall)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.acceptOnce("w", self.jump)
self.acceptOnce("o", self.jumpT2)
#Player 2 movement keys
#self.accept("l",self.fall2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.jumpOK = 1
def loadModels(self):
print "start loadModels"
self.playerModel = Actor("models/gamedev/redguy-model",{"walk":"models/gamedev/redguyrun",
"jump":"models/gamedev/redguy-jump","climb":"models/gamedev/redguy-climb"})
self.playerModel.reparentTo(render)
self.playerModel.setScale(.7)
self.playerModel.setPosHpr(Vec3(46,0,0),Vec3(0,0,0))
self.playerModel.setH(90)
self.playerModel2 = Actor("models/gamedev/bluegirl-model",{"walk2":"models/gamedev/bluegirlrun",
"jump2":"models/gamedev/bluegirl-jump","climb2":"models/gamedev/bluegirl-climb"})
self.playerModel2.reparentTo(render)
self.playerModel2.setScale(.7)
self.playerModel2.setPosHpr(Vec3(333,0,0),Vec3(0,0,0))
self.playerModel2.setH(270)
self.divider = loader.loadModel("models/gamedev/divider")
self.divider.setPos(144,0,-1000)
self.divider.setScale(5.0)
self.divider.reparentTo(render)
self.boulder1 = loader.loadModel("models/gamedev/boulder")
self.boulder1.reparentTo(render)
self.boulder1.setScale(7)
self.boulder1.setPos(46,0,-50)
self.boulder2 = loader.loadModel("models/gamedev/boulder")
self.boulder2.reparentTo(render)
self.boulder2.setScale(7)
self.boulder2.setPos(333,0,-50)
#loader.loadModel("models/gamedev/actuatorOn")
bounds = self.boulder1.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()*.7
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("boulder")
cNode.addSolid(cSphere)
cNodePath = self.boulder1.attachNewNode(cNode)
#cNodePath.show()
cNodePath = self.boulder2.attachNewNode(cNode)
#cNodePath.show()
print "end loadModels"
def setupStage(self):
print "start setupStage"
self.background = OnscreenImage(image = 'models/gamedev/lvl1background.jpg', pos = (175,5,0),scale=500)
self.background.reparentTo(render)
x1= 4.9
x2 = -4.9
len = 9.8
h = 0
a = 0
p = 0
j=0
m=0
x1b=0
x2b=0
while self.actCount < self.numActuator:
if j > 0:
lOld = l
rOld = r
x1Old = x1
x2Old = x2
x1 = (x1Old+x2Old)/2 + 4.9
x2 = (x1Old+x2Old)/2 - 4.9
x1o=x1
x2o=x2
for count in range(1):
l = random.randint(0,(10-lOld)+((10+rOld)-(10-lOld))/2)
r = random.randint(0,20-((10-lOld)+((10+rOld)-(10-lOld))/2))
if r+2 <= 20-((10-lOld)+((10+rOld)-(10-lOld))/2):
r += 2
if l+2 < (10-lOld)+((10+rOld)-(10-lOld))/2:
l += 2
if l+r < 4:
count = 0
p = random.randint(0,1)
else:
l = 10
r = 10
c = 10
#while a == 0:
a = random.randint(-l,r)
if j > 0:
if j % 2 == 0:
self.ladder = loader.loadModel("models/gamedev/ladder")
self.ladder.reparentTo(render)
self.ladder.setScale(1.5)
self.ladder.setPos(x1+m,0,h-20)
self.ladder2 = loader.loadModel("models/gamedev/ladder")
self.ladder2.reparentTo(render)
self.ladder2.setScale(1.5)
self.ladder2.setPos(x1+286+m,0,h-20)
self.array.append(self.ladder)
self.array.append(self.ladder2)
else:
self.ladder = loader.loadModel("models/gamedev/ladder")
self.ladder.reparentTo(render)
self.ladder.setScale(1.5)
self.ladder.setPos(x2,0,h-20)
self.ladder2 = loader.loadModel("models/gamedev/ladder")
self.ladder2.reparentTo(render)
self.ladder2.setScale(1.5)
self.ladder2.setPos(x2+286,0,h-20)
self.array.append(self.ladder)
self.array.append(self.ladder2)
k=-10
while k <= 13:
cSphere = CollisionSphere(Point3(1.5,0,k),.5)
cNode = CollisionNode("ladder")
cNode.addSolid(cSphere)
cNodePath = self.ladder.attachNewNode(cNode)
cNodePath = self.ladder2.attachNewNode(cNode)
#cNodePath.show()
k+=1
self.array.append(self.ladder)
#cSphere = CollisionSphere(Point3(1.5,0,h-40),.5)
#cNodeB = CollisionNode("canWalk")
#cNodeB.addSolid(cSphere)
#cNodePath = self.ladder.attachNewNode(cNodeB)
#cNodePath = self.ladder2.attachNewNode(cNodeB)
for i in range(r):
'''Right half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(x1,0,h)
self.environment2 = loader.loadModel("models/gamedev/platform")
self.environment2.reparentTo(render)
self.environment2.setScale(5)
self.environment2.setPos(x1+286,0,h)
self.array.append(self.environment)
self.array.append(self.environment2)
#if i == 0 and j > 0:
# cSphere = CollisionSphere(Point3((m/9.8)*1.9,0,0),.5)
# cNode = CollisionNode("platform")
# cNode.addSolid(cSphere)
# cNodePath = self.environment.attachNewNode(cNode)
# cNodePath = self.environment2.attachNewNode(cNode)
# cNodePath.show()
if r == i+1:
cSphere = CollisionSphere(Point3(2,0,0),2)
if i == 9:
cNode = CollisionNode("rwall")
else:
cNode = CollisionNode("redge")
cNode.addSolid(cSphere)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath = self.environment2.attachNewNode(cNode)
#cNodePath.show()
if a == i:
self.actCount+=1
self.actuator = Actor("models/gamedev/actuator")
self.actuator.reparentTo(render)
self.actuator.setPos(self.environment.getPos())
if p == 1:
self.actuator.setZ(self.actuator.getZ())
self.actuator.setP(self.actuator.getP()+180)
self.actuator.setScale(2)
self.actuator.setH(self.actuator.getH()+180)
self.array.append(self.actuator)
bounds = self.actuator.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()-.5
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("actuator")
cNode.addSolid(cSphere)
cNodePath = self.actuator.attachNewNode(cNode)
#cNodePath.show()
self.actuator2 = Actor("models/gamedev/actuator")
self.actuator2.reparentTo(render)
self.actuator2.setPos(self.environment2.getPos())
if p == 1:
self.actuator2.setZ(self.actuator2.getZ())
self.actuator2.setP(self.actuator2.getP()+180)
self.actuator2.setScale(2)
self.actuator2.setH(self.actuator2.getH()+180)
self.array.append(self.actuator2)
bounds = self.actuator2.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()-.5
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("actuator")
cNode.addSolid(cSphere)
cNodePath = self.actuator2.attachNewNode(cNode)
#cNodePath.show()
x1 = x1 + len
for i in range(l):
'''Left Half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(x2,0,h)
self.array.append(self.environment)
self.environment2 = loader.loadModel("models/gamedev/platform")
self.environment2.reparentTo(render)
self.environment2.setScale(5)
self.environment2.setPos(x2+286,0,h)
self.array.append(self.environment2)
if l == i+1:
cSphere = CollisionSphere(Point3(-2,0,0),2)
if i == 9:
cNode = CollisionNode("lwall")
else:
cNode = CollisionNode("ledge")
cNode.addSolid(cSphere)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath = self.environment2.attachNewNode(cNode)
#cNodePath.show()
if a == -i:
self.actCount+=1
self.actuator = Actor("models/gamedev/actuator")
self.actuator.reparentTo(render)
self.actuator.setPos(self.environment.getPos())
self.actuator.setScale(2)
self.array.append(self.actuator)
bounds = self.actuator.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()-.5
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("actuator")
cNode.addSolid(cSphere)
cNodePath = self.actuator.attachNewNode(cNode)
#cNodePath.show()
self.actuator = Actor("models/gamedev/actuator")
self.actuator.reparentTo(render)
self.actuator.setPos(self.environment2.getPos())
self.actuator.setScale(2)
self.array.append(self.actuator)
bounds = self.actuator.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()-.5
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("actuator")
cNode.addSolid(cSphere)
cNodePath = self.actuator.attachNewNode(cNode)
#cNodePath.show()
x2 = x2 - len
j+=1
h = h+40
#x1 = 4.9
#x2 = -4.9
a = 0
self.h = h+50
x2b=x2o
x1b=x1o
print "end setupStage"
def setupLighting(self):
print "start setupLighting"
ambientLight = AmbientLight('ambientLight')
ambientLight.setColor(Vec4(0.55,0.55,0.55,1.0))
ambientLightNP = render.attachNewNode(ambientLight)
render.setLight(ambientLightNP)
dirLight = DirectionalLight('dirLight')
dirLight.setColor(Vec4(0.6,0.6,0.6,1))
dirLightNP = render.attachNewNode(dirLight)
dirLightNP.setHpr(Vec3(0.0,-26.0,0.0))
render.setLight(dirLightNP)
print "end setupLighting"
def setupIntervals(self):
print "start setupIntervals"
self.charWalk1 = self.playerModel.actorInterval("walk")
self.charWalk1.loop( )
self.charWalk1.pause( )
self.charWalk2 = self.playerModel2.actorInterval("walk2")
self.charWalk2.loop( )
self.charWalk2.pause( )
self.jump1 = self.playerModel.actorInterval("jump")
self.jump1.loop()
self.jump1.pause()
self.jump2 = self.playerModel2.actorInterval("jump2")
self.jump2.loop()
self.jump2.pause()
self.climb1 = self.playerModel.actorInterval("climb")
self.climb1.loop()
self.climb1.pause()
self.climb2 = self.playerModel2.actorInterval("climb2")
self.climb2.loop()
self.climb2.pause()
print "end setupIntervals"
# PLAYER ONE #
def left(self):
taskMgr.add(self.leftTask,'leftTask')
self.charWalk1.loop()
#end left
def leftTask(self,task):
if self.climbing1 == 0:
self.playerModel.setH(270)
self.playerModel.setPos(Vec3(self.playerModel.getX()-self.speed1, self.playerModel.getY(), self.playerModel.getZ()))
return Task.cont
def right(self):
taskMgr.add(self.rightTask,'rightTask')
self.charWalk1.loop()
#end right
def rightTask(self,task):
if self.climbing1 == 0:
self.playerModel.setH(90)
self.playerModel.setPos(Vec3(self.playerModel.getX()+self.speed1, self.playerModel.getY(), self.playerModel.getZ()))
return Task.cont
def climbable(self,cEntry):
self.nodeCount1+=1
print self.nodeCount1
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.climb,[1])
self.accept("w-up",self.noClimb)
self.acceptOnce("s",self.climb,[-1])
self.accept("s-up",self.noClimb)
def climb(self,dir):
self.dir1 = dir
self.climbing1 = 1
self.climbSpeed1 = 1
self.ignore("a")
self.ignore("a-up")
self.ignore("d")
self.ignore("d-up")
taskMgr.add(self.climbTask,'climbTask')
self.climb1.loop()
def noClimb(self):
taskMgr.remove('climbTask')
self.climb1.pause()
if self.nodeCount1 == 0:
self.climbing = 0
self.climbSpeed1 = 0
self.acceptOnce("w",self.climb,[1])
self.acceptOnce("s",self.climb,[-1])
def jumpable(self,cEntry):
self.nodeCount1+=-1
print self.nodeCount1
if self.nodeCount1 == 0:
taskMgr.remove('climbTask')
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.jump)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.climbing1 = 0
self.climbSpeed1 = 0
self.climb1.pause()
def walkable(self,cEntry):
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.climb,[1])
self.accept("w-up",self.noClimb)
self.acceptOnce("s",self.climb,[-1])
self.accept("s-up",self.noClimb)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.climbing1 = 0
self.climbSpeed1 = 0
self.climb1.pause()
def climbTask(self,task):
if self.playerModel.getZ() >=0:
self.playerModel.setH(0)
self.playerModel.setPos(Vec3(self.playerModel.getX(), self.playerModel.getY(), self.playerModel.getZ()+self.climbSpeed1*self.dir1))
return Task.cont
def jump(self):
if self.nodeCount1 == 0:
self.ignore("w")
self.ignore("w-up")
z = self.playerModel.getZ()
j = ProjectileInterval(self.playerModel, startPos = self.playerModel.getPos(), startVel = Point3(0,0,27), endZ = z)
j.start()
taskMgr.doMethodLater(3,self.jumpTask,"jumpTask")
else:
self.acceptOnce("w",self.climb,[1])
def jumpTask(self, task):
if self.climbing1 == 0:
self.jump1.pause()
self.acceptOnce("w",self.jump)
#return task.cont
def allowRight(self):
self.acceptOnce("d",self.right)
def noRight(self):
taskMgr.remove('rightTask')
self.charWalk1.pause()
self.acceptOnce("d",self.right)
def stopRight(self):
self.noRight()
#self.allowRight()
def rightWall(self,cEntry):
self.ignore("d")
self.noRight()
def rightEdge(self,cEntry):
self.ignore("d")
self.noRight()
def rightOK(self,cEntry):
self.allowRight()
def allowLeft(self):
self.acceptOnce("a",self.left)
def noLeft(self):
taskMgr.remove('leftTask')
self.charWalk1.pause()
self.acceptOnce("a",self.left)
def stopLeft(self):
self.noLeft()
#self.allowLeft()
def leftWall(self,cEntry):
self.ignore("a")
self.noLeft()
def leftEdge(self,cEntry):
self.ignore("a")
self.noLeft()
def leftOK(self,cEntry):
self.allowLeft()
# PLAYERTWO #
def left2(self):
taskMgr.add(self.leftTask2,'leftTask2')
self.charWalk2.loop()
#end left
def leftTask2(self,task):
if self.climbing2 == 0:
self.playerModel2.setH(0)
self.playerModel2.setPos(Vec3(self.playerModel2.getX()-self.speed2, self.playerModel2.getY(), self.playerModel2.getZ()))
return Task.cont
def right2(self):
taskMgr.add(self.rightTask2,'rightTask2')
self.charWalk2.loop()
#end right
def rightTask2(self,task):
if self.climbing2 == 0:
self.playerModel2.setH(180)
self.playerModel2.setPos(Vec3(self.playerModel2.getX()+self.speed2, self.playerModel2.getY(), self.playerModel2.getZ()))
return Task.cont
def climbable2(self,cEntry):
self.nodeCount2+=1
#print self.nodeCount1
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.climbT2,[1])
self.accept("o-up",self.noClimb2)
self.acceptOnce("l",self.climbT2,[-1])
self.accept("l-up",self.noClimb2)
def climbT2(self,dir):
self.dir2 = dir
self.climbing2 = 1
self.climbSpeed2 = 1
self.ignore("k")
self.ignore("k-up")
self.ignore(";")
self.ignore(";-up")
taskMgr.add(self.climbTask2,'climbTask2')
self.climb2.loop()
def noClimb2(self):
taskMgr.remove('climbTask2')
self.climb2.pause()
if self.nodeCount2 == 0:
self.climbing2 = 0
self.climbSpeed2 = 0
self.acceptOnce("o",self.climbT2,[1])
self.acceptOnce("l",self.climbT2,[-1])
def jumpable2(self,cEntry):
self.nodeCount2+=-1
#print self.nodeCount2
if self.nodeCount2 == 0:
taskMgr.remove('climbTask2')
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.jumpT2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.climbing2 = 0
self.climbSpeed2 = 0
self.climb2.pause()
def walkable2(self,cEntry):
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.climbT2,[1])
self.accept("o-up",self.noClimb2)
self.acceptOnce("l",self.climbT2,[-1])
self.accept("l-up",self.noClimb2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft)
self.accept(";-up",self.stopRight)
self.climbing2 = 0
self.climbSpeed2 = 0
self.climb2.pause()
def climbTask2(self,task):
if self.playerModel2.getZ() >=0:
self.playerModel2.setH(90)
self.playerModel2.setPos(Vec3(self.playerModel2.getX(), self.playerModel2.getY(), self.playerModel2.getZ()+self.climbSpeed2*self.dir2))
return Task.cont
def jumpT2(self):
if self.nodeCount2 == 0:
self.ignore("o")
self.ignore("o-up")
z = self.playerModel2.getZ()
j = ProjectileInterval(self.playerModel2, startPos = self.playerModel2.getPos(), startVel = Point3(0,0,27), endZ = z)
j.start()
taskMgr.doMethodLater(3,self.jumpTask2,"jumpTask2")
else:
self.acceptOnce("w",self.climb,[1])
def jumpTask2(self, task):
if self.climbing2 == 0:
self.jump2.pause()
self.acceptOnce("o",self.jumpT2)
#return task.cont
def allowRight2(self):
self.acceptOnce(";",self.right2)
def noRight2(self):
taskMgr.remove('rightTask2')
self.charWalk2.pause()
self.acceptOnce(";",self.right2)
def stopRight2(self):
self.noRight2()
#self.allowRight()
def rightWall2(self,cEntry):
self.ignore(";")
self.noRight2()
def rightEdge2(self,cEntry):
self.ignore(";")
self.noRight2()
def rightOK2(self,cEntry):
self.allowRight2()
def allowLeft2(self):
self.acceptOnce("k",self.left2)
def noLeft2(self):
taskMgr.remove('leftTask2')
self.charWalk2.pause()
self.acceptOnce("k",self.left2)
def stopLeft2(self):
self.noLeft2()
#self.allowLeft()
def leftWall2(self,cEntry):
self.ignore("k")
self.noLeft2()
def leftEdge2(self,cEntry):
self.ignore("k")
self.noLeft2()
def leftOK2(self,cEntry):
self.allowLeft2()
def cameraFollowTask(self,task):
base.camList[1].setPos(Vec3(self.playerModel.getX(),-200,self.playerModel.getZ()+30))
base.camList[2].setPos(Vec3(self.playerModel2.getX(),-200,self.playerModel2.getZ()+30))
return task.cont
def activate(self,cEntry):
i = cEntry.getIntoNodePath().getParent()
where = i.getPos()
which = i.getHpr()
i.detachNode()
i = Actor("models/gamedev/actuatorOn")
i.setName("actuatorOn")
i.setPosHpr(where,which)
i.setScale(2)
i.reparentTo(render)
self.array.append(i)
if i.getX() < 144:
self.player1Score += 3
else:
self.player2Score += 3
def stun(self,cEntry):
ow = Sequence(Func(self.startStun), Wait(3), Func(self.stopStun))
ow.start()
def startStun(self):
self.speed1 = 0
self.climbspeed1 = 0
self.ignore("w")
self.ignore("w-up")
self.ignore("a")
self.ignore("d")
self.ignore("a-up")
self.ignore("d-up")
taskMgr.remove('leftTask')
taskMgr.remove('rightTask')
taskMgr.remove('climbTask')
taskMgr.remove('jumpTask')
self.playerModel.stop()
#self.ignore("player1-ladder")
def stopStun(self):
self.speed1 = 3
self.climbspeed1 = 1
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.acceptOnce("w",self.jump)
#self.accept("player1-ladder", self.climbable)
def stun2(self,cEntry):
ow = Sequence(Func(self.startStun2), Wait(3), Func(self.stopStun2))
ow.start()
def startStun2(self):
self.speed2 = 0
self.climbspeed2 = 0
self.ignore("k")
self.ignore(";")
self.ignore("k-up")
self.ignore(";-up")
self.ignore("o")
self.ignore("o-up")
taskMgr.remove('leftTask2')
taskMgr.remove('rightTask2')
taskMgr.remove('climbTask2')
taskMgr.remove('jumpTask2')
self.playerModel2.stop()
#self.ignore("player2-ladder")
def stopStun2(self):
self.speed2 = 3
self.climbspeed2 = 1
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.acceptOnce("o",self.jumpT2)
#self.accept("player2-ladder", self.climbable2)
def setupCollisions(self):
print "start setupCollisions"
self.cHandler = CollisionHandlerEvent()
self.cHandler = CollisionHandlerEvent()
self.cHandler.setInPattern("%fn-%in")
self.cHandler.setAgainPattern("%fn-is-on-%in")
self.cHandler.setOutPattern("%fn-left-%in")
self.cTrav = CollisionTraverser()
base.cTrav = self.cTrav
#Player 1 collision solid
bounds = self.playerModel.getChild(0).getBounds()
center = bounds.getCenter()-Vec3(0,0,12.5)
radius = bounds.getRadius()-21
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("player1")
cNode.addSolid(cSphere)
centerB = bounds.getCenter()-Vec3(0,0,-11)
radiusB = bounds.getRadius()-21
cSphereB = CollisionSphere(centerB,radiusB)
cNode.addSolid(cSphereB)
cNodePath = self.playerModel.attachNewNode(cNode)
#cNodePath.show()
#centerBB = bounds.getCenter()-Vec3(0,0,25)
#radiusBB = bounds.getRadius()-28
#cSphereBB = CollisionSphere(centerB,radiusB)
#cNodeT = CollisionNode("player1B")
#cNodeT.addSolid(cSphereBB)
#cNodePath = self.playerModel.attachNewNode(cNodeT)
#cNodePath.show()
#Player 2 collision solid
bounds2 = self.playerModel2.getChild(0).getBounds()
center2 = bounds2.getCenter()-Vec3(0,0,12.5)
radius2 = bounds2.getRadius()-21
cSphere2 = CollisionSphere(center2,radius2)
cNode2 = CollisionNode("player2")
cNode2.addSolid(cSphere2)
bounds2B = self.playerModel2.getChild(0).getBounds()
center2B = bounds2B.getCenter()-Vec3(0,0,-11)
radius2B = bounds2B.getRadius()-21
cSphere2B = CollisionSphere(center2B,radius2B)
cNode2.addSolid(cSphere2B)
cNodePath2 = self.playerModel2.attachNewNode(cNode2)
#cNodePath2.show()
self.cTrav.addCollider(cNodePath,self.cHandler)
self.cTrav.addCollider(cNodePath2,self.cHandler)
self.cTrav.addCollider(cNodePath,self.cHandler)
self.cTrav.addCollider(cNodePath2,self.cHandler)
self.accept("player1-ladder", self.climbable)
self.accept("player1-left-ladder", self.jumpable)
#self.accept("player1b-canWalk", self.walkable)
self.accept("player2-ladder", self.climbable2)
self.accept("player2-left-ladder", self.jumpable2)
#self.accept("player1-platform", self.climbable)
#self.accept("player1-left-platform",self.
#self.accept("player1-left-ladder-down", self.noDrop)
#self.accept("player2-ladder-down", self.drop2)
#self.accept("player2-left-ladder-down", self.noDrop2)
self.accept("player1-actuator", self.activate)
self.accept("player2-actuator", self.activate)
self.accept("player1-boulder", self.stun)
self.accept("player2-boulder", self.stun2)
self.accept("boulder-player1", self.stun)
self.accept("boulder-player2", self.stun2)
self.accept("player1-is-on-ledge", self.leftEdge)
self.accept("player2-is-on-ledge", self.leftEdge2)
self.accept("player1-is-on-redge", self.rightEdge)
self.accept("player2-is-on-redge", self.rightEdge2)
self.accept("player1-is-on-lwall", self.leftWall)
self.accept("player2-is-on-lwall", self.leftWall2)
self.accept("player1-is-on-rwall", self.rightWall)
self.accept("player2-is-on-rwall", self.rightWall2)
self.accept("player1-left-ledge", self.leftOK)
self.accept("player2-left-ledge", self.leftOK2)
self.accept("player1-left-redge", self.rightOK)
self.accept("player2-left-redge", self.rightOK2)
self.accept("player1-left-lwall", self.leftOK)
self.accept("player2-left-lwall", self.leftOK2)
self.accept("player1-left-rwall", self.rightOK)
self.accept("player2-left-rwall", self.rightOK2)
print "end setupCollisions"
def boulderTask(self,task):
drop1 = ProjectileInterval(self.boulder1, startPos = Point3(46+random.randint(-9,9)*9.8,0,self.h), startVel = Point3(0,0,0), endZ = -50)
drop2 = ProjectileInterval(self.boulder2, startPos = Point3(253+random.randint(-9,9)*9.8,0,self.h),startVel = Point3(0,0,0), endZ = -50)
dropBoth = Parallel(drop1,drop2)
if self.boulder1.getZ() <= -50.0:
drop1.start()
if self.boulder2.getZ() <= -50.0:
drop2.start()
return task.cont
def clockTask(self,task):
self.timer.detachNode()
self.timer = OnscreenText("%d" % (self.gameLen-globalClock.getRealTime(),), pos = (98,145), scale = 18.0)
self.timer.setColor(1,1,1)
self.timer.reparentTo(render)
return Task.cont
def endGame(self,task):
taskMgr.removeTasksMatching('cameraFollowTask')
taskMgr.removeTasksMatching('boulderTask')
taskMgr.removeTasksMatching('clockTask')
#base.camList[3].removeNode()
#base.camList[2].removeNode()
#base.camList[1].removeNode()
base.makeCamera(base.win, displayRegion = (0, 1, 0, 1))
self.music.stop()
#self.destroy()
self.music3 = loader.loadMusic("models/gamedev/CSTAR.mp3")
self.music3.play()
def getScores(self):
return (self.player1Score, self.player2Score)
def getGameLen(self):
return self.gameLen
def stopMusic(self):
self.music3.stop()
def destroy(self):
self.playerModel.detachNode()
self.playerModel2.detachNode()
self.divider.detachNode()
self.background.destroy()
self.timer.destroy()
while len(self.array) > 0:
print len(self.array)
self.array[0].remove()
del self.array[0]
#world = World()
#run()
class StabilityExperiment(ViewTowers):
def __init__(self, *args, **kwargs):
ViewTowers.__init__(self, *args, **kwargs)
# ignore keys set by viewer
for key in self.getAllAccepting():
if key in ("s", "escape"):
continue
self.ignore(key)
self.permanent_events = self.getAllAccepting()
# global variables
self.text_bg = (1, 1, 1, 0.7)
self.font = self.loader.loadFont('cmr12.egg')
self.question = [
"Will this tower fall?",
[[1, "definitely will not fall"], [2, "probably will not fall"],
[3, "might not fall"], [4, "don't know"], [5, "might fall"],
[6, "probably will fall"], [7, "definitely will fall"]]
]
self.question_keys = ["1", "2", "3", "4", "5", "6", "7"]
self.choice_text_start = 0.65
self.feedback_time = 3.0
self.buffer_time = 0.75
# create text
self.create_all_text()
def run(self):
# Show the start screen
self.toggle_task("show_start_screen")
# Call parent's run().
ShowBase.run(self)
def create_all_text(self):
self.continue_text = OnscreenText(
**{
"text":
("In a moment, you will be asked the question displayed on "
"the left. When you are ready, press the spacebar to begin."
),
"style":
1,
"fg": (.75, 0, 0, 1),
"bg":
self.text_bg,
"pos": (.4, .4),
"align":
TextNode.ACenter,
"scale":
.08,
"font":
self.font,
"wordwrap":
20
})
self.text_parent = self.continue_text.getParent()
self.continue_text.detachNode()
xpos = -1.25
skip = .15
self.question_text = OnscreenText(
**{
"text": self.question[0],
"style": 1,
"fg": (0, 0, .8, 1),
"bg": self.text_bg,
"pos": ((xpos + .05), .8),
"align": TextNode.ALeft,
"scale": .075,
"font": self.font,
"wordwrap": 35
})
self.question_choice_text = []
for i in xrange(len(self.question[1])):
n = len(self.question[1]) - i - 1
ypos = self.choice_text_start - (skip * n)
t1 = OnscreenText(
**{
"text": "%s" % self.question[1][i][0],
"style": 1,
"fg": (0, .1, 0, 1),
"bg": self.text_bg,
"pos": ((xpos + .1), ypos),
"align": TextNode.ALeft,
"scale": .075,
"font": self.font
})
t2 = OnscreenText(
**{
"text": "%s" % self.question[1][i][1],
"style": 1,
"fg": (0, .1, 0, 1),
"bg": self.text_bg,
"pos": ((xpos + 0.17), ypos),
"align": TextNode.ALeft,
"scale": .05,
"font": self.font
})
t = NodePath("choice_%s" % i)
t.reparentTo(self.text_parent)
t1.reparentTo(t)
t2.reparentTo(t)
self.question_choice_text.append(t)
for t in self.question_choice_text:
t.detachNode()
self.trials_remaining_text = OnscreenText(
**{
"text": "",
"style": 1,
"fg": (0, 0, 0, 1),
"bg": self.text_bg,
"pos": (-xpos, -.95),
"align": TextNode.ARight,
"scale": .05,
"font": self.font
})
def show_start_screen(self, task):
self.continue_text.reparentTo(self.text_parent)
for t in self.question_choice_text:
t.reparentTo(self.text_parent)
self.accept("space", self.toggle_task, ["show_trial"])
def show_trial(self, task):
if self.sso is None:
self.goto_sso(0)
elif self.ssos.index(self.sso) == (self.n_ssos - 1):
self.exit()
else:
self.next()
n = self.n_ssos - self.ssos.index(self.sso)
self.trials_remaining_text.setText("Trials remaining: %d" % n)
self.continue_text.detachNode()
for t in self.question_choice_text:
t.detachNode()
self.camera_rot.setH(np.random.randint(0, 360))
self.cam_spin = 270
self.taskMgr.doMethodLater(self.buffer_time, self.rotate, "rotate")
def rotate(self, task):
""" Task: rotate camera."""
H = (self.camera_rot.getH() + 1) % 360
self.camera_rot.setH(H)
self.cam_spin -= 1
if self.cam_spin == 0:
self.toggle_task("show_question")
return task.done
else:
return task.cont
def show_question(self, task):
for t in self.question_choice_text:
t.reparentTo(self.text_parent)
for key in self.question_keys:
self.accept(key, self.record_response, [key])
def record_response(self, key):
for k in self.question_keys:
self.ignore(k)
for i, t in enumerate(self.question_choice_text):
if i != (int(key) - 1):
t.detachNode()
self.toggle_task("physics")
def physics(self, task):
""" Task: simulate physics."""
# Elapsed time.
dt = self._get_elapsed() - self.old_elapsed
# Update amount of time simulated so far.
self.old_elapsed += dt
# Step the physics dt time.
size_sub = self.bbase.sim_par["size_sub"]
n_subs = int(dt / size_sub)
self.bbase.step(dt, n_subs, size_sub)
if self.old_elapsed >= self.feedback_time:
self.toggle_task("show_trial")
return task.done
else:
return task.cont
class DebugOptions(DirectObject):
def __init__(self, parent):
self.parent = parent
self.textPlayerPos = OnscreenText(text='',
parent=base.a2dTopLeft,
pos=(0, -0.1),
scale=0.04,
fg=(1, 1, 1, 1),
align=TextNode.ALeft)
self.showFps = True
base.setFrameRateMeter(True)
self.ambientLight = True
self.parent.alight.setColor(VBase4(0.43, 0.43, 0.43, 1.0))
self.flashlightFrustum = False
self.autoShader = True
render.setShaderAuto()
self.playerPos = True
taskMgr.add(self.refreshPlayerPos, 'RefreshPlayerPosTask')
self.textPlayerPos.reparentTo(base.a2dTopLeft)
self.bloom = False
self.blur = False
self.ao = False
self.walls = True
#spotlightpanel
self.spot_light_panel = SpotlightPanel(self, self.parent.player.slight)
base.accept('f1', self.toggleFps)
base.accept('f2', self.toggleAmbientLight)
base.accept('f3', self.toggleFlashlightFrustum)
base.accept('f4', self.parent.player.getDamage)
base.accept('f5', self.toggleAutoShader)
base.accept('f6', self.togglePlayerPos)
base.accept('f7', self.toggleBloom)
base.accept('f8', self.toggleBlur)
base.accept('f9', self.toggleAO)
base.accept('f10', self.toggleWalls)
base.accept('f11', render.analyze)
base.accept('f12', self.debugPrint)
def toggleFps(self):
if self.showFps == False:
self.showFps = True
base.setFrameRateMeter(True)
else:
self.showFps = False
base.setFrameRateMeter(False)
def toggleAmbientLight(self):
if self.ambientLight == False:
self.ambientLight = True
self.parent.alight.setColor(VBase4(0.43, 0.43, 0.43, 1.0))
else:
self.ambientLight = False
self.parent.alight.setColor(VBase4(0.03, 0.03, 0.03, 1.0))
def toggleFlashlightFrustum(self):
if self.flashlightFrustum == False:
self.flashlightFrustum = True
self.parent.slight.showFrustum()
else:
self.flashlightFrustum = False
self.parent.slight.hideFrustum()
def toggleAutoShader(self):
if self.autoShader == False:
self.autoShader = True
render.setShaderAuto()
else:
self.autoShader = False
render.setShaderOff()
def toggleWalls(self):
if self.walls == False:
self.walls = True
self.parent.level.wall_node.reparentTo(self.parent.level.node)
else:
self.walls = False
self.parent.level.wall_node.detachNode()
def togglePlayerPos(self):
if self.playerPos == False:
self.playerPos = True
taskMgr.add(self.refreshPlayerPos, 'RefreshPlayerPosTask')
self.textPlayerPos.reparentTo(base.a2dTopLeft)
else:
self.playerPos = False
taskMgr.remove('RefreshPlayerPosTask')
self.textPlayerPos.detachNode()
def toggleBloom(self):
if self.bloom == False:
self.bloom = True
self.parent.filters.setBloom()
else:
self.bloom = False
self.parent.filters.delBloom()
def toggleBlur(self):
if self.blur == False:
self.blur = True
self.parent.filters.setBlurSharpen()
else:
self.blur = False
self.parent.filters.delBlurSharpen()
def toggleAO(self):
if self.ao == False:
self.ao = True
self.parent.filters.setAmbientOcclusion()
else:
self.ao = False
self.parent.filters.delAmbientOcclusion()
def refreshPlayerPos(self, task):
px, py, pz = self.parent.player.node.getPos()
self.textPlayerPos.setText('Player pos: (%0.3f, %0.3f, %0.3f)' %
(px, py, pz))
return task.cont
def debugPrint(self):
print taskMgr
