def build_world(self):
space.nodes["ToggleGroup_HapticBlocker"].graphicsOn = False
space.nodes["ToggleGroup_HapticBlocker"].hapticsOn = False
self.white_material = space.nodes["Material_WhiteMaterial"]
self.black_material = space.nodes["Material_BlackMaterial"]
self.force_field = hgn.ForceField()
self.add_child(self.force_field)
self.base_plates = []
self.shelves = []
self.shelf_scores = []
self.occupied_shelves = 0
for i in range(self.number_of_shelves):
self.shelves.append([])
self.shelf_scores.append(BASE_SHELF_SCORE)
for j in range(self.mugs_per_shelf):
foo = i * self.mugs_per_shelf + j
space.nodes["ToggleGroup_Ball.%03d" % foo].graphicsOn = False
# Plates
for i in range(self.number_of_base_plates +
self.number_of_shelves * self.mugs_per_shelf):
transform = space.nodes["Transform_Plate.%03d" % i]
is_base_plate = i < self.number_of_base_plates
shelf_index = None
if not is_base_plate:
shelf_index = (
i - self.number_of_base_plates) / self.mugs_per_shelf
plate_info = {
'transform': transform,
'occupied': False,
'mug_info': None,
'base_plate': is_base_plate,
'shelf_index': shelf_index,
'finished': False,
}
if is_base_plate:
self.base_plates.append(plate_info)
else:
self.shelves[shelf_index].append(plate_info)
evt = Event()
evt.plate_info = plate_info
bl = MFBoolListener(
onTrue=self.touch_plate,
callbackObject=evt,
)
space.nodes["Mesh_Plate.%03d" %
i].h3dNode.isTouched.routeNoEvent(bl)
if i < self.number_of_base_plates - 1:
self.add_mug(plate_info=plate_info,
color_index=i % self.number_of_colors)
def build_world(self):
# Labels
#space.nodes["Text_Message"].string = [_("Touch all targets in order, man.")]
# Sounds
self.pop_sound = Sound("sounds/pop.wav", copies=3, intensity=0.5)
# Gather target materials
self.default_target_material = space.nodes["Material_DefaultTarget"]
self.next_target_material = space.nodes["Material_NextTarget"]
self.target_infos = []
for i in range(NUMBER_OF_TARGETS):
target = X3DFileNode("target.hgt")
self.add_child(target)
# Position the target according to the corresponding
# empty in the scene.
transform = target.find("Transform_TargetEmpty")
empty_transform = space.nodes["Transform_BubbleEmpty.%03d" % i]
transform.translation = empty_transform.translation
appearance = target.find("Appearance_TargetHaptic")
toggle = target.find("ToggleGroup_TargetHaptic")
if i == 0:
appearance.material = self.next_target_material.h3dNode
#toggle.graphicsOn = True
toggle.hapticsOn = True
else:
appearance.material = self.default_target_material.h3dNode
#toggle.graphicsOn = False
toggle.hapticsOn = False
# Create target info
target_info = {
'target_id': i,
'appearance': appearance,
'done': False,
'original_position': transform.translation,
'toggle': toggle,
}
self.target_infos.append(target_info)
# Bind touch
evt = Event()
evt.target_info = target_info
bl = MFBoolListener(
onTrue=self.touch_target,
callbackObject=evt
)
target.find("Mesh_TargetHaptic").h3dNode.isTouched.routeNoEvent(bl)
def build_world(self):
# Bow string represented by two straight lines.
self.top_line = LineShape(width=3)
self.add_child(self.top_line.node)
self.bottom_line = LineShape(width=3)
self.add_child(self.bottom_line.node)
# Markers and debug stuff
"""
self.line_marker = LineShape(width=5)
self.line_marker.material.emissiveColor = RGB(1, 0, 0)
self.line_marker.material.diffuseColor = RGB(1, 0, 0)
self.add_child(self.line_marker.node)
"""
space.nodes["ToggleGroup_Marker1"].graphicsOn = False
space.nodes["ToggleGroup_Marker2"].graphicsOn = False
# Save original pullpoint
self.orig_pp_translation = space.nodes['Transform_PullPoint'].translation
# Spring effect off when game starts
self.spring_effect = hgn.SpringEffect(
startDistance = 0.0,
escapeDistance = 0.001,
springConstant = 10,
)
space.nodes['Transform_StringPoint'].add_child(self.spring_effect)
# Sky motion - off
#space.nodes['DynamicTransform_Sky'].momentum = Vec3f(0.005, 0, 0)
# Reloader
bl = MFBoolListener(
onTrue=self.touch_reloader,
)
space.nodes["Mesh_Quiver"].h3dNode.isTouched.routeNoEvent(bl)
space.nodes["Mesh_ArrowFeathers"].h3dNode.isTouched.routeNoEvent(bl)
space.nodes["Mesh_ArrowStick"].h3dNode.isTouched.routeNoEvent(bl)
# Firing mechanism (Either omni button)
bl = BoolListener(
onTrue=self.press_stylus_button,
)
hgt.haptics.hdev.mainButton.routeNoEvent(bl)
hgt.haptics.hdev.secondaryButton.routeNoEvent(bl)
def add_mug(self, plate_info, color_index):
assert (plate_info["base_plate"])
assert (not plate_info["occupied"])
#print "Adding color mug", color_index
plate_info["occupied"] = True
mug = X3DFileNode("mug.hgt")
self.add_child(mug)
mug.find("ToggleGroup_HapticMug").graphicsOn = False
toggle = mug.find("ToggleGroup_MugEmpty")
transform = mug.find("Transform_MugEmpty")
transform.translation = plate_info['transform'].translation
appearance = mug.find("Appearance_MugModel")
appearance.material = space.nodes["Material_Mug%d" %
color_index].h3dNode
mesh = mug.find("Mesh_HapticMug")
grabObject = self.grabber.register(
transform=transform,
toggle=toggle,
)
mug_info = {
'color_index': color_index,
'transform': transform,
'appearance': appearance,
'grabObject': grabObject,
'toggle': toggle,
'plate_info': plate_info,
'finished': False,
}
evt = Event()
evt.mug_info = mug_info
bl = MFBoolListener(
onTrue=self.touch_mug,
callbackObject=evt,
)
mesh.h3dNode.isTouched.routeNoEvent(bl)
plate_info["mug_info"] = mug_info
def build_world(self):
# Invisible answer buttons
self.answer_pads = []
for i in range(self.number_of_answers):
prefix = "%s." % ['a', 'b', 'c', 'd'][i]
space.nodes["ToggleGroup_AnswerPad%d" % i].graphicsOn = False
material = space.nodes["Material_Answer%d" % i]
info = {
'id':
i,
'answer':
None,
'answered':
False,
'material':
material,
'prefix':
'', #prefix,
'feedback_pos':
space.nodes["Transform_AnswerPad%d" % i].translation +
Vec3f(0, -0.02, 0.02)
}
self.answer_pads.append(info)
e = Event()
e.info = info
pushButton = PushButton(
transformNode=space.nodes["Transform_AnswerPad%d" % i].h3dNode,
geometry=space.nodes["Mesh_AnswerPad%d" % i].h3dNode,
displacement=Vec3f(0, 0, 0),
event=e,
onPress=self.press_answer_pad,
)
# Chalk tap sounds when touching blackboard
bl = MFBoolListener(onTrue=self.touch_chalkboard, )
space.nodes["Mesh_Chalkboard"].h3dNode.isTouched.routeNoEvent(bl)
self.build_feedback_label()
def build_world(self):
# Labels
space.nodes["Text_Message"].string = [_("Touch all targets in order (1-2-3 ...)")]
# Sounds
self.correct_sound = Sound("sounds/correct.wav", copies=3, intensity=0.5)
self.wrong_sound = Sound("sounds/wrong.wav", copies=3, intensity=0.5)
# Gather target materials
self.default_target_material = space.nodes["Material_DefaultTarget"]
self.correct_target_material = space.nodes["Material_CorrectTarget"]
self.wrong_target_material = space.nodes["Material_WrongTarget"]
self.target_infos = []
for i in range(NUMBER_OF_TARGETS):
target = X3DFileNode("target.hgt")
self.add_child(target)
# Make the haptic part invisible
target.find("ToggleGroup_TargetHaptic").graphicsOn = False
# Set the label
if ALPHANUMERIC_SEQUENCE:
if i % 2 == 0:
label = str((i / 2) + 1)
else:
label = chr(ord('A') + (i / 2))
else:
label = str(i + 1)
target.find("Text_TargetLabel").string = [label]
# Set outline appearance to default color (black)
appearance = target.find("Appearance_TargetOutline")
appearance.material = self.default_target_material.h3dNode
# Position the target according to the corresponding
# empty in the scene.
transform = target.find("Transform_TargetEmpty")
empty_transform = space.nodes["Transform_CircleEmpty.%03d" % i]
transform.translation = empty_transform.translation
# Create target info
target_info = {
'appearance': appearance,
'done': False,
'original_position': transform.translation,
'target_id': i,
'touched_this_round': False,
}
self.target_infos.append(target_info)
# Bind touch
evt = Event()
evt.target_info = target_info
bl = MFBoolListener(
onTrue=self.touch_target,
callbackObject=evt
)
target.find("Mesh_TargetHaptic").h3dNode.isTouched.routeNoEvent(bl)
def build_world(self):
self.force_field = hgn.ForceField()
self.add_child(self.force_field)
self.left_bucket_material = space.nodes["Material_LeftBucket"]
self.right_bucket_material = space.nodes["Material_RightBucket"]
self.fish_texture = hgn.ImageTexture(url="textures/fish0.jpg")
# Fish
self.fish_info = {}
for i in range(self.fish_count):
fishModel = X3DFileNode("fish0.x3d")
fishShadow = X3DFileNode("fish_shadow.hgt")
self.add_child(fishModel)
dynamicTransform = fishModel.find("DynamicTransform_Fish")
dynamicTransform.orientation = Rotation(1, 0, 0, 90 * DEG2RAD)
dynamicTransform.orientation = Rotation(0, 0, 1, random.random() * math.pi) * dynamicTransform.orientation
transform = fishModel.find("Transform_Fish")
fish_appearance = fishModel.find("FISH_APPEARANCE")
fish_appearance.texture = self.fish_texture.h3dNode
foo = 0.02
fish_x = (i / float(self.fish_count)) * (2 * foo) - foo
fish_z = -0.10 + i * 0.0045
transform.translation = Vec3f(fish_x, 0, fish_z)
toggle = fishModel.find("ToggleGroup_Fish")
dynamicTransform.add_child(fishShadow)
fishShadow.find("Transform_Plane").translation = Vec3f(0, -0.11 - fish_z + i * 0.001, 0)
grabObject = self.grabber.register(
transform=transform,
toggle=toggle,
)
info = {
'fishId': i,
'transform': transform,
'grabObject': grabObject,
'dynamicTransform': dynamicTransform,
'transformInfo': fishModel.find("TransformInfo_Fish"),
'swimming': True,
'bumpTime': None,
'toggle': toggle,
'shadowToggle': fishShadow.find("ToggleGroup_Plane"),
}
self.fish_info[i] = info
evt = Event()
evt.info = info
bl = MFBoolListener(
onTrue=self.touch_fish,
callbackObject = evt,
)
fishModel.find("TouchSphere").h3dNode.isTouched.routeNoEvent(bl)
# Touching the aquarium glass
bl = MFBoolListener(
onTrue=self.touch_aquarium_glass,
callbackObject = evt,
)
space.nodes["Mesh_InnerAquariumGlass"].h3dNode.isTouched.routeNoEvent(bl)
bl = MFBoolListener(
onTrue=self.touch_outer_aquarium_glass,
callbackObject = evt,
)
space.nodes["Mesh_OuterAquariumGlass"].h3dNode.isTouched.routeNoEvent(bl)
# Touching the enemies
for i in range(self.number_of_enemies):
evt = Event()
evt.info = {
'flasher': self.enemy_flashers[i]
}
bl = MFBoolListener(
onTrue=self.touch_enemy,
callbackObject = evt,
)
space.nodes["Mesh_EnemySphere.%03d" % i].h3dNode.isTouched.routeNoEvent(bl)
space.nodes["ToggleGroup_EnemySphere.%03d" % i].graphicsOn = False
def build_world(self):
# Slot machine buttons
self.button_infos = {
'spin_reels': {
'name': 'SpinButton',
'title': _('SPIN'),
'id': 'spin_reels',
'label': space.nodes["Text_SpinButtonLabel"],
'material': space.nodes["Material_SpinButton"],
},
'bet_one': {
'name': 'BetButton',
'title': _('BET'),
'id': 'bet_one',
'label': space.nodes["Text_BetButtonLabel"],
'material': space.nodes["Material_BetButton"],
},
'exit': {
'name': 'ExitButton',
'title': _('EXIT'),
'id': 'exit',
'label': space.nodes["Text_ExitButtonLabel"],
'material': space.nodes["Material_ExitButton"],
},
}
for i in range(3):
bid = "hold%d" % i
self.button_infos[bid] = {
'name': 'HoldButton.%03d' % i,
'title': _('HOLD'),
'id': 'hold0',
'label': space.nodes["Text_HoldButtonLabel.%03d" % i],
'material': space.nodes["Material_HoldButton.%03d" % i],
}
for bi in self.button_infos.values():
# Set label
bi['label'].string = [bi['title']]
e = Event()
e.info = bi
pushButton = PushButton(
transformNode=space.nodes["Transform_%s" % bi['name']].h3dNode,
geometry=space.nodes["Mesh_%s" % bi['name']].h3dNode,
displacement=Vec3f(0, 0.005,
0), # push down 5 mm in negative z dir
onPress=self.press_button,
pressSound=self.button_up_sound,
releaseSound=self.button_down_sound,
event=e,
)
self.disable_button(bi)
# Coin
transform = space.nodes["Transform_TopCoin"]
grabObject = self.grabber.register(
transform=transform,
toggle=space.nodes["ToggleGroup_TopCoin"],
)
evt = Event()
evt.info = {
'transform': transform,
'grabObject': grabObject,
'originalTranslation': transform.translation,
'originalRotation': transform.rotation,
}
bl = MFBoolListener(
onTrue=self.touch_coin,
callbackObject=evt,
)
space.nodes["Mesh_TopCoin"].h3dNode.isTouched.routeNoEvent(bl)
# Coin slot
bl = MFBoolListener(onTrue=self.touch_coin_slot, )
space.nodes["Mesh_CoinSlot"].h3dNode.isTouched.routeNoEvent(bl)
def build_world(self):
self.feedback_label = FeedbackLabel(
topnode=self.node,
text=space.nodes["Text_FeedbackLabel"],
transform=space.nodes["Transform_FeedbackLabel"],
material=space.nodes["Material_FeedbackLabel"],
toggle=space.nodes["ToggleGroup_FeedbackLabel"],
)
self.button_infos = []
self.button_material = space.nodes["Material_BingoButton"]
self.pressed_button_material = space.nodes[
"Material_BingoButtonPressed"]
self.completed_button_material = space.nodes[
"Material_BingoButtonCompleted"]
self.bingo_button_material = space.nodes["Material_BingoButtonBingo"]
space.nodes["Transform_ButtonAnchor"].scale = self.grid_scale * Vec3f(
1, 1, 1)
# Center buttons about x = 0
c = ((self.square_size - 1) * self.button_spacing) / 2.0
centering_vector = Vec3f(-c, 0, 0)
for col in range(self.square_size):
for row in range(self.square_size):
index = col * self.square_size + row
bb = X3DFileNode("bingobutton.hgt")
space.nodes["Transform_ButtonAnchor"].add_child(bb)
transform = bb.find("Transform_BingoButtonEmpty")
mesh = bb.find("Mesh_BingoButtonMesh")
appearance = bb.find("Appearance_BingoButton")
appearance.material = self.button_material.h3dNode
label = bb.find("Text_BingoLabel")
# Put the button in position and mark it
transform.translation += Vec3f(col * self.button_spacing,
row * self.button_spacing,
0) + centering_vector
number = self.sequence[index]
label.string = [str(number)]
# Button touch listener
info = {
'pressed': False,
'found': False,
'appearance': appearance,
'number': number,
'transform': transform,
'row': row,
'col': col,
'index': index,
'bingoed': False,
}
evt = Event()
evt.info = info
self.button_infos.append(info)
bl = MFBoolListener(
onTrue=self.touch_button,
callbackObject=evt,
)
self.save_ref(bl)
mesh.h3dNode.isTouched.routeNoEvent(bl)
def build_environment(self):
# Spinning earth
self.earthSpinner = hgn.DynamicTransform(
angularMomentum = Vec3f(0, 0, 0)
)
space.nodes["Transform_EarthSea"].reparent_children_to(self.earthSpinner)
bl = MFBoolListener(
onTrue = self.touch_earth,
onFalse = self.untouch_earth,
)
space.nodes["Mesh_EarthSea"].h3dNode.isTouched.routeNoEvent(bl)
self.touchingEarth = False
# Touchable fruit plate bottom, coupled to release of grabbed objects
bl = MFBoolListener(
onTrue = self.grabManager.release,
)
space.nodes["Mesh_GrabReleaseSensor"].h3dNode.isTouched.routeNoEvent(bl)
# Bobbing guide arrow
self.guideArrow = hgn.Transform()
self.guideToggle = hgn.ToggleGroup(graphicsOn = False)
self.guideArrowPos = space.nodes["Transform_GuideArrow"]
self.guideArrowPos.reparent_children_to(self.guideArrow)
self.guideArrowPos.reparent_children_to(self.guideToggle)
# A light that follows the stylus
"""
self.stylusLight = hgn.PointLight(
intensity = 0.1,
attenuation = Vec3f(0, 10, 50),
)
self.add_child(self.stylusLight)
"""
# An unreachable fish swimming in the aquarium
self.fishTransform = hgn.DynamicTransform(
position = Vec3f(0, 0.24, 0),
angularMomentum = Vec3f(0, 0, 0.075),
)
fish = X3DFileNode("fish.x3d")
self.fishTransform.add(fish)
self.add_child(self.fishTransform)
# A button that toggles the "aquarium light" on/off. Really controls
# the aquarium glass transparency.
button = space.nodes["Transform_LightButton"]
buttonMesh = space.nodes["Mesh_LightButton"]
b = PushButton(
transformNode = button.h3dNode,
geometry = buttonMesh.h3dNode,
onPress = self.press_aquarium_button,
displacement = Vec3f(0, 0.0025, 0),
hitForce = 1.0,
)
space.nodes["ToggleGroup_AquariumGlassEmpty"].graphicsOn = False
self.aquariumLightOn = False
self.aquariumLamp = space.nodes["PointLight_AquariumLamp"]
self.exitLamp = space.nodes["PointLight_ExitLamp"]
# Tapping on aquarium glass
bl = MFBoolListener(
callbackObject = None,
onTrue = self.tap_glass,
)
space.nodes["Mesh_AquariumGlass"].h3dNode.isTouched.routeNoEvent(bl)
# Something that when touched initiates the exit procedure
bl = MFBoolListener(
callbackObject = None,
onTrue = self.initiate_exit,
)
space.nodes["Mesh_ExitSign"].h3dNode.isTouched.routeNoEvent(bl)
self.exitSignMaterial = space.nodes["Material_ExitSign"]
self.exiting = False
self.readyToQuit = False
# Particle systems
# Device trail
p = X3DFileNode("trail_particles.x3d")
self.trailParticleEmitter = p.find("EMITTER")
self.add_child(p)