class Preloader():
def __init__(self):
self.progressBar = DirectWaitBar(text = "", value = 0, pos = (0,0,0), scale = 0.5, barColor = (1,0.3,0,1))
self.textObject = OnscreenText(text = "", pos = (0.0,-0.15),
scale = 0.1,fg=(0,0,0,1),align=TextNode.ACenter,mayChange=1)
f = open('models_2.txt', 'r')
self.models = f.readlines()
f.close()
for N in range(len(self.models)):
self.models[N] = self.models[N].replace("\n", "")
self.totalItems = len(self.models)
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
self.itemCount = 0
for M in self.models:
print(M)
item = loader.loadModel(M)
progress = 100 / float(self.totalItems)
self.progressBar['value'] += progress
#text = str(self.progressBar['value'])+'%'
self.textObject.setText("Loading")
#self.loaderBar.setTexOffset(self.modTS, -progress + 0.15,0)
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
self.textObject.destroy()
self.progressBar.destroy()
class RaceGui(Gui, RaceGuiFacade):
def __init__(self, mdt, racegui_props):
Gui.__init__(self, mdt)
r_p = self.props = racegui_props
result_props = ResultProps(r_p.menu_args, r_p.drivers_img,
r_p.cars_imgs, r_p.share_urls,
r_p.share_imgs, r_p.track_name)
self.results = Results(result_props)
self.loading = Loading(mdt)
self.debug_txt = OnscreenText('',
pos=(-.1, .1),
scale=.05,
fg=(1, 1, 1, 1),
parent=eng.base.a2dBottomRight,
align=TextNode.ARight)
self.way_txt = OnscreenText('',
pos=(.1, .1),
scale=.1,
fg=r_p.menu_args.text_err,
parent=eng.base.a2dBottomLeft,
align=TextNode.ALeft,
font=FontMgr().load_font(r_p.font))
def start(self):
self.minimap = Minimap(self.mdt.track.lrtb, self.props.minimap_path,
self.props.minimap_image, self.props.col_dct,
self.props.cars, self.props.car_name)
def destroy(self):
self.results.destroy()
self.loading.destroy()
self.way_txt.destroy()
self.minimap.destroy()
Gui.destroy(self)
class Countdown(GameObject):
def __init__(self, sfx_path, font, seconds):
GameObject.__init__(self)
self.countdown_sfx = loader.loadSfx(sfx_path)
self.__countdown_txt = OnscreenText('',
pos=(0, 0),
scale=.2,
fg=(1, 1, 1, 1),
font=font)
self.__cnt = seconds
self.tsk = self.eng.do_later(1.0, self.process_countdown)
def process_countdown(self):
if self.__cnt >= 0:
self.countdown_sfx.play()
txt = str(self.__cnt) if self.__cnt else _('GO!')
self.__countdown_txt.setText(txt)
self.__cnt -= 1
return Task.again
self.__countdown_txt.destroy()
self.notify('on_start_race')
def destroy(self):
self.tsk = self.eng.rm_do_later(self.tsk)
self.__countdown_txt.destroy()
GameObject.destroy(self)
class LoadingScreen:
def __init__(self, main):
self.main = main
self.imageObject = OnscreenImage(image = 'IMAGES/loading.jpg', pos = (0, 0, 0))
self.imageObject.reparentTo(render2d)
#base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
def finish(self):
self.imageObject.destroy()
self.countDownText = OnscreenText(text=str(countDownStart), style=1, fg=(1,1,1,1),
pos=(0.01, 0.1), align = TextNode.ACenter, scale = .2, mayChange = 1)
taskMgr.add(self.countDown,"countDownTask")
def countDown(self,task):
timeLeft = "%01d" % (countDownStart - task.time)
if (countDownStart - task.time) > 1:
self.countDownText.setText(timeLeft)
return task.cont
elif 1 > (countDownStart - task.time) > 0:
self.countDownText.setText("GO!")
return task.cont
else:
self.canMove = True
if not self.main.isActive:
print "Activate"
self.main.isActive = True
taskMgr.add(self.main.update, 'updateWorld')
self.main.activateKeys()
self.countDownText.destroy()
return task.done
class Countdown(Subject):
def __init__(self, countdown_sfx, font):
Subject.__init__(self)
self.countdown_sfx = loader.loadSfx(countdown_sfx)
self.__countdown_txt = OnscreenText(
'', pos=(0, 0), scale=.2, fg=(1, 1, 1, 1), font=font)
self.countdown_cnt = 3
meth = self.process_countdown
self.tsk = taskMgr.doMethodLater(1.0, meth, 'countdown')
# manage repeating do_later
def process_countdown(self, task):
if self.countdown_cnt >= 0:
self.countdown_sfx.play()
txt = str(self.countdown_cnt) if self.countdown_cnt else _('GO!')
self.__countdown_txt.setText(txt)
self.countdown_cnt -= 1
return task.again
self.__countdown_txt.destroy()
self.notify('on_start_race')
def destroy(self):
self.tsk = taskMgr.remove(self.tsk)
self.__countdown_txt.destroy()
Subject.destroy(self)
def isCheck(self, index):
kingIndex = 0
for i in range(0, 64):
if (isinstance(self.pieces[i], King)
and self.pieces[i].obj.getColor() != self.turn):
kingIndex = i
for j in range(0, 64):
if (isinstance(self.pieces[index], Piece)
and self.pieces[index].obj.getColor() == self.turn):
if (self.checkIfRoutePossible(
index, kingIndex,
self.pieces[index].getMovementTableBattle())):
global check
print("CHECK FOUND")
label = "white"
if self.turn == WHITE:
label = "black"
check = OnscreenText(text="Check on " + label + " king",
parent=base.a2dTopLeft,
align=TextNode.ALeft,
style=1,
fg=(1, 1, 1, 1),
pos=(0.06, -0.26),
scale=.05)
elif (not isinstance(check, type(None))):
print("Should remove now")
check.destroy()
check = None
class TextHistoryLabel(NodePath):
def __init__(self, text, speaker = None, voiceName = None, parent = None, height = 0):
#TODO add a voice button in it
NodePath.__init__(self,'texthistorylabel')
self.parent = parent or aspect2d
self.reparentTo(parent)
if speaker:
text = '\1th_name\1(' + speaker.strip() + ')\n\2' + text
self.textcontent = OnscreenText(text = text,align = TextNode.ALeft, pos = (TEXTLEFT,-height),
wordwrap = WORDWRAP, parent = self, **base.getStyle('historytext'))
self.labelHeight = self.textcontent.textNode.getHeight() * self.textcontent.getScale()[1]
def destroy(self):
self.textcontent.destroy()
self.removeNode()
def getLabelHeight(self):
return self.labelHeight
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.hs = OnscreenText(' ',
style=1,
fg=(1, 1, 1, 1),
pos=(-0.4, -0.8),
scale=.1)
bg = OnscreenImage(image='models/banner.png', pos=(0, 0, 0))
b = DirectButton(text=("Play"),
text_bg=(255, 255, 255, 0),
text_scale=(0.5, 0.5),
text_fg=(0, 0, 255, 255),
scale=.2,
command=setText)
b.setPos(0.55, 0, -0.75)
self.taskMgr.add(self.update, "update")
def update(self, task):
p = open('score.txt', 'r')
score = p.readline()
p.close()
self.hs.destroy()
self.hs = OnscreenText(score,
style=1,
fg=(1, 1, 1, 1),
pos=(-0.4, -0.8),
scale=.1)
return Task.cont
class Alert(Notifier):
def __init__(self, reason):
Notifier.__init__(self, "alert")
VirtualFileSystem.getGlobalPtr().mount(Filename("mf/alert.mf"), ".",
VirtualFileSystem.MFReadOnly)
ok = loader.loadModel("alert.egg")
if reason not in LOCAL_EN:
reason = GENERAL
self.reason = reason
self.bg_frame = DirectFrame(frameColor=(0, 0, 0, 0),
frameSize=(-1, 1, -1, 1),
suppressMouse=1,
state=DGG.NORMAL,
sortOrder=1000)
self.frame = DirectFrame(frameSize=(1, 1, 1, 1),
image=ok.find('**/alert'),
image_scale=(1, 0, 0.6),
state=DGG.NORMAL,
parent=self.bg_frame)
self.text = OnscreenText(text=LOCAL_EN[reason],
fg=(1, 1, 1, 1),
pos=(0, 0.15, 0),
align=TextNode.ACenter,
wordwrap=13,
parent=self.frame)
self.button = DirectButton(geom=(ok.find('**/ok-ready'),
ok.find('**/ok-click'),
ok.find('**/ok-hover'),
ok.find('**/ok-click')),
relief=None,
geom_scale=(0.3, 0, 0.15),
geom_pos=(0, 0, -0.175),
pressEffect=0,
command=self.destroy,
parent=self.frame)
self.notify.debug(
f"[__init__] Created Alert with reason {self.reason}")
loader.unloadModel(ok)
def __repr__(self):
return str(self.reason)
def destroy(self):
VirtualFileSystem.getGlobalPtr().unmount("mf/alert.mf")
VirtualFileSystem.getGlobalPtr().unmount("mf/ok_small.mf")
self.bg_frame.destroy()
self.frame.destroy()
self.button.destroy()
self.text.cleanup()
self.text.destroy()
del self.frame
del self.button
del self.text
del self
class Core(FSM):
"""knows Menu, Scenario and Loading."""
def __init__(self):
FSM.__init__(self, "Core Game Control")
# We might need to put a loading screen in front of menu if we get some
# fancy menu screens.
self.defaultTransitions = {
"Menu": [
"Loading",
],
"Loading": [
"Scenario",
],
"Scenario": ["Menu", "Loading"]
}
# Optional, but prevents a warning message.
# The scenario task chain gives us grouping option.
# It might get replaced by an own task manager, by chance.
base.taskMgr.setupTaskChain("scenario", frameBudget=-1)
def enterLoading(self, scenario):
# TODO: put this into gui package and add a black background
self.loading = OnscreenText(text="LOADING",
pos=(0, 0),
scale=0.1,
align=TextNode.ACenter,
fg=(1, 1, 1, 1))
self.preloader = scenarioPreloader(scenario)
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
self.preloader.preloadFast() # depends on the loading screen
# Other preloader methods would specify a callback that calls
# self.demand(scenario), but preloadFast() is executed in one frame, so
# we can safely demand that from here. Interactive loading screens
# might require special handling.
self.demand("Scenario", scenario)
def exitLoading(self):
self.loading.destroy()
del self.loading
del self.preloader
def enterScenario(self, scenario):
self.scenario = ScenarioProxy(scenario)
self.scenario.begin()
def exitScenario(self):
self.scenario.destroy()
del self.scenario
def enterMenu(self, menu, *args):
#self.menu = MenuProxy(menu, *args)
import gui
self.menu = getattr(gui, menu)()
def exitMenu(self):
self.menu.destroy()
def keyboard_action_check(self):
"""Check for actions and update the object accordingly"""
### recording ###
# for start and stop recording you press a then r
if keyboard.is_pressed('a'):
keyboard.wait('r')
self.recording_text = OnscreenText(text='',
pos=(0.0, -0.4),
scale=0.07)
if self.is_recording:
self.recording_text.destroy()
saving_text = OnscreenText(text='saving',
pos=(0.0, -0.4),
scale=0.07)
# if previous state was recording then we store the data in json tables and reset the variables
json.dump(
self.stored_vals,
open(
'posture-app/results/' + self.record_id +
'/pose3d_data.txt', 'w'))
json.dump(
np.array(self.stored_kinect_data).tolist(),
open(
'posture-app/results/' + self.record_id +
'/kinect_data.txt', 'w'))
json.dump(
self.stored_pifpaf,
open(
'posture-app/results/' + self.record_id +
'/pifpaf_data.txt', 'w'))
self.stored_vals = {
"azure": {
"head": [],
"back": [],
"orient": []
},
"pose3d": {
"head": [],
"back": [],
"orient": []
}
}
self.stored_kinect_data = []
self.stored_pifpaf = []
self.record_id = str(int(time.time()))
self.record_count = 0
saving_text.destroy()
else:
self.recording_text = OnscreenText(text='recording',
pos=(0.0, -0.4),
scale=0.07)
self.is_recording = not self.is_recording
class ResponseRegister(ServerResponse):
def execute(self, data):
try:
self.status = data.getString()
print "ResponseRegister - ", self.status
if (self.status == "Success"):
print "Created Successfully!"
elif self.status == "Same Username":
print "Already have that username"
#self.l = login2()
#self.l.throwIncorrectUsername()
taskMgr.add(self.destroyIncorrectUsername,
"destroyIncorrectUsername")
self.throwIncorrectUsername()
else:
print "there was a problem with the server"
taskMgr.add(self.destroyServerError, "destroyServerError")
self.throwServerError()
#self.log('Received [' + str(Constants.RAND_STRING) + '] String Response')
except:
self.log('Bad [' + str(self.status) + '] Register Response')
print_exc()
def throwIncorrectUsername(self):
self.incorrectUsername = OnscreenText(
text="Already have that username",
pos=(0, -.5),
scale=0.05,
fg=Constants.TEXT_ERROR_COLOR,
mayChange=0)
def throwServerError(self):
self.serverError = OnscreenText(text="Unable to Connect to Server",
pos=(0, -.5),
scale=0.05,
fg=Constants.TEXT_ERROR_COLOR,
mayChange=0)
def destroyIncorrectUsername(self, task):
if task.time < 5.0:
return task.cont
else:
self.incorrectUsername.destroy()
return task.done
def destroyServerError(self, task):
if task.time < 5.0:
return task.cont
else:
self.serverError.destroy()
return task.done
def enterWorld(self, scenario=scenarios.TestEnvironment):
#self.world = OdeWorld()
#self.world.setGravity(0.0, 0.0, 0.0)
#world.setGravity(0.0, 0.0, -9.81)
loading = OnscreenText(text="LOADING", pos=(0,0), scale=0.1,
align=TextNode.ACenter, fg=(1,1,1,1))
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
self.scenario = scenario()
loading.destroy()
self.scenario.start()
class EmptyScene(Scene): def showScene(self): self.text = OnscreenText(text = 'Empty Scene', pos = (0, 0), scale = 0.2) return True # end showScene def hideScene(self): self.text.destroy() return True # end hideScene
class EmptyScene(Scene):
def showScene(self):
self.text = OnscreenText(text='Empty Scene', pos=(0, 0), scale=0.2)
return True
# end showScene
def hideScene(self):
self.text.destroy()
return True
# end hideScene
class Core(FSM):
"""knows Menu, Scenario and Loading."""
def __init__(self):
FSM.__init__(self, "Core Game Control")
# We might need to put a loading screen in front of menu if we get some
# fancy menu screens.
self.defaultTransitions = {"Menu":["Loading",],
"Loading":["Scenario",],
"Scenario":["Menu", "Loading"]
}
# Optional, but prevents a warning message.
# The scenario task chain gives us grouping option.
# It might get replaced by an own task manager, by chance.
base.taskMgr.setupTaskChain("scenario", frameBudget=-1)
def enterLoading(self, scenario):
# TODO: put this into gui package and add a black background
self.loading = OnscreenText(text="LOADING", pos=(0,0), scale=0.1,
align=TextNode.ACenter, fg=(1,1,1,1))
self.preloader = scenarioPreloader(scenario)
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
self.preloader.preloadFast() # depends on the loading screen
# Other preloader methods would specify a callback that calls
# self.demand(scenario), but preloadFast() is executed in one frame, so
# we can safely demand that from here. Interactive loading screens
# might require special handling.
self.demand("Scenario", scenario)
def exitLoading(self):
self.loading.destroy()
del self.loading
del self.preloader
def enterScenario(self, scenario):
self.scenario = ScenarioProxy(scenario)
self.scenario.begin()
def exitScenario(self):
self.scenario.destroy()
del self.scenario
def enterMenu(self, menu, *args):
#self.menu = MenuProxy(menu, *args)
import gui
self.menu = getattr(gui, menu)()
def exitMenu(self):
self.menu.destroy()
class ServerOptionsMenu(Menu):
def __init__(self):
Menu.__init__(self)
fieldValues = {'Server Name' : Settings.SERVER_NAME,
'World Name' : Settings.LAST_WORLD }
self.fields = {}
y = 0
for fieldLabel, initText in fieldValues.iteritems():
self.fields[fieldLabel] = self.CreateField(fieldLabel, initText, y, False)
y += 1
self.instructions = OnscreenText(text = 'Press Enter to start server', pos = (-0.1, 0.1), scale = 0.09, fg = (1, 1, 1, 1), align = TextNode.ARight, parent = base.a2dBottomRight)
self.Show()
self.acceptOnce('enter', self.OnStart)
def OnStart(self):
Settings.SERVER_NAME = self.GetValue('Server Name')
Settings.LAST_WORLD = self.GetValue('World Name')
ServerStartEvent().Fire()
self.Destroy()
def CreateField(self, fieldLabel, initText, yIndex, focus):
label = OnscreenText(text = fieldLabel, pos = (-0.4, 0.35 - yIndex * 0.2), scale = 0.07, fg = (1, 1, 1, 1), align = TextNode.ALeft)
label.reparentTo(self.node)
f = DirectEntry(text = '' ,
scale = 0.05,
initialText = initText,
numLines = 1,
rolloverSound = None,
clickSound = None,
pos = (-0.4, 1, 0.25 - yIndex * 0.2),
focus = (not focus))
f.reparentTo(self.node)
return f
def GetValue(self, key):
return self.fields[key].get()
def Destroy(self):
self.node.removeNode()
self.instructions.destroy()
class ConsoleLog:
def __init__(self, text, valid, archivable=True, auto_create=True):
"""
@param text: What did they type in the console?
@type text: str
@param valid: Did the command work?
@type valid: bool
@param archivable: Should the log be retrievable via arrow keys?
@type archivable: bool
@param auto_create: Should the text of the log be auto created?
@type auto_create: bool
"""
self.text = text
self.valid = valid
self.log = None
self.archivable = archivable
if auto_create:
self.create()
if not valid and self.log is not None:
self.log["fg"] = (1, 0, 0, 1)
def create(self):
self.log = OnscreenText(text=self.text,
fg=(1, 1, 1, 1),
pos=(-1.25, -.8),
align=TextNode.ALeft)
if not self.archivable:
self.log["pos"] = (self.log["pos"][0] + 0.05, self.log["pos"][1])
self.log["fg"] = (.8, .8, .8, 1)
if not self.valid:
self.log["fg"] = (1, 0, 0, 1)
if not self.archivable:
self.log["fg"] = (.8, 0, 0, 1)
def move_up(self):
"""
Move the OnscreenText up
"""
self.log.setPos(self.log.getPos()[0], self.log.getPos()[1] + 0.07)
def destroy(self):
self.log.destroy()
class ResponseLogin(ServerResponse):
def execute(self, data):
try:
self.status = data.getInt()
#self.username = data.getString()
print "ResponseLogin - ", self.status
if(self.status == 1):
print "logged In!"
c = selectcharandteamtype()
elif self.status == 0:
print "incorrect username/password"
#self.l = login2()
#self.l.throwIncorrectUsername()
taskMgr.add(self.destroyIncorrectUsername, "destroyIncorrectUsername")
self.throwIncorrectUsername()
else:
print "there was a problem with the server"
taskMgr.add(self.destroyServerError, "destroyServerError")
self.throwServerError()
#self.log('Received [' + str(Constants.RAND_STRING) + '] String Response')
except:
self.log('Bad [' + str(self.status) + '] Login Response')
print_exc()
def throwIncorrectUsername(self):
self.incorrectUsername = OnscreenText(text="Incorrect Username/Password",
pos=(0, -.5), scale=0.05, fg=Constants.TEXT_ERROR_COLOR, mayChange=0)
def throwServerError(self):
self.serverError = OnscreenText(text="Unable to Connect to Server",
pos=(0, -.5), scale=0.05, fg=Constants.TEXT_ERROR_COLOR, mayChange=0)
def destroyIncorrectUsername(self, task):
if task.time < 5.0:
return task.cont
else:
self.incorrectUsername.destroy()
return task.done
def destroyServerError(self, task):
if task.time < 5.0:
return task.cont
else:
self.serverError.destroy()
return task.done
class ResponseRegister(ServerResponse):
def execute(self, data):
try:
self.status = data.getInt32()
print "ResponseRegister - ", self.status
if(self.status == 1):
print "Created Successfully!"
elif self.status == 0:
print "Already have that username"
#self.l = login2()
#self.l.throwIncorrectUsername()
taskMgr.add(self.destroyIncorrectUsername, "destroyIncorrectUsername")
self.throwIncorrectUsername()
else:
print "there was a problem with the server"
taskMgr.add(self.destroyServerError, "destroyServerError")
self.throwServerError()
#self.log('Received [' + str(Constants.RAND_STRING) + '] String Response')
except:
self.log('Bad [' + str(self.status) + '] Register Response')
print_exc()
def throwIncorrectUsername(self):
self.incorrectUsername = OnscreenText(text="Already have that username",
pos=(0, -.5), scale=0.05, fg=Constants.TEXT_ERROR_COLOR, mayChange=0)
def throwServerError(self):
self.serverError = OnscreenText(text="Unable to Connect to Server",
pos=(0, -.5), scale=0.05, fg=Constants.TEXT_ERROR_COLOR, mayChange=0)
def destroyIncorrectUsername(self, task):
if task.time < 5.0:
return task.cont
else:
self.incorrectUsername.destroy()
return task.done
def destroyServerError(self, task):
if task.time < 5.0:
return task.cont
else:
self.serverError.destroy()
return task.done
class mainMenu:
def __init__(self, mainMenuState, cameraActive):
# Just try and destroy a menu if it already exists
try:
self.hideMainMenu()
except:
# If nothing exists we create the main menu
self.bk_text = "Welcome to SHENKO"
self.textObject = OnscreenText(text=self.bk_text,
pos=(0.95, -0.95),
scale=0.05,
fg=(0, 1, 1, 1),
bg=(0, 0, 0, .5),
align=TextNode.ACenter,
mayChange=1)
# Draw the Shenko LOGO
self.imageObject = OnscreenImage(image='logo.png',
pos=(0, 0, .6),
scale=0.5)
self.imageObject.setImage('logo.png')
# Menu buttons
rollSound = base.loader.loadSfx("click.ogg")
self.startbttn = DirectButton(text=("start", "---> start <---",
"--> start <--", "disabled"),
pos=(0, 0, .2),
scale=.07,
rolloverSound=rollSound,
command=self.start)
self.mainMenuState = False
print('derp', self.mainMenuState)
def hideMainMenu(self):
print("#---#### ####---#")
#DirectButton.destroy()
self.textObject.destroy() # This is the text lower right of screen
self.imageObject.destroy() # This is the Logo
self.startbttn['state'] = DGG.DISABLED
self.startbttn.destroy()
def start(self):
print("LOADING CENTRAL --------------------------_> ...")
self.hideMainMenu()
class HUD(Thing):
def __init__(self):
super(HUD, self).__init__("empty")
#initialize hud
self.textStackSize = OnscreenText(text = u"0/\u221e", pos = (-1.2, 0.9), scale = 0.07)
self.stackDepth = 0
def save(self):
self.textStackSize.destroy()
self.stackDepth += 1
self.textStackSize = OnscreenText(text = str(self.stackDepth) + u"/\u221e", pos = (-1.2, 0.9), scale = 0.07)
def revert(self):
if self.stackDepth == 0:
return
self.textStackSize.destroy()
self.stackDepth += -1
self.textStackSize = OnscreenText(text = str(self.stackDepth) + u"/\u221e", pos = (-1.2, 0.9), scale = 0.07)
class CarNetworkGui(CarGui):
def __init__(self, mediator, car_props, players):
self.car_props = car_props
CarGui.__init__(self, mediator)
for player in players:
if player.car == car_props.name:
name = player.name
break
sprops = self.car_props.race_props.season_props
menu_props = sprops.gameprops.menu_props
pars = {
'scale': .04,
'fg': menu_props.text_normal_col,
'font': self.eng.font_mgr.load_font(sprops.font)
}
if '@' in name: name = name[:name.index('@')]
self.name_txt = OnscreenText(name, **pars)
self.eng.attach_obs(self.on_frame)
@staticmethod
def __2d_pos(node):
p3d = base.cam.get_relative_point(node.node, Point3(0, 0, 0))
p2d = Point2()
return p2d if base.camLens.project(p3d, p2d) else None
def on_frame(self):
pos = self.__2d_pos(self.mediator.gfx.nodepath)
if pos:
self.name_txt.show()
self.name_txt.set_pos((pos[0], 1, pos[1] + .16))
else:
self.name_txt.hide()
def hide(self):
CarGui.hide(self)
self.name_txt.hide()
def destroy(self):
self.name_txt.destroy()
self.eng.detach_obs(self.on_frame)
CarGui.destroy(self)
class OptionsScreen:
def __init__(self, options):
self.bg = OnscreenImage(image='./image/bg.png', pos = (0.0, -1.0, 0.0), parent=render2d)
self.bg.setTransparency(TransparencyAttrib.MAlpha)
self.title = OnscreenText(text = 'Options', pos = (0.0, 0.7), scale = 0.3, font=babelfish_font, align=TextNode.ACenter, fg=(1,1,1,1))
self.option_title_txt = OnscreenText(text='Controller', scale=0.2, pos=(-1.0, 0.0), font=babelfish_font, align=TextNode.ALeft, fg=(1,1,1,1))
self.option_value = options.get('game-opts', 'controller')
self.option_value_txt = OnscreenText(text=self.option_value, scale=0.2, pos=(.7, 0.0), font=babelfish_font, align=TextNode.ACenter, fg=(1,1,1,1))
self.options = options
self.curr_controller = 0
self.controllers = ['Keyboard','Joypad', 'Mouse']
#define o controle atual baseado no arquivo salvo
for f in self.controllers:
if f == self.option_value:
break
else:
self.curr_controller += 1
def option_changed(self, command):
self.toggle_value(command)
def toggle_value(self, opt):
if opt == 'nav-right':
self.curr_controller += 1
elif opt == 'nav-left':
self.curr_controller -= 1
if (self.curr_controller >= len(self.controllers)):
self.curr_controller = 0
elif (self.curr_controller < 0):
self.curr_controller = len(self.controllers) - 1
self.option_value = self.controllers[self.curr_controller]
self.option_value_txt.destroy()
self.option_value_txt = OnscreenText(text=self.option_value, scale=0.2, pos=(.7, 0.0), font=babelfish_font, align=TextNode.ACenter, fg=(1,1,1,1))
def clear(self):
self.bg.destroy()
self.title.destroy()
self.option_title_txt.destroy()
self.option_value_txt.destroy()
self.options.set('game-opts', 'controller', self.option_value)
class OptionLabel(GuiElement):
'''
one option label in options menu
size is the size of the text and the controlNP is normally outside the box
(for a better align)
'''
#TODO: inherit this from a 'MenuElement' liked class?
def __init__(self, configForm, text , controlNP = None, controlOffset = 0.35 , size = (0.4,0.15)):
GuiElement.__init__(self, size = size)
self.text = text
self.controlNP = controlNP
self._controlOffset = controlOffset
#TODO: textNP as a button-like, commonly use in menus
self.textNP = OnscreenText(font = color_themes.default_font, text = text, scale = 0.07, fg = (1,1,1,1) )
self.textParentNP = NodePath('tpnp')
self.textParentNP.reparentTo(self)
self.textNP.reparentTo(self.textParentNP)
self.controlParentNP = NodePath('cpnp')
self.controlParentNP.setPos(self._controlOffset,0,0)
self.controlParentNP.reparentTo(self)
self.controlNP.reparentTo(self.controlParentNP)
def destroy(self):
if self.textNP:
self.textNP.destroy()
if self.controlNP:
self.controlNP.destroy()
self.textNP = None
self.controlNP = None
self.textParentNP = None
self.controlParentNP = None
GuiElement.destroy(self)
class Client(DirectObject):
def __init__(self):
DirectObject.__init__(self)
#No player yet
self.player = None
self.stars = []
tcpPort = base.config.GetInt('server-port', 4400)
hostname = base.config.GetString('server-host', '192.168.137.1')
self.url = URLSpec('http://%s:%s' % (hostname, tcpPort))
self.cr = MyClientRepository()
self.cr.connect([self.url], successCallback = self.connectSuccess, failureCallback = self.connectFailure)
self.waitingText = OnscreenText(
'Connecting to %s.\n.' % (self.url),
scale = 0.1, fg = (1, 1, 1, 1), shadow = (0, 0, 0, 1))
def connectFailure(self, statusCode, statusString):
self.waitingText.destroy()
self.failureText = OnscreenText(
'Failed to connect to %s: %s.' % (self.url, statusString),
scale = 0.15, fg = (1, 0, 0, 1), shadow = (0, 0, 0, 1))
def connectSuccess(self):
""" Successfully connected. But we still can't really do
anything until we've got the doID range. """
self.waitingText.destroy()
self.waitingText = OnscreenText('Waiting for server.',scale = 0.1, fg = (1, 1, 1, 1), shadow = (0, 0, 0, 1))
self.acceptOnce('createReady', self.createReady)
def createReady(self):
""" Now we're ready to go! """
self.waitingText.destroy()
# Manifest an avatar for ourselves.
#self.av = self.cr.createDistributedObject(className = 'DistributedPlayer')
# Update the local avatar's position every frame.
#self.moveTask = taskMgr.add(self.moveAvatar, 'moveAvatar')
# Send position updates only several times a second, instead
# of every frame, or we will flood the network.
#self.lastBroadcastTransform = self.av.getTransform()
#self.updateTask = taskMgr.doMethodLater(0.2, self.updateAvatar, 'updateAvatar')
def addStars(self, positions):
for position in positions:
star = DistributedStar(self.cr)
star.setInitialPos(position)
self.cr.createDistributedObject(distObj = star)
self.stars.append(star)
def clearStars(self):
for p in self.stars:
self.cr.sendDeleteMsg(p.doId)
class CarMultiPlayerPanel(CarPanel):
def enter_waiting(self):
CarPanel.enter_waiting(self)
if self.ncars == 1: parent = base.aspect2d
elif self.ncars == 2:
if self.player_idx == 0: parent = base.a2dCenterQuarter
else: parent = base.a2dCenterThirdQuarter
elif self.ncars == 3:
if self.player_idx == 0: parent = base.a2dQuarterCenter
elif self.player_idx == 1: parent = base.a2dThirdQuarterQuarter
else: parent = base.a2dThirdQuarterThirdQuarter
elif self.ncars == 4:
if self.player_idx == 0: parent = base.a2dQuarterQuarter
elif self.player_idx == 1: parent = base.a2dQuarterThirdQuarter
elif self.player_idx == 2: parent = base.a2dThirdQuarterQuarter
else: parent = base.a2dThirdQuarterThirdQuarter
menu_props = \
self.car_props.race_props.season_props.gameprops.menu_props
pars = {
'scale':
.065,
'parent':
parent,
'fg':
menu_props.text_normal_col,
'font':
self.eng.font_mgr.load_font(
self.car_props.race_props.season_props.font)
}
self.wait_lab = OnscreenText(_('waiting for the other players'),
pos=(0, 0),
**pars)
def exit_waiting(self):
CarPanel.exit_waiting(self)
self.wait_lab.destroy()
class cApplication( DirectObject ):
def __init__( self ):
# create world
self.world = cWorld( )
# setup controls
self.setupControls( )
# display title information
self.title = OnscreenText( text = 'BOIDS.PY - SEEK & ARRIVE', fg = ( 1.0, 1.0, 1.0, 1.0), pos = ( -.98, .9 ), scale = 0.06 )
# display copright information
self.copyRight = OnscreenText( text = 'Copyright (C) 2016 David Lettier.', fg = ( 1.0, 1.0, 1.0, 1.0), pos = ( .98, -.98 ), scale = 0.05 )
# display panda version text
self.pandaVersion = OnscreenText( text = 'Panda Version 1.9.2', fg = ( 1.0, 1.0, 1.0, 1.0), pos = ( -1.18, -.98 ), scale = 0.04 )
# display print debug button
# this button calls the prntDebug function
self.prntDebugButton = DirectButton( text = "Print Debug", relief = DGG.RAISED, scale = .1, pad = ( .5, .5 ), pos = Vec3( -1.0, 0.0, -.8 ), command = self.prntDebug )
def setupControls( self ):
# accept the esc key to exit application
self.accept( 'escape', sys.exit )
def prntDebug( self ):
# destory debug button
self.prntDebugButton.destroy( )
# create new clear debug button
# this button calls the clearDebug function
self.clearDebugButton = DirectButton( text = "Clear Debug", relief = DGG.RAISED, scale = .1, pad = ( .5, .5 ), pos = Vec3( -1.0, 0.0, -.8 ), command = self.clearDebug )
# create green target position text
self.greenPos = OnscreenText( text = 'Green Target Pos: ' + str( int( self.world.target.getX( ) ) ) + ", " + str( int( self.world.target.getY( ) ) ) + ", " + str( int( self.world.target.getZ( ) ) ), fg = ( 1.0, 1.0, 1.0, 1.0), pos = ( -.8, .8 ), scale = 0.05, mayChange = True )
# create blue boid position text
self.bluePos = OnscreenText( text = 'Blue Boid (Arrive) Pos: ' + str( int( self.world.blueBoid.boidModel.getX( ) ) ) + ", " + str( int( self.world.blueBoid.boidModel.getY( ) ) ) + ", " + str( int( self.world.blueBoid.boidModel.getZ( ) ) ), fg = ( 1.0, 1.0, 1.0, 1.0), pos = ( -.8, .7 ), scale = 0.05, mayChange = True )
# create green boid position text
self.redPos = OnscreenText( text = 'Red Boid (Seek) Pos: ' + str( int( self.world.redBoid.boidModel.getX( ) ) ) + ", " + str( int( self.world.redBoid.boidModel.getY( ) ) ) + ", " + str( int( self.world.redBoid.boidModel.getZ( ) ) ), fg = ( 1.0, 1.0, 1.0, 1.0), pos = ( -.8, .6 ), scale = 0.05, mayChange = True )
# add the update on screen text task
taskMgr.add( self.updateOSTxt, 'updateOSTxt' )
def updateOSTxt( self, Task ):
# update green target position text
self.greenPos.setText( 'Green Target Pos: ' + str( int( self.world.target.getX( ) ) ) + ", " + str( int( self.world.target.getY( ) ) ) + ", " + str( int( self.world.target.getZ( ) ) ) )
# update blue boid position text
self.bluePos.setText( 'Blue Boid (Arrive) Pos: ' + str( int( self.world.blueBoid.boidModel.getX( ) ) ) + ", " + str( int( self.world.blueBoid.boidModel.getY( ) ) ) + ", " + str( int( self.world.blueBoid.boidModel.getZ( ) ) ) )
# update red boid position text
self.redPos.setText( 'Red Boid (Seek) Pos: ' + str( int( self.world.redBoid.boidModel.getX( ) ) ) + ", " + str( int( self.world.redBoid.boidModel.getY( ) ) ) + ", " + str( int( self.world.redBoid.boidModel.getZ( ) ) ) )
# call task next frame
return Task.cont
def clearDebug( self ):
# destory button
self.clearDebugButton.destroy( )
# destory all debug on screen text
self.greenPos.destroy( )
self.bluePos.destroy( )
self.redPos.destroy( )
# remove task
taskMgr.remove( 'updateOSTxt' )
# create again the print debug button to start the cycle all over again
self.prntDebugButton = DirectButton( text = "Print Debug", relief = DGG.RAISED, scale = .1, pad = ( .5, .5 ), pos = Vec3( -1.0, 0.0, -.8 ), command = self.prntDebug )
class DeveloperConsole(InteractiveInterpreter, DirectObject):
"""The name says it all."""
def __init__(self):
sys.stdout = PseudoFile(self.writeOut)
sys.stderr = PseudoFile(self.writeErr)
tpErr = TextProperties()
tpErr.setTextColor(1, 0.5, 0.5, 1)
TextPropertiesManager.getGlobalPtr().setProperties("err", tpErr)
#font = loader.loadFont("cmss12")
self.frame = DirectFrame(parent = base.a2dTopCenter, text_align = TextNode.ALeft, text_pos = (-base.getAspectRatio() + TEXT_MARGIN[0], TEXT_MARGIN[1]), text_scale = 0.05, text_fg = (1, 1, 1, 1), frameSize = (-2.0, 2.0, -0.5, 0.0), frameColor = (0, 0, 0, 0.5), text = '')#, text_font = font)
self.entry = DirectEntry(parent = base.a2dTopLeft, command = self.command, scale = 0.05, width = 1000.0, pos = (-0.02, 0, -0.48), relief = None, text_pos = (1.5, 0, 0), text_fg = (1, 1, 0.5, 1), rolloverSound = None, clickSound = None)#, text_font = font)
self.otext = OnscreenText(parent = self.entry, scale = 1, align = TextNode.ALeft, pos = (1, 0, 0), fg = (1, 1, 0.5, 1), text = ':')#, font = font)
self.lines = [''] * 9
self.commands = [] # All previously sent commands
self.cscroll = None # Index of currently navigated command, None if current
self.command = '' # Currently entered command
self.block = '' # Temporarily stores a block of commands
self.hide()
self.initialized = False
def prevCommand(self):
if self.hidden: return
if len(self.commands) == 0: return
if self.cscroll == None:
self.cscroll = len(self.commands)
self.command = self.entry.get()
elif self.cscroll <= 0:
return
else:
self.commands[self.cscroll] = self.entry.get()
self.cscroll -= 1
self.entry.set(self.commands[self.cscroll])
self.entry.setCursorPosition(len(self.commands[self.cscroll]))
def nextCommand(self):
if self.hidden: return
if len(self.commands) == 0: return
if self.cscroll == None: return
self.commands[self.cscroll] = self.entry.get()
self.cscroll += 1
if self.cscroll >= len(self.commands):
self.cscroll = None
self.entry.set(self.command)
self.entry.setCursorPosition(len(self.command))
else:
self.entry.set(self.commands[self.cscroll])
self.entry.setCursorPosition(len(self.commands[self.cscroll]))
def writeOut(self, line, copy = True):
if copy: sys.__stdout__.write(line)
lines = line.split('\n')
firstline = lines.pop(0)
self.lines[-1] += firstline
self.lines += lines
self.frame['text'] = '\n'.join(self.lines[-9:])
def writeErr(self, line, copy = True):
if copy: sys.__stderr__.write(line)
line = '\1err\1%s\2' % line
lines = line.split('\n')
firstline = lines.pop(0)
self.lines[-1] += firstline
self.lines += lines
self.frame['text'] = '\n'.join(self.lines[-9:])
def command(self, text):
if not self.hidden:
self.cscroll = None
self.command = ''
self.entry.set('')
self.entry['focus'] = True
self.writeOut(self.otext['text'] + ' ' + text + '\n', False)
if text != '' and (len(self.commands) == 0 or self.commands[-1] != text):
self.commands.append(text)
# Insert plugins into the local namespace
locals = __main__.__dict__
#locals['manager'] = self.manager
#for plugin in self.manager.named.keys():
# locals[plugin] = self.manager.named[plugin]
locals['panda3d'] = panda3d
# Run it and print the output.
if not self.initialized:
InteractiveInterpreter.__init__(self, locals = locals)
self.initialized = True
try:
if self.runsource(self.block + '\n' + text) and text != '':
self.otext['text'] = '.'
self.block += '\n' + text
else:
self.otext['text'] = ':'
self.block = ''
except Exception: # Not just "except", it will also catch SystemExit
# Whoops! Print out a traceback.
self.writeErr(traceback.format_exc())
def toggle(self):
if self.hidden:
self.show()
else:
self.hide()
def show(self):
self.accept('arrow_up', self.prevCommand)
self.accept('arrow_up-repeat', self.prevCommand)
self.accept('arrow_down', self.nextCommand)
self.accept('arrow_down-repeat', self.nextCommand)
self.hidden = False
self.entry['focus'] = True
self.frame.show()
self.entry.show()
self.otext.show()
def hide(self):
self.ignoreAll()
self.hidden = True
self.entry['focus'] = False
self.frame.hide()
self.entry.hide()
self.otext.hide()
def destroy(self):
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
self.ignoreAll()
self.frame.destroy()
self.entry.destroy()
self.otext.destroy()
class World(DirectObject):
#class World, extends DirectObject, builds the world to play the game
###################### INITIALIZATIONS #########################################
def __init__(self):
mySplashScreen = SplashScreen()
mySplashScreen.loading()
mySplashScreen.introduction()
self.promptMode()
self.turnWallNotification()
##### Creating Scene #####
self.createBackground()
self.loadWallModel()
self.loadBallModel()
self.setCamera()
self.createLighting()
##### Create Controls #####
self.createKeyControls()
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0, "drop":0}
##### Task Manager #####
timer = 0.2
taskMgr.doMethodLater(timer, self.traverseTask, "tsk_traverse")
#scans for collisions every 0.2 seconds
taskMgr.add(self.move,"moveTask")
#constant smooth movement
##### Collisions #####
self.createBallColliderModel()
self.disableForwardMovement = False
self.disableBackwardMovement = False
self.disableLeftMovement = False
self.disableRightMovement = False
##### Game state variables #####
self.isMoving = False
self.isDropping = False
self.camAngle = math.pi/2
self.direction = "W" #constant; does not change with relativity
self.drop = False
self.levelHeight = 2.1
self.level = 0
self.maxLevel = 6
self.currentHeight = 13.302
self.cameraHeight = 0.2
self.mode = None
self.timer = ""
##### Views #####
self.xray_mode = False
self.collision_mode = False
self.wireframe = False
##### On-Screen Text #####
self.title = addTitle("aMAZEing")
self.instructions = OnscreenText(text="[ i ]: Toggle Instructions",
style=1, fg=(0, 0, 0, 1), pos=(1.3, 0.95),
align=TextNode.ARight, scale=0.05)
self.instr = []
self.messages = []
self.levelText = OnscreenText(text= "Level = " + str(self.level),
style=1, fg=(0, 0, 0, 1), pos=(-1.3, -0.95),
align=TextNode.ALeft, scale=0.07)
self.directionText = OnscreenText(text="Direction = " + self.direction,
style=1, fg=(0, 0, 0, 1), pos=(-1.3, -0.85),
align=TextNode.ALeft, scale=0.07)
self.timerText = OnscreenText(text= self.timer,
style=1, fg=(1, 1, 1, 1), pos=(1.3, 0.85),
align=TextNode.ARight, scale=0.07)
def setKey(self, key, value):
#records the state of the arrow keys
self.keyMap[key] = value
###################### Onscreen Text #######################################
def postInstructions(self):
#posts the instructions onto the screen
inst1 = addInstructions(0.95, "[ESC]: Quit")
self.instr.append(inst1)
inst2 = addInstructions(0.90, "[Left Arrow]: Turn Left")
self.instr.append(inst2)
inst3 = addInstructions(0.85, "[Right Arrow]: Turn Right")
self.instr.append(inst3)
inst4 = addInstructions(0.80, "[Up Arrow]: Move Ball Forward")
self.instr.append(inst4)
inst5 = addInstructions(0.75, "[Down Arrow]: Move Ball Backwards")
self.instr.append(inst5)
inst6 = addInstructions(0.70,
"[Space]: Drop Levels (if level drop is availale)")
self.instr.append(inst6)
inst7 = addInstructions(0.60, "[x]: Toggle XRay Mode")
self.instr.append(inst7)
inst8 = addInstructions(0.55, "[c]: Toggle Collision Mode")
self.instr.append(inst8)
inst9 = addInstructions(0.50, "[z]: Toggle Wireframe")
self.instr.append(inst9)
inst10 = OnscreenText(text='''Hello!
Welcome to aMAZEing!
You are this sphere,
and your goal is to find the exit of the maze! Each level
of the maze has a hole you can drop through, to move on to the
next level. This maze has six levels and each maze is a 12x12.
If you chose timer mode, you have 5 minutes to finish the maze,
or else you lose.
Good luck! You're aMAZEing :)''', style = 1,
fg=(0, 0, 0, 1), pos=(0, -.1), align=TextNode.ACenter, scale=0.07)
self.instr.append(inst10)
def deleteInstructions(self):
#deletes onscreen instructions
for instr in self.instr:
instr.destroy()
def addNotification(self, txt):
#adds a notification to the screen
y = 0.9
tex = OnscreenText(text=txt, style=1, fg= (0, 0, 0, 1), pos=(0, y))
self.messages.append(tex)
def deleteNotifications(self):
#deletes all on-screen notifications
for msg in self.messages:
msg.destroy()
def updateLevelText(self):
#updates the level text
self.levelText.destroy()
levelTextPos = (-1.3, -0.95)
levelScale = 0.07
self.levelText = OnscreenText(text= "Level = " + str(self.level),
style=1, fg=(0, 0, 0, 1), pos=levelTextPos,
align=TextNode.ALeft, scale=levelScale)
def updateDirectionText(self):
#updates the direction text on the screen
self.directionText.destroy()
directionTextPos = (-1.3, -0.85)
directionScale = 0.07
self.directionText = OnscreenText(text="Direction = " + self.direction,
style=1, fg=(0, 0, 0, 1), pos=directionTextPos,
align=TextNode.ALeft, scale=directionScale)
def updateTimerText(self):
#updates timer on screen
self.timerText.destroy()
timerTextPos = (1.3, 0.85)
timerScale = 0.07
if self.mode == "timer":
self.timerText = OnscreenText(text= self.timer,
style=1, fg=(1, 1, 1, 1), pos=timerTextPos,
align=TextNode.ARight, scale=timerScale)
def turnWallNotification(self):
#give a notification sequence at the beginning
notificationSeq = Sequence()
notificationSeq.append(Func(addNotification,"""
If you just see a blank color,
it means you are facing a wall :)"""))
notificationSeq.append(Wait(8))
notificationSeq.append(Func(deleteNotifications))
notificationSeq.start()
def promptMode(self):
#prompts for the mode
modeScreen = SplashScreen()
modeScreen.mode()
def setMode(self, mode):
#sets the mode of the game
self.mode = mode
if self.mode == "timer":
self.setTimer()
###################### Initialization Helper Functions #####################
def createBackground(self):
#black feautureless space
base.win.setClearColor(Vec4(0,0,0,1))
def loadWallModel(self):
#loads the wall model (the maze)
wallScale = 0.3
wallModelName = self.randomWallModel()
#randomly select a maze
self.wallModel = loader.loadModel(wallModelName)
self.wallModel.setScale(wallScale)
self.wallModel.setPos(0, 0, 0)
self.wallModel.setCollideMask(BitMask32.allOff())
self.wallModel.reparentTo(render)
### Setting Texture ###
texScale = 0.08
self.wallModel.setTexGen(TextureStage.getDefault(),
TexGenAttrib.MWorldNormal)
self.wallModel.setTexProjector(TextureStage.getDefault(),
render, self.wallModel)
self.wallModel.setTexScale(TextureStage.getDefault(), texScale)
tex = loader.load3DTexture('/Users/jianwei/Documents/School/Freshman/Semester1/15-112/TERMPROJECT/Project/wallTex/wallTex_#.png')
self.wallModel.setTexture(tex)
#creating visual geometry collision
self.wallModel.setCollideMask(BitMask32.bit(0))
def randomWallModel(self):
#generates a random wall in the library of mazes that were
#randomly generated by the Blender script "mazeGenerator"
#and exported to this computer
numMazes = 10
name = str(random.randint(0, numMazes))
#randomly selects a number saved in the computer
path = "/Users/jianwei/Documents/School/Freshman/Semester1/15-112/TERMPROJECT/Project/mazeModels/maze"
path += name
return path
def loadBallModel(self):
#loads the character, a ball model
#ballModelStartPos = (-8, -8, 0.701) #THIS IS THE END
ballModelStartPos = (8, 8, 13.301) #level 0
ballScale = 0.01
self.ballModel = loader.loadModel("/Users/jianwei/Documents/School/Freshman/Semester1/15-112/TERMPROJECT/Project/ball")
self.ballModel.reparentTo(render)
self.ballModel.setScale(ballScale)
self.ballModel.setPos(ballModelStartPos)
### Setting ball texture ###
texScale = 0.08
self.ballModel.setTexGen(TextureStage.getDefault(),
TexGenAttrib.MWorldPosition)
self.ballModel.setTexProjector(TextureStage.getDefault(),
render, self.ballModel)
self.ballModel.setTexScale(TextureStage.getDefault(), texScale)
tex = loader.load3DTexture('/Users/jianwei/Documents/School/Freshman/Semester1/15-112/TERMPROJECT/Project/ballTex/ballTex_#.png')
self.ballModel.setTexture(tex)
def setCamera(self):
#sets up the initial camera location
#camera will follow the sphere
followLength = 2
camHeight = 0.2
base.disableMouse()
base.camera.setPos(self.ballModel.getX(),
self.ballModel.getY() - followLength,
self.ballModel.getZ() + camHeight)
base.camLens.setNear(0.4)
#creates a floater object - will look at the floater object
#above the sphere, so you can get a better view
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
def createKeyControls(self):
#creates the controllers for the keys
#event handler
#describes what each key does when pressed and unpressed
self.accept("escape", sys.exit)
self.accept("arrow_left", self.turnLeft)
self.accept("arrow_right", self.turnRight)
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("arrow_down", self.setKey, ["backward",1])
self.accept("space", self.nowDropping)
#unpressed event handlers
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("arrow_down-up", self.setKey, ["backward",0])
self.accept("space_up", self.setKey, ["drop", 0])
#views
self.accept('x', self.toggle_xray_mode)
self.accept('c', self.toggle_collision_mode)
self.accept('z', self.toggle_wireframe)
#information
self.accept('i', self.postInstructions)
self.accept('i-up', self.deleteInstructions)
#restart
self.accept('r', self.restart)
#modes
self.accept("t", self.setMode, ["timer"])
self.accept("m", self.setMode, ["marathon"])
def createBallColliderModel(self):
#creates the collider sphere around the ball
cSphereRad = 9.9
self.cTrav = CollisionTraverser() #moves over all possible collisions
self.ballModelSphere = CollisionSphere(0, 0, 0, cSphereRad)
#collision mesh around ball is a simple sphere
self.ballModelCol = CollisionNode('ballModelSphere')
self.ballModelCol.addSolid(self.ballModelSphere)
self.ballModelCol.setFromCollideMask(BitMask32.bit(0))
self.ballModelCol.setIntoCollideMask(BitMask32.allOff())
self.ballModelColNp = self.ballModel.attachNewNode(self.ballModelCol)
self.ballModelGroundHandler = CollisionHandlerQueue()
#collision handler queue stores all collision points
self.cTrav.addCollider(self.ballModelColNp, self.ballModelGroundHandler)
def createLighting(self):
#creates lighting for the scene
aLightVal = 0.3
dLightVal1 = -5
dLightVal2 = 5
#set up the ambient light
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1))
ambientLight1 = AmbientLight("ambientLight1")
ambientLight1.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1))
ambientLight2 = AmbientLight("ambientLight2")
ambientLight2.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1))
#sets a directional light
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(dLightVal1, dLightVal1, dLightVal1))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(0, 0, 0, 1))
#sets a directional light
directionalLight1 = DirectionalLight("directionalLight2")
directionalLight1.setDirection(Vec3(dLightVal2, dLightVal1, dLightVal1))
directionalLight1.setColor(Vec4(1, 1, 1, 1))
directionalLight1.setSpecularColor(Vec4(1, 1, 1, 1))
#attaches lights to scene
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(ambientLight1))
render.setLight(render.attachNewNode(ambientLight1))
render.setLight(render.attachNewNode(directionalLight))
render.setLight(render.attachNewNode(directionalLight1))
###################### COLLISION DETECTION #####################################
def traverseTask(self, task=None):
# handles collisions with collision handers and a
# collision queue
# essentially checks region of potential collision for collisions
# and stops the ball if a collision is triggered
# called by task manager
self.ballModelGroundHandler.sortEntries()
for i in range(self.ballModelGroundHandler.getNumEntries()):
entry = self.ballModelGroundHandler.getEntry(i)
if self.drop == True:
#we cant drop in this situation
self.ballModel.setZ(self.currentHeight)
dropFailWait = 4
dropFailSeq = Sequence()
dropFailSeq.append(Func(addNotification,"Whoops! You can't drop here!"))
dropFailSeq.append(Wait(dropFailWait))
dropFailSeq.append(Func(deleteNotifications))
dropFailSeq.start()
self.drop = False
elif self.direction == "N":
self.northDisableMovements()
elif self.direction == "S":
self.southDisableMovements()
elif self.direction == "E":
self.eastDisableMovements()
elif self.direction == "W":
self.westDisableMovements()
if task: return task.cont #exit task
# If there are no collisions
if task: return task.cont
def northDisableMovements(self):
#disables movements when direction is north
if self.keyMap["forward"] != 0: #if the ball was moving foward
self.disableForwardMovement = True #disable forward movement
if self.keyMap["backward"] != 0:
self.disableBackwardMovement = True
def southDisableMovements(self):
#disables movements when direction is south
if self.keyMap["forward"] != 0:
self.disableBackwardMovement = True
if self.keyMap["backward"] != 0:
self.disableForwardMovement = True
def eastDisableMovements(self):
#disables movements when direction is east
if self.keyMap["forward"] != 0:
self.disableRightMovement = True
if self.keyMap["backward"] != 0:
self.disableLeftMovement = True
def westDisableMovements(self):
#disables movements when direction is west
if self.keyMap["forward"] != 0:
self.disableLeftMovement = True
if self.keyMap["backward"] != 0:
self.disableRightMovement = True
def checkCollisions(self):
#checks for collisions
self.cTrav.traverse(render)
def enableAllWalls(self):
#enables all walls by disabling all the disable wall functions
self.disableLeftMovement = False
self.disableRightMovement = False
self.disableForwardMovement = False
self.disableBackwardMovement = False
def inCollision(self):
#return true if we are in a collision right now, false otherwise
if (self.disableForwardMovement == True
or self.disableBackwardMovement == True
or self.disableRightMovement == True
or self.disableLeftMovement):
return True
return False
def checkForWin(self):
#checks for a win, toggles win splash sceen if we win
yLoc = self.ballModel.getY()
exitBound = -9.1
if yLoc < exitBound:
winScreen = SplashScreen()
winScreen.win()
if self.mode == "timer":
self.checkForTimerLoss()
def checkForTimerLoss(self):
#checks to see the time, will lose if past 5 minutes
if self.timer == "0:05:00":
loseScreen = SplashScreen()
loseScreen.lose()
###################### MOVEMENTS ###############################################
def move(self, task):
# Accepts arrow keys to move the player front and back
# Also deals with grid checking and collision detection
step = 0.03
#movement animation
self.movementAnimation(step)
#rotation animation
self.rotationAnimation()
base.camera.setX(self.ballModel.getX() + math.sin(self.camAngle))
base.camera.setY(self.ballModel.getY() + math.cos(self.camAngle))
self.resetCamDist()
self.checkCollisions()
self.lookAtFloater()
self.checkForWin()
return task.cont
def resetCamDist(self):
#resets the camera distance to a specific distance
#keeps distance relatively constant
camFarDist = 0.75
camCloseDist = 0.7
camvec = self.ballModel.getPos() - base.camera.getPos()
#vector between ball and camera
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if (camdist > camFarDist):
base.camera.setPos(base.camera.getPos() +
camvec*(camdist-camFarDist))
camdist = camFarDist
if (camdist < camCloseDist):
base.camera.setPos(base.camera.getPos() -
camvec*(camCloseDist-camdist))
camdist = camCloseDist
base.camera.lookAt(self.ballModel)
def lookAtFloater(self):
#looks at the floater above the sphere
floaterHeight = 0.23
self.floater.setPos(self.ballModel.getPos())
self.floater.setZ(self.ballModel.getZ() + floaterHeight)
base.camera.lookAt(self.floater)
####################### Movement Animation #################################
def ballIsMoving(self):
#notes if the ball is moving or not with self.isMoving variable
if (self.keyMap["forward"]!=0) or (self.keyMap["backward"]!=0):
if self.isMoving == False:
self.isMoving = True
elif self.keyMap["forward"] == 0 and self.keyMap["backward"] == 0:
self.isMoving = False
def movementAnimation(self, step):
#describes the movement animation
if self.drop == True:
self.dropMovementAnimation(step)
elif self.direction == "N":
self.northMovementAnimation(step)
elif self.direction == "S":
self.southMovementAnimation(step)
elif self.direction == "E":
self.eastMovementAnimation(step)
elif self.direction == "W":
self.westMovementAnimation(step)
def northMovementAnimation(self, step):
#describes animation when direction is north
if (self.keyMap["forward"]!=0):
#if you are pressing forward
if self.disableForwardMovement == False:
#if you are just moving through space...
self.ballModel.setY(self.ballModel.getY() + step)
if self.disableBackwardMovement == True:
#if you had moved backwards into a wall
#and you want to move forward again
self.ballModel.setY(self.ballModel.getY() + step)
self.disableBackwardMovement = False
if (self.keyMap["backward"]!=0):
#if you are pressing backwards
if self.disableBackwardMovement == False:
#if you are just moving backwards through space...
self.ballModel.setY(self.ballModel.getY() - step)
if self.disableForwardMovement == True:
#if you had moved forward into a wall
#and want to back away from the wall
self.ballModel.setY(self.ballModel.getY() - step)
self.disableForwardMovement = False
def southMovementAnimation(self, step):
#describes animation when direction is north
#same relative set of animations to northMovementAnimation
#but opposite
if (self.keyMap["forward"]!=0):
if self.disableBackwardMovement == False:
self.ballModel.setY(self.ballModel.getY() - step)
if self.disableForwardMovement == True:
self.ballModel.setY(self.ballModel.getY() - step)
self.disableForwardMovement = False
if (self.keyMap["backward"]!=0):
if self.disableForwardMovement == False:
self.ballModel.setY(self.ballModel.getY() + step)
if self.disableBackwardMovement == True:
self.ballModel.setY(self.ballModel.getY() + step)
self.disableBackwardMovement = False
def eastMovementAnimation(self, step):
#describes animation when direction is east
#same relative as north and south movement animations
#but relative to the x axis
#and disabling/enabling right and left movement at collisions
if (self.keyMap["forward"]!=0):
if self.disableRightMovement == False:
self.ballModel.setX(self.ballModel.getX() + step)
if self.disableLeftMovement == True:
self.ballModel.setX(self.ballModel.getX() + step)
self.disableLeftMovement = False
if (self.keyMap["backward"]!=0):
if self.disableLeftMovement == False:
self.ballModel.setX(self.ballModel.getX() - step)
if self.disableRightMovement == True:
self.ballModel.setX(self.ballModel.getX() - step)
self.disableRightMovement = False
def westMovementAnimation(self, step):
#describes animation when direction is west
#relatively same animations as the east movement animations
#exact opposite
if (self.keyMap["forward"]!=0):
if self.disableLeftMovement == False:
self.ballModel.setX(self.ballModel.getX() - step)
if self.disableRightMovement == True:
self.ballModel.setX(self.ballModel.getX() - step)
self.disableRightMovement = False
if (self.keyMap["backward"]!=0):
if self.disableRightMovement == False:
self.ballModel.setX(self.ballModel.getX() + step)
if self.disableLeftMovement == True:
self.ballModel.setX(self.ballModel.getX() + step)
self.disableLeftMovement = False
def turnRight(self):
#turns right in the animation
#uses an interval to slowly rotate camera around
initial = self.camAngle
final = self.camAngle + math.pi/2
#turn animation
turnTime = 0.2
turnRightSeq = Sequence()
turnRightSeq.append(LerpFunc(self.changeCamAngle, turnTime, initial,
final, 'easeInOut'))
turnRightSeq.start()
self.setKey("right", 1) #notes that the right key is pressed
#changes the direction right, based on current direction
if self.direction == "N":
self.direction = "E"
elif self.direction == "E":
self.direction = "S"
elif self.direction == "S":
self.direction = "W"
else:
self.direction = "N"
#when you turn, all the collision disablements should be True
#just checking
#self.enableAllWalls()
#update the label
self.updateDirectionText()
def turnLeft(self):
#turns left
initial = self.camAngle
final = self.camAngle - math.pi/2
#turn animation
turnTime = 0.2
turnRightSeq = Sequence()
turnRightSeq.append(LerpFunc(self.changeCamAngle, turnTime, initial,
final, 'easeInOut'))
turnRightSeq.start()
self.setKey("left", 1) #notes that left key is pressed
#changes the direction left, based on current direction
if self.direction == "N":
self.direction = "W"
elif self.direction == "W":
self.direction = "S"
elif self.direction == "S":
self.direction = "E"
else:
self.direction = "N"
#when you turn, all the collision disablements should be True
#just checking
#self.enableAllWalls()
#update the label
self.updateDirectionText()
def changeCamAngle(self, angle):
#changes the camAngle to angle
self.camAngle = angle
def dropMovementAnimation(self, step):
#describes movement when drop is hit
a = 0.1
if self.keyMap["drop"] != 0:
if self.ballModel.getZ() > self.currentHeight - self.levelHeight+ a:
self.ballModel.setZ(self.ballModel.getZ() - step)
else:
self.currentHeight -= self.levelHeight
self.level += 1
self.updateLevelText()
self.drop = False
base.camera.setZ(self.ballModel.getZ() + self.cameraHeight)
def nowDropping(self):
#toggles isDropping boolean
self.drop = True
self.setKey("drop", 1)
################## Ball Rotation Animation #################################
def rotationAnimation(self):
#describes the rotation movement of sphere
self.ballIsMoving()
speed=300
inCollision = self.inCollision()
if self.isMoving and not inCollision:
if self.direction == "N":
self.northRotationAnimation(speed)
if self.direction == "S":
self.southRotationAnimation(speed)
if self.direction == "E":
self.eastRotationAnimation(speed)
if self.direction == "W":
self.westRotationAnimation(speed)
def northRotationAnimation(self, speed):
#describes the rotation animation if direction is north
if self.keyMap["forward"] != 0:
self.ballModel.setP(self.ballModel.getP()-speed*globalClock.getDt())
elif self.keyMap["backward"] != 0:
self.ballModel.setP(self.ballModel.getP()+speed*globalClock.getDt())
def southRotationAnimation(self, speed):
#describes the rotaiton animation if the direction is south
if self.keyMap["backward"] != 0:
self.ballModel.setP(self.ballModel.getP()-speed*globalClock.getDt())
elif self.keyMap["forward"] != 0:
self.ballModel.setP(self.ballModel.getP()+speed*globalClock.getDt())
def eastRotationAnimation(self, speed):
#describes the rotation animation if the direction is east
if self.keyMap["backward"] != 0:
self.ballModel.setR(self.ballModel.getR()-speed*globalClock.getDt())
elif self.keyMap["forward"] != 0:
self.ballModel.setR(self.ballModel.getR()+speed*globalClock.getDt())
def westRotationAnimation(self, speed):
#describes the rotation animation if the direction is west
if self.keyMap["forward"] != 0:
self.ballModel.setR(self.ballModel.getR()-speed*globalClock.getDt())
elif self.keyMap["backward"] != 0:
self.ballModel.setR(self.ballModel.getR()+speed*globalClock.getDt())
###################### VIEWS ###################################################
def toggle_xray_mode(self):
#Toggle X-ray mode on and off.
#Note: slows down program considerably
xRayA = 0.5
self.xray_mode = not self.xray_mode
if self.xray_mode:
self.wallModel.setColorScale((1, 1, 1, xRayA))
self.wallModel.setTransparency(TransparencyAttrib.MDual)
else:
self.wallModel.setColorScaleOff()
self.wallModel.setTransparency(TransparencyAttrib.MNone)
def toggle_collision_mode(self):
#Toggle collision mode on and off
#Shows visual representation of the collisions occuring
self.collision_mode = not self.collision_mode
if self.collision_mode == True:
# Note: Slows the program down considerably
self.cTrav.showCollisions(render)
else:
self.cTrav.hideCollisions()
def toggle_wireframe(self):
#toggles wireframe view
self.wireframe = not self.wireframe
if self.wireframe:
self.wallModel.setRenderModeWireframe()
else:
self.wallModel.setRenderModeFilled()
##################### RESTART ##################################################
def restart(self):
#restarts the game
loading = SplashScreen()
loading.loading()
self.reset()
def reset(self):
#resets the maze, resets the location of the character
#removes all notes
self.wallModel.removeNode()
self.ballModel.removeNode()
#resets notes
self.loadWallModel()
self.loadBallModel()
self.createBallColliderModel()
self.resetCamDist()
#resets timers
taskMgr.remove("timerTask")
self.timer = ""
self.timerText.destroy()
self.promptMode()
#################### TIMER #####################################################
def setTimer(self):
#code from panda.egg user on Panda3D,
#"How to use Timer, a small example maybe?" forum
#creates a timer
self.timer = DirectLabel(pos=Vec3(1, 0.85),scale=0.08)
taskMgr.add(self.timerTask, "timerTask")
def dCharstr(self, theString):
#code from panda.egg user on Panda3D,
#"How to use Timer, a small example maybe?" forum
#turns time string into a readable clock string
if len(theString) != 2:
theString = '0' + theString
return theString
def timerTask(self, task):
#code from panda.egg user on Panda3D,
#"How to use Timer, a small example maybe?" forum
#task for resetting timer in timer mode
secondsTime = int(task.time)
minutesTime = int(secondsTime/60)
hoursTime = int(minutesTime/60)
self.timer = (str(hoursTime) + ':'
+ self.dCharstr(str(minutesTime%60)) + ':'
+ self.dCharstr(str(secondsTime%60)))
self.updateTimerText()
return Task.cont
class Dialog:
def __init__(self, menuGraphics, fonts, menu, menuButton):
self.menuGraphics = menuGraphics
self.menuButton = menuButton
self.fonts = fonts
self.self = self
self.menu = menu
self.links = {}
links = open('links.txt', 'r')
for line in links:
(key, val) = line.split()
self.links[key] = val
self.keys = self.links.keys()
self.pressed = False
def initMenu(self, args):
type = args[0]
if(args[1] != None):
self.title = args[1]
else:
self.title = None
self.items = args[2]
self.buttons = []
if(type == 3):
self.frame = DirectFrame(
geom = self.menuGraphics.find("**/menu3"),
relief = None, scale = (1.5,1,1.5),
frameColor = (1,1,1,.75), parent = base.aspect2d)
framePadding = .1
height = self.frame.getHeight()/2 - framePadding
self.title = DirectLabel(text = self.title,
text_font = self.fonts["times"], text_fg = (1,1,1,.75),
relief = None, text_align = TextNode.ACenter,
text_scale = .05, parent = self.frame,
pos = (-.025,0,height+0.05))
if self.title["text"].startswith('Screen'):
if self.menu.world.startOptions.has_key(self.title["text"]):
self.active = [self.menu.world.startOptions[self.title["text"]]]
else:
self.active = [0]
for N in range(len(self.items)):
xPos = -.3
zPos = -(height / (2)) * N + 0.1
if len(self.buttons)>=5:
xPos = 0.15
zPos = self.buttons[N-5]["pos"][2]
self.buttons.append(DirectRadioButton(
variable = self.active, value = [N], scale = 0.045,
text = self.keys[N], text_font = self.fonts["times"],
boxPlacement = 'left',
text_fg = (1,1,1,.75),
text_pos=(0,0),
text_align = TextNode.ALeft,
relief = None,
clickSound = None,
#rolloverSound = None,
parent = self.frame,
pos = (xPos, 0, zPos)))
for button in self.buttons:
button.setOthers(self.buttons)
b = DirectButton(
command = self.loadWebView,
text = "OK",
text_font = self.fonts["blue"],
text_fg = (1,1,1,1),
text_scale=(0.04,0.04),
text_pos=(0,-0.01),
text_align = TextNode.ACenter,
geom = (self.menuButton.find("**/normal"),
self.menuButton.find("**/clicked"),
self.menuButton.find("**/hoover")),
geom_scale = (1,1,1.5),
relief = None, clickSound = None,
rolloverSound = None, parent = self.frame,
pos = (0, 0, -.16))
else:
self.help = OnscreenText(text = 'f1 - URL reload\
\nf2 - Zoom in on display\
\nf3 - Toggle menu\
\narrow keys - Navigation',
font = self.fonts["times"],
fg = (1,1,1,.75),
pos = (-0.37, 0.09),
scale = 0.045,
align = TextNode.ALeft,
parent = self.frame)
self.close = DirectButton(
command = self.destroyHelp,
text = "Close",
text_font = self.fonts["blue"],
text_fg = (1,1,1,1),
text_scale=(0.04,0.04),
text_pos=(0,-0.01),
text_align = TextNode.ACenter,
geom = (self.menuButton.find("**/normal"),
self.menuButton.find("**/clicked"),
self.menuButton.find("**/hoover")),
geom_scale = (1,1,1.5),
relief = None, clickSound = None,
rolloverSound = None, parent = self.frame,
pos = (0, 0, -.16))
return
def loadWebView(self):
if self.title["text"] == "Screen 1":
key = self.buttons[self.active[0]]["text"]
self.menu.world.htmlview1.webView.loadURL(self.links[key], '', '', '')
self.menu.world.htmlview1.htmlFile = self.links[key]
elif self.title["text"] == "Screen 2":
key = self.buttons[self.active[0]]["text"]
self.menu.world.htmlview2.webView.loadURL(self.links[key], '', '', '')
self.menu.world.htmlview2.htmlFile = self.links[key]
elif self.title["text"] == "Screen 3":
key = self.buttons[self.active[0]]["text"]
self.menu.world.htmlview3.webView.loadURL(self.links[key], '', '', '')
self.menu.world.htmlview3.htmlFile = self.links[key]
elif self.title["text"] == "Screen 4":
key = self.buttons[self.active[0]]["text"]
self.menu.world.htmlview4.webView.loadURL(self.links[key], '', '', '')
self.menu.world.htmlview4.htmlFile = self.links[key]
elif self.title["text"] == "Screen 5":
key = self.buttons[self.active[0]]["text"]
self.menu.world.htmlview5.webView.loadURL(self.links[key], '', '', '')
self.menu.world.htmlview5.htmlFile = self.links[key]
self.menu.options[self.title["text"]] = self.active[0]
self.destroyScreen()
def destroyScreen(self):
for N in range(len(self.items)):
self.buttons[0].destroy()
if(self.title != None):
self.title.destroy()
self.frame.destroy()
self.self = None
return
def destroyHelp(self):
self.close.destroy()
self.help.destroy()
self.title.destroy()
self.frame.destroy()
class World(DirectObject):
mySound = base.loader.loadSfx("trial.mp3")
#Used for adding a virus at a randomly generated position
def random_vgen(self):
print 'I am in random'
for i in range(0, 5):
self.a[random.randint(0, 7)][random.randint(0, 7)] = 1
def initializer(self, level):
self.turns = 0
## Level Definition
def levelone():
self.a[4][4] = 1
self.a[4][5] = 1
self.a[4][6] = 1
self.a[5][2] = 1
self.a[3][5] = 1
self.a[4][6] = 1
self.a[5][5] = 1
def leveltwo():
self.a[4][3] = 1
self.a[4][5] = 1
self.a[4][7] = 1
self.a[5][2] = 1
self.a[3][5] = 1
self.a[2][2] = 1
self.a[5][3] = 1
self.a[1][2] = 1
def levelthree():
self.a[4][4] = 1
self.a[4][5] = 1
self.a[4][6] = 1
self.a[5][2] = 1
self.a[3][5] = 1
self.a[4][6] = 1
self.a[5][5] = 1
self.a[4][3] = 1
self.a[4][5] = 1
self.a[4][7] = 1
self.a[5][2] = 1
self.a[3][5] = 1
self.a[2][2] = 1
self.a[5][3] = 1
options = {1: levelone, 2: leveltwo, 3: levelthree}
options[level]()
print self.a
temp = []
count = 0
for element in reversed(self.a):
for ele in element:
#print 'cheking element is 1 : ' + str(ele)
if ele == 1:
temp.append(count)
self.pieces[count] = Monster(count, WHITE)
#self.squares[count].setColor(HIGHLIGHT)
count = count + 1
self.list = temp
def showscore(self):
try:
self.score.destroy()
except:
pass
self.score = OnscreenText(text='Number of Turns : %s' % (self.turns),
pos=(0.5, 0.95),
scale=0.07,
mayChange=True)
def menuscreen(self):
# Callback function to set text
def setText():
b.destroy()
helptext.destroy()
# Add button
b = DirectButton(text=("START", "START", "START", "disabled"),
scale=0.15,
command=setText,
pos=(0, 0, 0.85))
helptext = OnscreenText(text='''
STORY:
Hello Mad Scientist!
You are so close to finding the cure to aids!
You understood the behaviour and can finally manipulate the virus to kill itself!
But time is running out!
You have a red and white blood cell sample infected with AIDS Virus.
INSTRUCTIONS:
The AIDS Virus obeys the Conway's Game of Life. Who would have guessed?
1. If virus is surrounded by more than 3 viruses, it dies of suffocation
2. If virus is surrounded by less than 2 viruses, it dies of underpopulation
3. If dead empty cell, is surrounded by exactly 3 viruses, a new virus is spawned due to breeding.
AIM:
To kill all the viruses, by moving one of them every turn.
''',
pos=(-0.90, 0.72),
frame=(123, 123, 123, 1),
wordwrap=25,
align=TextNode.ALeft,
bg=(0.23, 0.243, 0.13, 0.9))
def endscreen(self):
def restart():
taskMgr.remove(self.mouseTask)
for i in range(64):
self.squares[i].setColor(SquareColor(i))
scorecard.destroy()
restartb.destroy()
end.destroy()
nextlevelb.destroy()
self.reference.destroy()
self.mySound.stop()
try:
self.score.destroy()
except:
pass
print 'restarting'
print self.a
print self.list
World()
def quitgame():
sys.exit()
def nextLevel():
self.currlevel = self.currlevel + 1
nextlevelb.destroy()
scorecard.destroy()
restartb.destroy()
end.destroy()
self.score.destroy()
self.initializer(self.currlevel)
# Add button
scorecard = OnscreenText(text='You finished it in %s turns! ' %
(self.turns),
frame=(123, 123, 123, 0),
wordwrap=25,
bg=(0.2, 0, 0.8, 1))
nextlevelb = DirectButton(text=("NEXT LEVEL", "NEXT LEVEL",
"NEXT LEVEL", "disabled"),
scale=0.15,
command=nextLevel,
pos=(0, 0, -0.15))
restartb = DirectButton(text=("RESTART", "RESTART", "RESTART",
"disabled"),
scale=0.15,
command=restart,
pos=(0, 0, -0.35))
end = DirectButton(text=("QUIT", "QUIT", "QUIT", "disabled"),
scale=0.15,
command=quitgame,
pos=(0, 0, -0.55))
if self.currlevel == self.maxlevel:
nextlevelb.destroy()
def __init__(self):
#music
self.mySound.play()
print 'I am being initialized'
self.menuscreen()
self.list = []
self.turns = 0
self.maxlevel = 3
self.currlevel = 1
self.a = [[0 for x in range(8)] for y in range(8)]
#This code puts the standard title and instruction text on screen
self.title = OnscreenText(text="Game of Life : Help in ending AIDS!",
style=1,
fg=(1, 1, 1, 1),
pos=(0, -0.95),
scale=.07)
self.escapeEvent = OnscreenText(text="ESC: Quit",
style=1,
fg=(1, 1, 1, 1),
pos=(-1.3, 0.95),
align=TextNode.ALeft,
scale=.05)
## self.mouse1Event = OnscreenText(
## text="Left-click and drag: Pick up virus and drag it to a new bloodcell",
## style=1, fg=(1,1,1,1), pos=(-1.3, 0.90),
## align=TextNode.ALeft, scale = .05)
##
self.accept('escape', sys.exit) #Escape quits
base.disableMouse() #Disble mouse camera control
camera.setPosHpr(0, -13.75, 6, 0, -25, 0) #Set the camera
self.setupLights() #Setup default lighting
#Since we are using collision detection to do picking, we set it up like
#any other collision detection system with a traverser and a handler
self.picker = CollisionTraverser() #Make a traverser
self.pq = CollisionHandlerQueue() #Make a handler
#Make a collision node for our picker ray
self.pickerNode = CollisionNode('mouseRay')
#Attach that node to the camera since the ray will need to be positioned
#relative to it
self.pickerNP = camera.attachNewNode(self.pickerNode)
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay() #Make our ray
self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node
#Register the ray as something that can cause collisions
self.picker.addCollider(self.pickerNP, self.pq)
#self.picker.showCollisions(render)
#We will attach all of the squares to their own root. This way we can do the
#collision pass just on the sqaures and save the time of checking the rest
#of the scene
self.squareRoot = render.attachNewNode("squareRoot")
#For each square
self.squares = [None for i in range(64)]
self.pieces = [None for i in range(64)]
for i in range(64):
#Load, parent, color, and position the model (a single square polygon)
self.squares[i] = loader.loadModel("models/square")
self.squares[i].reparentTo(self.squareRoot)
self.squares[i].setPos(SquarePos1(i))
self.squares[i].setColor(SquareColor(i))
#Set the model itself to be collideable with the ray. If this model was
#any more complex than a single polygon, you should set up a collision
#sphere around it instead. But for single polygons this works fine.
self.squares[i].find("**/polygon").node().setIntoCollideMask(
BitMask32.bit(1))
#Set a tag on the square's node so we can look up what square this is
#later during the collision pass
self.squares[i].find("**/polygon").node().setTag('square', str(i))
#We will use this variable as a pointer to whatever piece is currently
#in this square
self.initializer(self.currlevel)
#This will represent the index of the currently highlited square
self.hiSq = False
#This wil represent the index of the square where currently dragged piece
#was grabbed from
self.dragging = False
#Start the task that handles the picking
self.mouseTask = taskMgr.add(self.mouseTask, 'mouseTask')
#self.trial = taskMgr.add(self.trial,'trial')
self.accept("mouse1", self.grabPiece) #left-click grabs a piece
self.accept("mouse1-up", self.releasePiece) #releasing places it
#This function swaps the positions of two pieces
def swapPieces(self, fr, to):
temp = self.pieces[fr]
self.pieces[fr] = self.pieces[to]
self.pieces[to] = temp
if self.pieces[fr]:
print 'imma swapping'
self.pieces[fr].square = fr
print fr
print SquarePos(fr)
try:
self.pieces[fr].obj.setPos(SquarePos(fr))
except:
pass
print 'done'
if self.pieces[to]:
self.pieces[to].square = to
try:
self.pieces[to].obj.setPos(SquarePos(to))
except:
pass
def trial(self):
self.turns = self.turns + 1
try:
self.reference.destroy()
except:
pass
self.reference = OnscreenText(text='''
Reference:
virus is surrounded by more than 3 viruses, it dies
virus is surrounded by less than 2 viruses, it dies
If dead empty cell, is surrounded by exactly 3 viruses, a new virus is spawned.
''',
style=1,
fg=(1, 1, 1, 1),
pos=(-1, 0.95),
align=TextNode.ALeft,
scale=.05)
self.showscore()
a = self.a
while True:
for i in self.list:
#insert deletion code
print 'imma deleting the sq : ' + str(i)
self.pieces[i].obj.delete()
self.squares[i].setColor(SquareColor(i))
count = 0
a = [[([[
sum(b[y1][x1]
for b in [[[(
(-1 < x2 + dx < len(a[0])) and
(-1 < y2 + dy < len(a))) and a[y2 + dy][x2 + dx] or 0
for x2 in range(len(a[0]))]
for y2 in range(len(a))]
for (dx, dy) in [(dx, dy) for dx in [-1, 0, 1]
for dy in [-1, 0, 1] if
(dy != 0 or dx != 0)]])
for x1 in range(len(a[0]))
] for y1 in range(len(a))][y][x] == 3 or ([[
sum(c[y3][x3]
for c in [[[(
(-1 < x4 + dx < len(a[0])) and
(-1 < y4 + dy < len(a))) and a[y4 + dy][x4 + dx] or 0
for x4 in range(len(a[0]))]
for y4 in range(len(a))]
for (dx, dy) in [(dx, dy) for dx in [-1, 0, 1]
for dy in [-1, 0, 1] if
(dy != 0 or dx != 0)]])
for x3 in range(len(a[0]))
] for y3 in range(len(a))][y][x] == 2 and a[y][x] == 1)) and 1 or 0
for x in range(len(a[0]))] for y in range(len(a))]
lis = []
#insert a random virus at a probability of 1/5
diceroll = random.randint(0, 5)
if diceroll == 2:
self.random_vgen()
for element in reversed(a):
for ele in element:
#print 'cheking element is 1 : ' + str(ele)
if ele == 1:
lis.append(count)
count = count + 1
print lis
self.list = lis
self.a = a
print self.list
for i in self.list:
self.pieces[i] = Monster(i, WHITE)
#self.squares[i].setColor(HIGHLIGHT)
print 'leaving trial'
if len(self.list) == 0:
self.endscreen()
break
return
def mouseTask(self, task):
#This task deals with the highlighting and dragging based on the mouse
#First, clear the current highlight
if self.hiSq is not False:
self.squares[self.hiSq].setColor(SquareColor(self.hiSq))
self.hiSq = False
#Check to see if we can access the mouse. We need it to do anything else
if base.mouseWatcherNode.hasMouse():
#get the mouse position
mpos = base.mouseWatcherNode.getMouse()
#Set the position of the ray based on the mouse position
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
#If we are dragging something, set the position of the object
#to be at the appropriate point over the plane of the board
if self.dragging is not False:
#Gets the point described by pickerRay.getOrigin(), which is relative to
#camera, relative instead to render
nearPoint = render.getRelativePoint(camera,
self.pickerRay.getOrigin())
#Same thing with the direction of the ray
nearVec = render.getRelativeVector(
camera, self.pickerRay.getDirection())
try:
self.pieces[self.dragging].obj.setPos(
PointAtZ(.5, nearPoint, nearVec))
except:
pass
#Do the actual collision pass (Do it only on the squares for
#efficiency purposes)
self.picker.traverse(self.squareRoot)
if self.pq.getNumEntries() > 0:
#if we have hit something, sort the hits so that the closest
#is first, and highlight that node
self.pq.sortEntries()
i = int(self.pq.getEntry(0).getIntoNode().getTag('square'))
#Set the highlight on the picked square
self.squares[i].setColor(HIGHLIGHT)
self.hiSq = i
#print 'selected is ' + str(i)
return Task.cont
def grabPiece(self):
#If a square is highlighted and it has a piece, set it to dragging mode
if (self.hiSq is not False and self.pieces[self.hiSq]):
self.dragging = self.hiSq
self.hiSq = False
def releasePiece(self):
#Letting go of a piece. If we are not on a square, return it to its original
#position. Otherwise, swap it with the piece in the new square
if self.dragging is not False: #Make sure we really are dragging something
#We have let go of the piece, but we are not on a square
if self.hiSq is False:
try:
self.pieces[self.dragging].obj.setPos(
SquarePos(self.dragging))
except:
pass
else:
#Otherwise, swap the pieces
self.swapPieces(self.dragging, self.hiSq)
#self.draggin is the from
print self.list
print 'you picked this, so Imma deleting this ' + str(
self.dragging)
#deletion of i after picking it up.
try:
self.list.remove(self.dragging)
except:
pass
temp2 = []
temp2 = SquarePosTuple(self.dragging)
self.a[temp2[0]][temp2[1]] = 0
i = self.hiSq
print self.list
print 'highlighted sq is ' + str(i)
templis = []
templis = SquarePosTuple(i)
print templis
self.list.append(i)
print self.list
print templis
self.a[templis[0]][templis[1]] = 1
for line in self.a:
print line
self.trial()
#We are no longer dragging anything
self.dragging = False
def setupLights(self): #This function sets up some default lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.8, .8, .8, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0, 45, -45))
directionalLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
render.setLight(render.attachNewNode(directionalLight))
render.setLight(render.attachNewNode(ambientLight))
class Dashboard(DirectObject):
# def __init__(self, character, taskMgr, raceMst):
def __init__(self, world, taskMgr):
self.world = world
self.font_digital = loader.loadFont('models/font/SFDigitalReadout-Heavy.ttf')
self.total_players = 30
self.rank = 21
self.main_char = world.vehicleContainer
#self.rm = raceMst
self.speed = "0.0 km/h"
self.lead1 = ""
self.lead2 = ""
self.lead3 = ""
self.start_time = datetime.datetime.now()
self.time_elapsed = datetime.timedelta(milliseconds=0)
self.countdown_time = datetime.timedelta(minutes=8)
# insert total time
self.game_time = self.countdown_time - self.time_elapsed
# print self.game_time
# Timer
self.display_timer = OnscreenText(text=str(self.game_time), style=1, fg=(1, 1, 1, 1), pos=(0, .9), scale=.1,
font=self.font_digital)
# Mini-Map
# self.mini_map = OnscreenImage(image="models/dashb/minimap.png", scale=.15, pos=(-1.15, 0, .8))
# self.mini_map.setTransparency(TransparencyAttrib.MAlpha)
# Speedometer
self.speed_img = OnscreenImage(image="models/dashb/speedometer.png", scale=.5, pos=(1.1, 0, -.95))
self.speed_img.setTransparency(TransparencyAttrib.MAlpha)
OnscreenText(text="km\n/h", style=1, fg=(1, 1, 1, 1),
font=self.font_digital, scale=.07, pos=(1.25, -.92))
# Your Rank
OnscreenText(text="Rank", style=1, fg=(1, 1, 1, 1), pos=(-.9, .89), align=TextNode.ALeft,
font=self.font_digital, scale=.06)
#rank = str(self.rm.rank) + "/" + str(self.rm.racers)
# self.display_rank = OnscreenText(text=rank, style=1, fg=(1, 1, 1, 1),
# pos=(-.8, .85), align=TextNode.ALeft,
# scale=.15, font=self.font_digital)
OnscreenText(text="Players\nLeft", style=1, fg=(1, 1, 1, 1), pos=(-.5, .89), align=TextNode.ALeft,
font=self.font_digital, scale=.06)
#laps = str(self.rm.laps) + " Laps"
#self.display_lap = OnscreenText(text=laps, style=1, fg=(1, 1, 1, 1), pos=(1.0, .89), align=TextNode.ALeft,
# font=self.font_digital, scale=.06)
# Leaderboard Ranking
self.leader1 = OnscreenText(text="1:", style=1, fg=(1, 1, 1, 1),
pos=(-1.3, .5), align=TextNode.ALeft,
scale=.07, font=self.font_digital)
self.leader2 = OnscreenText(text="2:", style=1, fg=(1, 1, 1, 1),
pos=(-1.3, .45), align=TextNode.ALeft,
scale=.07, font=self.font_digital)
self.leader3 = OnscreenText(text="3:", style=1, fg=(1, 1, 1, 1),
pos=(-1.3, .4), align=TextNode.ALeft,
scale=.07, font=self.font_digital)
# Power-ups
# OnscreenText(text="1", style=1, fg=(1, 1, 1, 1),
# pos=(-1.25, -.95),
# scale=.07)
# OnscreenText(text="2", style=1, fg=(1, 1, 1, 1),
# pos=(-1.15, -.95),
# scale=.07)
# OnscreenText(text="3", style=1, fg=(1, 1, 1, 1),
# pos=(-1.05, -.95),
# scale=.07)
# self.power1 = OnscreenImage(image='models/power_ups/pow1.png', pos=(-1.25, 0, -0.85), scale=.05)
# self.power2 = OnscreenImage(image='models/power_ups/pow2.png', pos=(-1.15, 0, -0.85), scale=.05)
# self.power3 = OnscreenImage(image='models/power_ups/pow3.png', pos=(-1.05, 0, -0.85), scale=.05)
# Display Speed
self.display_speed = OnscreenText(text=self.speed, style=1, fg=(1, 1, 1, 1),
pos=(1.3, -0.95), align=TextNode.ARight, scale=.07, font=self.font_digital)
taskMgr.doMethodLater(.1, self.show_speed, 'updateSpeed')
taskMgr.doMethodLater(.1, self.show_timer, 'updateTimer')
taskMgr.doMethodLater(.1, self.update_rank, 'updateRank')
def show_speed(self, task):
self.speed = str(format(self.main_char.vehicle.getCurrentSpeedKmHour(), '0.2f'))
# print self.speed
# Update Speed Display
self.display_speed.destroy()
self.display_speed = OnscreenText(text=self.speed, style=3, fg=(1, 1, 1, 1),
pos=(1.2, -0.95), align=TextNode.ARight, scale=.15, font=self.font_digital)
return task.cont
def show_timer(self, task):
self.time_elapsed = datetime.datetime.now() - self.start_time
game_time = str(self.countdown_time - self.time_elapsed)[2:11]
self.display_timer.destroy()
self.display_timer = OnscreenText(text=game_time, style=3, fg=(1, 1, 1, 1), pos=(0, .9), scale=.15,
font=self.font_digital)
return task.cont
# server updates client time in ms
def force_timer(self, server_time):
self.start_time = datetime.datetime.now()
self.countdown_time = datetime.timedelta(milliseconds=server_time)
def update_ranking(self, leaders):
# get usernames from list
self.lead1 = leaders.get(1)
self.lead2 = leaders.get(2)
self.lead3 = leaders.get(3)
def update_rank(self, task):
#self.display_rank.destroy()
#self.display_lap.destroy()
# Your Rank
#rank = str(self.rm.rank) + "/" + str(self.rm.racers)
# self.display_rank = OnscreenText(text=rank, style=1, fg=(1, 1, 1, 1),
# pos=(-.8, .85), align=TextNode.ALeft,
# scale=.15, font=self.font_digital)
#
# #laps = str(self.rm.laps) + " Laps - " + str(self.rm.checkpointspassed)
# self.display_lap = OnscreenText(text=laps, style=1, fg=(1, 1, 1, 1), pos=(1.0, .89), align=TextNode.ALeft,
# font=self.font_digital, scale=.06)
# Leader board
self.leader1.destroy()
self.leader2.destroy()
self.leader3.destroy()
lead1 = "1:" + self.lead1
lead2 = "2:" + self.lead2
lead3 = "3:" + self.lead3
self.leader1 = OnscreenText(text=lead1, style=1, fg=(1, 1, 1, 1),
pos=(-1.3, .5), align=TextNode.ALeft,
scale=.07, font=self.font_digital)
self.leader2 = OnscreenText(text=lead2, style=1, fg=(1, 1, 1, 1),
pos=(-1.3, .45), align=TextNode.ALeft,
scale=.07, font=self.font_digital)
self.leader3 = OnscreenText(text=lead3, style=1, fg=(1, 1, 1, 1),
pos=(-1.3, .4), align=TextNode.ALeft,
scale=.07, font=self.font_digital)
return task.cont
class World(DirectObject):
rotateSpeed = 180
moveSpeed = 20
def __init__(self):
DirectObject.__init__(self)
base.camera.hide()
self.access = 0
self.av = None
self.ToonSpeedFactor = 1.25
self.ToonForwardSpeed = 16.0 * self.ToonSpeedFactor
self.ToonJumpForce = 24.0
self.ToonReverseSpeed = 8.0 * self.ToonSpeedFactor
self.ToonRotateSpeed = 80.0 * self.ToonSpeedFactor
self.moveKeyList = [
'arrow_left', 'arrow_right', 'arrow_up', 'arrow_down'
]
self.moveKeys = {}
for key in self.moveKeyList:
self.moveKeys[key] = False
self.accept(key, self.moveKeyStateChanged, extraArgs=[key, True])
self.accept(key + '-up',
self.moveKeyStateChanged,
extraArgs=[key, False])
tcpPort = base.config.GetInt('server-port', 4400)
hostname = base.config.GetString('server-host', '127.0.0.1')
self.url = URLSpec('http://%s:%s' % (hostname, tcpPort))
self.cr = MyClientRepository()
self.waitingText = OnscreenText(
'Connecting to %s.\nPress ESC to cancel.' % (self.url),
scale=0.1,
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1))
self.accept('escape', self.escape)
base.disableMouse()
base.cTrav = CollisionTraverser()
self.cr.connect([self.url],
successCallback=self.connectSuccess,
failureCallback=self.connectFailure)
def moveKeyStateChanged(self, key, newState):
self.moveKeys[key] = newState
def escape(self):
sys.exit()
def connectFailure(self, statusCode, statusString):
self.waitingText.destroy()
self.failureText = OnscreenText(
'Failed to connect to %s: %s.\nPress ESC to quit.' %
(self.url, statusString),
scale=0.15,
fg=(1, 0, 0, 1),
shadow=(0, 0, 0, 1))
def connectSuccess(self):
self.waitingText.destroy()
self.waitingText = OnscreenText('Waiting for server.',
scale=0.1,
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1))
self.cr.setInterestZones([1])
self.acceptOnce('gotTimeSync', self.syncReady)
def syncReady(self):
if self.cr.haveCreateAuthority():
self.createReady()
else:
self.acceptOnce('createReady', self.createReady)
def createReady(self):
self.waitingText.destroy()
self.av = self.cr.createDistributedObject(className='DistributedToon',
zoneId=2)
self.av.setupLocalAvatar()
self.offset = 3.2375
base.camera.reparentTo(self.av)
base.camera.setPos(0, -10.0 - self.offset, self.offset)
base.camera.hide()
self.av.startPosHprBroadcast()
def changeAvZone(self, zoneId):
if zoneId == 999 and self.access >= 100:
self.cr.setObjectZone(self.av, zoneId)
elif zoneId == 999 and self.access <= 100:
print "Insufficient access"
else:
self.cr.setObjectZone(self.av, zoneId)
strZoneId = str(zoneId)
print "Went to room " + strZoneId + ""
def moveAvatar(self, task):
wallBitmask = BitMask32(1)
floorBitmask = BitMask32(2)
base.cTrav = CollisionTraverser()
def getAirborneHeight():
return offset + 0.025000000000000001
walkControls = GravityWalker(legacyLifter=True)
walkControls.setWallBitMask(wallBitmask)
walkControls.setFloorBitMask(floorBitmask)
walkControls.setWalkSpeed(self.ToonForwardSpeed, self.ToonJumpForce,
self.ToonReverseSpeed, self.ToonRotateSpeed)
walkControls.initializeCollisions(base.cTrav,
self.model,
floorOffset=0.025,
reach=4.0)
walkControls.setAirborneHeightFunc(getAirborneHeight)
walkControls.enableAvatarControls()
self.model.physControls = walkControls
def setWatchKey(key, input, keyMapName):
def watchKey(active=True):
if active == True:
inputState.set(input, True)
keyMap[keyMapName] = 1
else:
inputState.set(input, False)
keyMap[keyMapName] = 0
base.accept(key, watchKey, [True])
base.accept(key + '-up', watchKey, [False])
keyMap = {
'left': 0,
'right': 0,
'forward': 0,
'backward': 0,
'control': 0
}
setWatchKey('arrow_up', 'forward', 'forward')
setWatchKey('control-arrow_up', 'forward', 'forward')
setWatchKey('alt-arrow_up', 'forward', 'forward')
setWatchKey('shift-arrow_up', 'forward', 'forward')
setWatchKey('arrow_down', 'reverse', 'backward')
setWatchKey('control-arrow_down', 'reverse', 'backward')
setWatchKey('alt-arrow_down', 'reverse', 'backward')
setWatchKey('shift-arrow_down', 'reverse', 'backward')
setWatchKey('arrow_left', 'turnLeft', 'left')
setWatchKey('control-arrow_left', 'turnLeft', 'left')
setWatchKey('alt-arrow_left', 'turnLeft', 'left')
setWatchKey('shift-arrow_left', 'turnLeft', 'left')
setWatchKey('arrow_right', 'turnRight', 'right')
setWatchKey('control-arrow_right', 'turnRight', 'right')
setWatchKey('alt-arrow_right', 'turnRight', 'right')
setWatchKey('shift-arrow_right', 'turnRight', 'right')
setWatchKey('control', 'jump', 'control')
self.movingNeutral, movingForward = (False, False)
self.movingRotation, movingBackward = (False, False)
self.movingJumping = False
def setMovementAnimation(loopName, playRate=1.0):
if 'jump' in loopName:
self.movingJumping = True
self.movingForward = False
self.movingNeutral = False
self.movingRotation = False
self.movingBackward = False
elif loopName == 'run':
self.movingJumping = False
self.movingForward = True
self.movingNeutral = False
self.movingRotation = False
self.movingBackward = False
elif loopName == 'walk':
self.movingJumping = False
self.movingForward = False
self.movingNeutral = False
if playRate == -1.0:
self.movingBackward = True
self.movingRotation = False
else:
self.movingBackward = False
self.movingRotation = True
elif loopName == 'neutral':
self.movingJumping = False
self.movingForward = False
self.movingNeutral = True
self.movingRotation = False
self.movingBackward = False
else:
self.movingJumping = False
self.movingForward = False
self.movingNeutral = False
self.movingRotation = False
self.movingBackward = False
ActorInterval(self.model, loopName, playRate=playRate).loop()
def handleMovement(task):
global movingNeutral, movingForward
global movingRotation, movingBackward, movingJumping
if keyMap['control'] == 1:
if keyMap['forward'] or keyMap['backward'] or keyMap[
'left'] or keyMap['right']:
if self.movingJumping == False:
if self.model.physControls.isAirborne:
setMovementAnimation('running-jump-idle')
else:
if keyMap['forward']:
if self.movingForward == False:
setMovementAnimation('run')
elif keyMap['backward']:
if self.movingBackward == False:
setMovementAnimation('walk', playRate=-1.0)
elif keyMap['left'] or keyMap['right']:
if self.movingRotation == False:
setMovementAnimation('walk')
else:
if not self.model.physControls.isAirborne:
if keyMap['forward']:
if self.movingForward == False:
setMovementAnimation('run')
elif keyMap['backward']:
if self.movingBackward == False:
setMovementAnimation('walk', playRate=-1.0)
elif keyMap['left'] or keyMap['right']:
if self.movingRotation == False:
setMovementAnimation('walk')
else:
if self.movingJumping == False:
if self.model.physControls.isAirborne:
setMovementAnimation('jump-idle')
else:
if self.movingNeutral == False:
setMovementAnimation('neutral')
else:
if not self.model.physControls.isAirborne:
if self.movingNeutral == False:
setMovementAnimation('neutral')
elif keyMap['forward'] == 1:
if self.movingForward == False:
if not self.model.physControls.isAirborne:
setMovementAnimation('run')
elif keyMap['backward'] == 1:
if self.movingBackward == False:
if not self.model.physControls.isAirborne:
setMovementAnimation('walk', playRate=-1.0)
elif keyMap['left'] or keyMap['right']:
if self.movingRotation == False:
if not self.model.physControls.isAirborne:
setMovementAnimation('walk')
else:
if not self.model.physControls.isAirborne:
if self.movingNeutral == False:
setMovementAnimation('neutral')
return Task.cont
base.taskMgr.add(handleMovement, 'controlManager')
dt = globalClock.getDt()
class MyApp(ShowBase):
def addTitle(self,text):
return OnscreenText(text=text, style=1, fg=(1,1,1,1), pos=(0,-0.95), align=TextNode.ACenter, scale = .07)
def makeStatusLabel(self, i):
return OnscreenText(style=1, fg=(1,1,0,1), pos=(-1.3 + (i*0.8), -0.95 ), align=TextNode.ALeft, scale = .05, mayChange = 1)
def __init__(self):
#base = ShowBase()
ShowBase.__init__(self)
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
self.texto1 = OnscreenText(text="Collect 8 balls and meet Sonic behind the building", style=1, fg=(1,1,1,1), pos=(0,-0.1), align=TextNode.ACenter, scale = .07)
self.texto2 = OnscreenText(text="Eat bananas for energy and avoid green stones", style=1, fg=(1,1,1,1), pos=(0,-0.2), align=TextNode.ACenter, scale = .07)
self.texto3 = OnscreenText(text="Arrow keys move the player", style=1, fg=(1,1,1,1), pos=(0,-0.3), align=TextNode.ACenter, scale = .07)
self.texto4 = OnscreenText(text="a and s help you view the scene", style=1, fg=(1,1,1,1), pos=(0,-0.4), align=TextNode.ACenter, scale = .07)
mySound = base.loader.loadSfx("models/Theme_song.ogg")
mySound.setLoop(True)
mySound.play()
#mySound.setLoop(true)
self.noOfbanana = self.makeStatusLabel(0)
self.noOfBalls = self.makeStatusLabel(1)
self.points = self.makeStatusLabel(2)
self.environ = self.loader.loadModel("models/moonsurface.egg")
self.environ.reparentTo(self.render)
self.environ.setScale(0.25, 0.25, 0.25)
self.environ.setPos(-8, 42, -3)
self.environ1 = self.loader.loadModel("models/env")
self.environ1.reparentTo(self.render)
self.environ1.setScale(50,50,30)
self.environ1.setPos(0, -170, -3)
#self.environ1.setHpr(90,0,0)
self.chair1=self.loader.loadModel("models/BeachChair")
#self.chair1=self.reaparentTo(self.render)
#self.setScale(1000)
#self.setPos(25,-160,-3)
#self.chair1.setHpr(90,0,0)
self.house1 = self.loader.loadModel("models/houses/church")
self.house1.reparentTo(self.render)
self.house1.setScale(0.30)
self.house1.setPos(25, -150, -3)
self.house1.setHpr(90,0,0)
self.house2 = self.loader.loadModel("models/houses/building")
self.house2.reparentTo(self.render)
self.house2.setScale(0.30)
self.house2.setPos(18, -200, -3)
self.house2.setHpr(180,0,0)
self.house3 = self.loader.loadModel("models/houses/farmhouse")
self.house3.reparentTo(self.render)
self.house3.setScale(0.30)
self.house3.setPos(20, -130, -3)
self.house3.setHpr(90,0,0)
self.house4 = self.loader.loadModel("models/houses/dojo")
self.house4.reparentTo(self.render)
self.house4.setScale(0.05)
self.house4.setPos(5, -220, -3)
self.house5 = self.loader.loadModel("models/houses/beachhouse2")
self.house5.reparentTo(self.render)
self.house5.setScale(0.30)
self.house5.setPos(-10, -180, -3)
self.house5.setHpr(-90,0,0)
self.house6 = self.loader.loadModel("models/houses/gazebo")
self.house6.reparentTo(self.render)
self.house6.setScale(0.50)
self.house6.setPos(-10, -200, -3)
self.house7 = self.loader.loadModel("models/houses/building")
self.house7.reparentTo(self.render)
self.house7.setScale(0.30)
self.house7.setPos(-10, -120, -3)
''' for x in range(0,8):
self.load4 = loader.loadModel("models/fence")
self.load4.reparentTo(render)
self.load4.setScale(.5, .5, 1.3)
self.load4.setPos(28-x*7,0,1.8)
cp = self.load4.attachNewNode(CollisionNode('box'))
cp.node().addSolid(CollisionPolygon(
Point3(-10.0,0.0,4),Point3(10,0,4),
Point3(10,-1,-2),Point3(-10,-1,-2))) '''
self.tunnel = [None for i in range(10)]
for x in range(10):
#Load a copy of the tunnel
self.tunnel[x] = loader.loadModel('models/tunnel')
self.tunnel[x].setHpr(0,90,0)
self.tunnel[x].setScale(0.5)
self.tunnel[x].setPos(0,177.5 + 25*x, 0)
self.tunnel[x].reparentTo(self.render)
## ###World specific-code
##
## #Create an instance of fog called 'distanceFog'.
## #'distanceFog' is just a name for our fog, not a specific type of fog.
## self.fog = Fog('distanceFog')
## #Set the initial color of our fog to black.
## self.fog.setColor(0, 0, 0)
## #Set the density/falloff of the fog. The range is 0-1.
## #The higher the numer, the "bigger" the fog effect.
## self.fog.setExpDensity(.08)
## #We will set fog on render which means that everything in our scene will
## #be affected by fog. Alternatively, you could only set fog on a specific
## #object/node and only it and the nodes below it would be affected by
## #the fog.
## render.setFog(self.fog)
self.banana = [None for i in range(20)]
self.flag = [0 for i in range(20)]
self.fla = [0 for i in range(5)]
self.fl = [0 for i in range(8)]
for x in range(10):
#Load a copy of the tunnel
self.banana[x] = loader.loadModel('models/banana/banana')
#self.banana[x].setHpr(0,90,0)
self.banana[x].setScale(0.7)
if(x%2==0):
self.banana[x].setPos(-1,180 + 25*x, -2)
else:
self.banana[x].setPos(1,177.5 + 25*x, -2)
self.banana[x].reparentTo(self.render)
self.banana[11] = self.loader.loadModel("models/banana/banana")
self.banana[11].reparentTo(self.render)
self.banana[11].setPos(12, 8, -2)
self.banana[12] = self.loader.loadModel("models/banana/banana")
self.banana[12].reparentTo(self.render)
self.banana[12].setPos(0, 120, -2)
self.banana[13] = self.loader.loadModel("models/banana/banana")
self.banana[13].reparentTo(self.render)
self.banana[13].setPos(12, 100, -2)
self.banana[14] = self.loader.loadModel("models/banana/banana")
self.banana[14].reparentTo(self.render)
self.banana[14].setPos(22, 80, -2)
self.banana[15] = self.loader.loadModel("models/banana/banana")
self.banana[15].reparentTo(self.render)
self.banana[15].setPos(12, 50, -2)
self.banana[16] = self.loader.loadModel("models/banana/banana")
self.banana[16].reparentTo(self.render)
self.banana[16].setPos(15, 30, -2)
self.banana[17] = self.loader.loadModel("models/banana/banana")
self.banana[17].reparentTo(self.render)
self.banana[17].setPos(-10, 8, -2)
self.banana[18] = self.loader.loadModel("models/banana/banana")
self.banana[18].reparentTo(self.render)
self.banana[18].setPos(-20, -30, -2)
self.banana[19] = self.loader.loadModel("models/banana/banana")
self.banana[19].reparentTo(self.render)
self.banana[19].setPos(-50, -50, -2)
self.candy = self.loader.loadModel("models/candy/candycane2")
self.candy.reparentTo(self.render)
self.candy.setScale(0.001)
self.candy.setPos(-6, 10, -2)
self.fire = self.loader.loadModel("models/candy/candycane2")
self.fire.reparentTo(self.render)
self.fire.setScale(0.001)
self.fire.setPos(0, 2, -2)
self.ball = [None for i in range(8)]
self.ball[0] = self.loader.loadModel("models/ball/soccerball")
self.ball[0].reparentTo(self.render)
self.ball[0].setPos(-6, 6, -2)
self.ball[0].setScale(0.7)
self.ball[1] = self.loader.loadModel("models/ball/soccerball")
self.ball[1].reparentTo(self.render)
self.ball[1].setPos(-6, -6, -2)
self.ball[1].setScale(0.7)
self.ball[2] = self.loader.loadModel("models/ball/soccerball")
self.ball[2].reparentTo(self.render)
self.ball[2].setPos(-15, 10, -2)
self.ball[2].setScale(0.7)
self.ball[3] = self.loader.loadModel("models/ball/soccerball")
self.ball[3].reparentTo(self.render)
self.ball[3].setPos(-19, 0, -2)
self.ball[3].setScale(0.7)
self.ball[4] = self.loader.loadModel("models/ball/soccerball")
self.ball[4].reparentTo(self.render)
self.ball[4].setPos(-6, -20, -2)
self.ball[4].setScale(0.7)
self.ball[5] = self.loader.loadModel("models/ball/soccerball")
self.ball[5].reparentTo(self.render)
self.ball[5].setPos(6, 6, -2)
self.ball[5].setScale(0.7)
self.ball[6] = self.loader.loadModel("models/ball/soccerball")
self.ball[6].reparentTo(self.render)
self.ball[6].setPos(19, 10, -2)
self.ball[6].setScale(0.7)
self.ball[7] = self.loader.loadModel("models/ball/soccerball")
self.ball[7].reparentTo(self.render)
self.ball[7].setPos(-15, 12, -2)
self.ball[7].setScale(0.7)
self.rock = [None for i in range(8)]
self.rock[0] = self.loader.loadModel("models/greencrystal")
self.rock[0].reparentTo(self.render)
self.rock[0].setPos(0,306, -4)
self.rock[0].setScale(0.007)
self.rock[0].setHpr(90,0,0)
self.rock[1] = self.loader.loadModel("models/greencrystal")
self.rock[1].reparentTo(self.render)
self.rock[1].setPos(-2, 150, -3)
self.rock[1].setScale(0.007)
self.rock[1].setHpr(90,0,0)
self.rock[2] = self.loader.loadModel("models/greencrystal")
self.rock[2].reparentTo(self.render)
self.rock[2].setPos(-10, 10, -3)
self.rock[2].setScale(0.007)
self.rock[2].setHpr(90,0,0)
self.rock[3] = self.loader.loadModel("models/greencrystal")
self.rock[3].reparentTo(self.render)
self.rock[3].setPos(5, 0, -3)
self.rock[3].setScale(0.007)
self.rock[3].setHpr(90,0,0)
self.rock[4] = self.loader.loadModel("models/greencrystal")
self.rock[4].reparentTo(self.render)
self.rock[4].setPos(-2, -120, -3)
self.rock[4].setScale(0.007)
self.rock[4].setHpr(90,0,0)
self.tire = self.loader.loadModel("models/tire/tire")
self.tire.reparentTo(self.render)
self.tire.setScale(0.25, 0.25, 0.25)
self.tire.setPos(-20, 3, -2)
self.bunny1 = self.loader.loadModel("models/bunny")
self.bunny1.reparentTo(self.render)
self.bunny1.setScale(0.2)
self.bunny1.setPos(15, -160, -3)
self.bunny1.setHpr(-60,0,0)
self.bunny2 = self.loader.loadModel("models/bunny")
self.bunny2.reparentTo(self.render)
self.bunny2.setScale(0.2)
self.bunny2.setPos(15, -161, -3)
self.bunny2.setHpr(-145,0,0)
# Add the spinCameraTask procedure to the task manager.
#self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# Load and transform the panda actor.
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
#self.pandaActor.setPos(0,100,-3)
self.pandaActor.reparentTo(self.render)
# Loop its animation.
self.pandaActor.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
pandaPosInterval1 = self.pandaActor.posInterval(20,
Point3(0, -110, -3),
startPos=Point3(0, -90, -3))
pandaPosInterval2 = self.pandaActor.posInterval(20,
Point3(0, -90, -3),
startPos=Point3(0, -110, -3))
pandaHprInterval1 = self.pandaActor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(0, 0, 0))
pandaHprInterval2 = self.pandaActor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.pandaPace = Sequence(pandaPosInterval1,
pandaHprInterval1,
pandaPosInterval2,
pandaHprInterval2,
name="pandaPace")
self.pandaPace.loop()
self.eve = Actor("models/eve",
{"walk": "models/eve-walk"})
self.eve.setScale(0.5, 0.5, 0.5)
self.eve.setPos(-1,-140,-3)
self.eve.reparentTo(self.render)
# Loop its animation.
self.eve.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
evePosInterval1 = self.eve.posInterval(20,
Point3(-1, -160, -3),
startPos=Point3(-1, -140, -3))
evePosInterval2 = self.eve.posInterval(20,
Point3(-1, -140, -3),
startPos=Point3(-1, -160, -3))
eveHprInterval1 = self.eve.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(0, 0, 0))
eveHprInterval2 = self.eve.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.evePace = Sequence(evePosInterval1,eveHprInterval1,evePosInterval2,eveHprInterval2,name="evePace")
self.evePace.loop()
self.ralph = Actor("models/r/ralph",
{"run":"models/ralph-run",
"walk": "models/ralph-walk"})
self.ralph.setScale(0.5, 0.5, 0.5)
self.ralph.setPos(0, 420, -3)
self.ralph.reparentTo(self.render)
self.boy = Actor("models/soni/sonic",
{"anim":"models/soni/sonic-win"})
self.boy.setScale(0.05, 0.05, 0.05)
self.boy.setPos(33, -203, -2)
self.boy.setHpr(-90,0,0)
self.boy.reparentTo(self.render)
self.boy.loop("anim")
self.boy1 = Actor("models/boy/boymodel",
{"anim":"models/boy/boyanimation"})
self.boy1.setScale(0.007)
self.boy1.setPos(-5, -200, -2)
self.boy1.setHpr(180,0,0)
self.boy1.reparentTo(self.render)
self.boy1.loop("anim")
self.character=Actor()
self.character.loadModel('models/dancer')
self.character.setPos(3,150,-3)
self.character.reparentTo(render)
self.character.setHpr(180,0,0)
self.character.setScale(0.6)
self.character.loadAnims({'win':'models/dancer'})
self.character.loop('win')
self.character1=Actor()
self.character1.loadModel('models/gorillawalking')
self.character1.setPos(2,-13,-3)
self.character1.setScale(0.6)
self.character1.reparentTo(render)
self.character1.setHpr(180,0,0)
self.character1.loadAnims({'win':'models/gorillawalking'})
self.character1.loop('win')
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
taskMgr.add(self.move,"moveTask")
taskMgr.add(self.find,"fisdTask")
taskMgr.add(self.potask,"potaskTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,-1)
#print self.ralph.getX(), self.ralph.getY()
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
self.updateStatusLabel()
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
def potask(self,task):
global points
if(self.ralph.getY()<410):
self.texto1.destroy()
self.texto2.destroy()
self.texto3.destroy()
self.texto4.destroy()
if(points<0):
OnscreenText(text="Game Over", style=1, fg=(1,1,1,1), pos=(0,0), align=TextNode.ACenter, scale = 0.4)
OnscreenText(text="You are out of energy", style=1, fg=(1,1,1,1), pos=(0,-0.20), align=TextNode.ACenter, scale = 0.05)
return Task.cont
def find(self,task):
global nob, points, noba
#print self.ralph.getX(),self.ralph.getY()
if ((self.ralph.getX()>=-3 and self.ralph.getX()<=-1) and (self.ralph.getY()>=145 and self.ralph.getY()<=165) and self.fla[1] == 0):
self.rock[1].removeNode()
points= points - 20
self.fla[1]=1
elif((self.ralph.getX()>=-11 and self.ralph.getX()<=-9) and (self.ralph.getY()>=9 and self.ralph.getY()<=11) and self.fla[2] == 0):
self.rock[2].removeNode()
points= points - 20
self.fla[2]=1
elif((self.ralph.getX()>=4 and self.ralph.getX()<=6) and (self.ralph.getY()>=-1 and self.ralph.getY()<=1) and self.fla[3] == 0):
self.rock[3].removeNode()
points= points - 20
self.fla[3]=1
elif((self.ralph.getX()>=-1 and self.ralph.getX()<=1) and (self.ralph.getY()>=305 and self.ralph.getY()<=307) and self.fla[0] == 0):
self.rock[0].removeNode()
points= points - 20
self.fla[0]=1
elif((self.ralph.getX()>=-3 and self.ralph.getX()<=-1) and (self.ralph.getY()>=-121 and self.ralph.getY()<=-119) and self.fla[4] == 0):
self.rock[4].removeNode()
points= points - 20
self.fla[4]=1
if ((self.ralph.getX()>=-7.5 and self.ralph.getX()<=-6.5) and (self.ralph.getY()>=-7.5 and self.ralph.getY()<=-6.5) and self.fl[1] == 0):
self.ball[1].removeNode()
noba= noba + 1
self.fl[1]=1
elif((self.ralph.getX()>=-15.5 and self.ralph.getX()<=-14.5) and (self.ralph.getY()>=9.5 and self.ralph.getY()<=10.5) and self.fl[2] == 0):
self.ball[2].removeNode()
noba= noba + 1
self.fl[2]=1
elif((self.ralph.getX()>=-19.5 and self.ralph.getX()<=-18.5) and (self.ralph.getY()>=-0.5 and self.ralph.getY()<=0.5) and self.fl[3] == 0):
self.ball[3].removeNode()
noba= noba + 1
self.fl[3]=1
elif((self.ralph.getX()>=-6.5 and self.ralph.getX()<=-5.5) and (self.ralph.getY()>=5.5 and self.ralph.getY()<=6.5) and self.fl[0] == 0):
self.ball[0].removeNode()
noba= noba + 1
self.fl[0]=1
elif((self.ralph.getX()>=-6.5 and self.ralph.getX()<=-5.5) and (self.ralph.getY()>=-20.5 and self.ralph.getY()<=-19.5) and self.fl[4] == 0):
self.ball[4].removeNode()
noba= noba + 1
self.fl[4]=1
elif((self.ralph.getX()>=5.5 and self.ralph.getX()<=6.5) and (self.ralph.getY()>=5.5 and self.ralph.getY()<=6.5) and self.fl[5] == 0):
self.ball[5].removeNode()
noba= noba + 1
self.fl[5]=1
elif((self.ralph.getX()>=18.5 and self.ralph.getX()<=19.5) and (self.ralph.getY()>=9.5 and self.ralph.getY()<=10.5) and self.fl[6] == 0):
self.ball[6].removeNode()
noba= noba + 1
self.fl[6]=1
elif((self.ralph.getX()>=-15.5 and self.ralph.getX()<=-14.5) and (self.ralph.getY()>=11.5 and self.ralph.getY()<=12.5) and self.fl[7] == 0):
self.ball[7].removeNode()
noba= noba + 1
self.fl[7]=1
if ((self.ralph.getX()>=11.5 and self.ralph.getX()<=12.5) and (self.ralph.getY()>=7.5 and self.ralph.getY()<=8.5) and self.flag[11]==0):
self.banana[11].removeNode()
nob= nob + 1
points= points + 10
self.flag[11]=1
elif ((self.ralph.getX()>=0.5 and self.ralph.getX()<=1.5) and (self.ralph.getY()>=404.5 and self.ralph.getY()<=405.5) and self.flag[9]==0):
self.banana[9].removeNode()
nob= nob + 1
points= points + 10
self.flag[9]=1
elif ((self.ralph.getX()>=0.5 and self.ralph.getX()<=1.5) and (self.ralph.getY()>=354.5 and self.ralph.getY()<=355.5) and self.flag[7]==0):
self.banana[7].removeNode()
nob= nob + 1
points= points + 10
self.flag[7]=1
elif ((self.ralph.getX()>=0.5 and self.ralph.getX()<=1.5) and (self.ralph.getY()>=304.5 and self.ralph.getY()<=305.5) and self.flag[5]==0):
self.banana[5].removeNode()
nob= nob + 1
points= points + 10
self.flag[5]=1
elif ((self.ralph.getX()>=0.5 and self.ralph.getX()<=1.5) and (self.ralph.getY()>=254.5 and self.ralph.getY()<=255.5) and self.flag[3]==0):
self.banana[3].removeNode()
nob= nob + 1
points= points + 10
self.flag[3]=1
elif ((self.ralph.getX()>=0.5 and self.ralph.getX()<=1.5) and (self.ralph.getY()>=204.5 and self.ralph.getY()<=205.5) and self.flag[1]==0):
self.banana[1].removeNode()
nob= nob + 1
points= points + 10
self.flag[1]=1
elif ((self.ralph.getX()>=-1.5 and self.ralph.getX()<=-0.5) and (self.ralph.getY()>=379.5 and self.ralph.getY()<=380.5) and self.flag[8]==0):
self.banana[8].removeNode()
#print 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
nob= nob + 1
points= points + 10
self.flag[8]=1
elif ((self.ralph.getX()>=-1.5 and self.ralph.getX()<=-0.5) and (self.ralph.getY()>=329.5 and self.ralph.getY()<=330.5) and self.flag[6]==0):
self.banana[6].removeNode()
nob= nob + 1
points= points + 10
self.flag[6]=1
elif ((self.ralph.getX()>=-1.5 and self.ralph.getX()<=-0.5) and (self.ralph.getY()>=279.5 and self.ralph.getY()<=280.5) and self.flag[4]==0):
self.banana[4].removeNode()
nob= nob + 1
points= points + 10
self.flag[4]=1
elif ((self.ralph.getX()>=-1.5 and self.ralph.getX()<=-0.5) and (self.ralph.getY()>=229.5 and self.ralph.getY()<=230.5) and self.flag[2]==0):
self.banana[2].removeNode()
nob= nob + 1
points= points + 10
self.flag[2]=1
elif ((self.ralph.getX()>=-1.5 and self.ralph.getX()<=-0.5) and (self.ralph.getY()>=179.5 and self.ralph.getY()<=180.5) and self.flag[0]==0):
self.banana[0].removeNode()
nob= nob + 1
points= points + 10
self.flag[0]=1
elif ((self.ralph.getX()>=-0.5 and self.ralph.getX()<=0.5) and (self.ralph.getY()>=119.5 and self.ralph.getY()<=120.5) and self.flag[12]==0):
self.banana[12].removeNode()
nob= nob + 1
points= points + 10
self.flag[12]=1
elif ((self.ralph.getX()>=11.5 and self.ralph.getX()<=12.5) and (self.ralph.getY()>=99.5 and self.ralph.getY()<=100.5) and self.flag[13]==0):
self.banana[13].removeNode()
nob= nob + 1
points= points + 10
self.flag[13]=1
elif ((self.ralph.getX()>=21.5 and self.ralph.getX()<=22.5) and (self.ralph.getY()>=79.5 and self.ralph.getY()<=80.5) and self.flag[14]==0):
self.banana[14].removeNode()
nob= nob + 1
points= points + 10
self.flag[14]=1
elif ((self.ralph.getX()>=11.5 and self.ralph.getX()<=12.5) and (self.ralph.getY()>=49.5 and self.ralph.getY()<=50.5) and self.flag[15]==0):
self.banana[15].removeNode()
nob= nob + 1
points= points + 10
self.flag[15]=1
elif ((self.ralph.getX()>=14.5 and self.ralph.getX()<=15.5) and (self.ralph.getY()>=29.5 and self.ralph.getY()<=30.5) and self.flag[16]==0):
self.banana[16].removeNode()
nob= nob + 1
points= points + 10
self.flag[16]=1
elif ((self.ralph.getX()>=-10.5 and self.ralph.getX()<=-9.5) and (self.ralph.getY()>=7.5 and self.ralph.getY()<=8.5) and self.flag[17]==0):
self.banana[17].removeNode()
nob= nob + 1
points= points + 10
self.flag[17]=1
elif ((self.ralph.getX()>=-20.5 and self.ralph.getX()<=-19.5) and (self.ralph.getY()>=-30.5 and self.ralph.getY()<=-29.5) and self.flag[18]==0):
self.banana[18].removeNode()
nob= nob + 1
points= points + 10
self.flag[18]=1
elif ((self.ralph.getX()>=-50.5 and self.ralph.getX()<=-49.5) and (self.ralph.getY()>=-50.5 and self.ralph.getY()<=-49.5) and self.flag[19]==0):
self.banana[19].removeNode()
nob= nob + 1
points= points + 10
self.flag[19]=1
if(self.ralph.getX()>30 and self.ralph.getY()<-200 and noba <8):
self.boy.loop("anim")
#self.ralph.removeNode()
OnscreenText(text="Game Over (n)-Sad!", style=1, fg=(1,1,1,1), pos=(0,0), align=TextNode.ACenter, scale = 0.4)
OnscreenText(text="You've Failed this City! \nTask not Completed", style=1, fg=(1,1,1,1), pos=(0,-0.20), align=TextNode.ACenter, scale = 0.05)
OnscreenText(text="This is a Akshay Arun Shubham Production!", style=1, fg=(1,1,1,1), pos=(0,-0.40), align=TextNode.ACenter, scale = 0.05)
elif(self.ralph.getX()>30 and self.ralph.getY()<-200 and noba ==8):
#self.ralph.removeNode()
OnscreenText(text="Game Over", style=1, fg=(1,1,1,1), pos=(0,0), align=TextNode.ACenter, scale = 0.4)
OnscreenText(text="Congratulations, Task Completed", style=1, fg=(1,1,1,1), pos=(0,-0.20), align=TextNode.ACenter, scale = 0.05)
OnscreenText(text="This is a Akshay Arun Shubham Production!", style=1, fg=(1,1,1,1), pos=(0,-0.40), align=TextNode.ACenter, scale = 0.05)
self.updateStatusLabel()
return Task.cont
#Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def move(self, task):
if(self.ralph.getY()<160):
# If the camera-left key is pressed, move camera left.
# If the camera-right key is pressed, move camera right.
base.camera.lookAt(self.ralph)
if (self.keyMap["cam-left"]!=0):
base.camera.setX(base.camera, -20 * globalClock.getDt())
if (self.keyMap["cam-right"]!=0):
base.camera.setX(base.camera, +20 * globalClock.getDt())
# save ralph's initial position so that we can restore it,
# in case he falls off the map or runs into something.
startpos = self.ralph.getPos()
# If a move-key is pressed, move ralph in the specified direction.
if (self.keyMap["left"]!=0):
self.ralph.setH(self.ralph.getH() + 300 * globalClock.getDt())
if (self.keyMap["right"]!=0):
self.ralph.setH(self.ralph.getH() - 300 * globalClock.getDt())
if (self.keyMap["forward"]!=0):
self.ralph.setY(self.ralph, -25 * globalClock.getDt())
# If ralph is moving, loop the run animation.
# If he is standing still, stop the animation.
if (self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0):
if self.isMoving is False:
self.ralph.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.ralph.stop()
self.ralph.pose("walk",5)
self.isMoving = False
else:
# If the camera-left key is pressed, move camera left.
# If the camera-right key is pressed, move camera right.
base.camera.lookAt(self.ralph)
startpos = self.ralph.getPos()
# If a move-key is pressed, move ralph in the specified direction.
if ((self.keyMap["left"]!=0) and self.ralph.getX()<2.5):
self.ralph.setH(self.ralph.getH() + 200 * globalClock.getDt())
if ((self.keyMap["right"]!=0) and self.ralph.getX()>-2.5):
self.ralph.setH(self.ralph.getH() - 200 * globalClock.getDt())
if ((self.keyMap["forward"]!=0) and self.ralph.getX()>-3 and self.ralph.getX()<3):
self.ralph.setY(self.ralph, -25 * globalClock.getDt())
elif (self.ralph.getX()<-3):
self.ralph.setX(-2.9)
elif (self.ralph.getX()>3):
self.ralph.setX(2.9)
# If ralph is moving, loop the run animation.
# If he is standing still, stop the animation.
if (self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0):
if self.isMoving is False:
self.ralph.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.ralph.stop()
self.ralph.pose("walk",5)
self.isMoving = False
camvec = self.ralph.getPos() - base.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if (camdist > 10.0):
base.camera.setPos(base.camera.getPos() + camvec*(camdist-10))
camdist = 10.0
if (camdist < 5.0):
base.camera.setPos(base.camera.getPos() - camvec*(5-camdist))
camdist = 5.0
return task.cont
def updateStatusLabel( self ):
global nob, points
self.noOfbanana.setText("Bananas Taken: " + str(nob))
self.points.setText("Energy Meter: " + str(points))
self.noOfBalls.setText("Balls found: " + str(noba))
class World(DirectObject):
def __init__(self):
self.itemID = 0
self.switchState = True
self.iAktion = "E"
self.altIPos = [0,0]
self.switchCam = False
self.kampf = Battle.Kampf()
self.itemDa = False
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.spieler = Players.Player(Actor("models/box.x"))
self.spieler.actor.reparentTo(render)
spielerStartPos = (-107.575, 26.6066, -0.490075)
self.spieler.actor.setPos(spielerStartPos)
self.textObjectSpieler = OnscreenText(text = self.spieler.name+": "+str(self.spieler.energie)+"/"+str(self.spieler.maxenergie)+" HP", pos = (-0.90, -0.98), scale = 0.07, fg = (1,0,0,1))
# Erstellt Gegner
self.gegnerStartPos = ([(-39.1143569946,25.1781406403,-0.136657714844),
(-102.375793457,-30.6321983337,0.0),
(-56.927986145, -34.6329650879, -0.16748046875),
(-79.6673126221,30.8231620789,2.89721679688),
(-4.37648868561,30.5158863068,2.18450927734),
(22.6527004242,4.99837779999,3.11364746094),
(-23.8257598877,-7.87773084641,1.36920166016),
(-80.6140823364,19.5769443512,4.70764160156),
(-75.0773696899,-15.2991075516,6.24676513672)
])
gegnerPos = random.choice(self.gegnerStartPos)
self.gegnerErstellen(gegnerPos)
self.textObjectGegner = OnscreenText(text = str(self.gegner.name)+": "+str(self.gegner.energie)+"/"+str(self.gegner.maxenergie)+" HP", pos = (0.90, -0.98), scale = 0.07, fg = (1,0,0,1))
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
self.item = None
# Handling der Usereingaben für Bewegung
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("i", self.setKey, ["inventar",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
self.accept("e", self.iAktionsHandler,["e"])
self.accept("v", self.iAktionsHandler,["v"])
self.accept("w", self.iAktionsHandler,["w"])
taskMgr.add(self.move,"moveTask")
taskMgr.add(self.erkenneKampf,"Kampferkennung")
taskMgr.add(self.screentexts,"Screentexte")
# Menü erstellen
self.createMenu()
# Kameraeinstellungen
base.disableMouse()
base.camera.setPos(self.spieler.actor.getX(),self.spieler.actor.getY()+10,2)
self.collisionInit();
self.setAI()
# Licht
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Hintergrund (Himmel)
self.setupSkySphere()
def iAktionsHandler(self,key):
if key == "e":
self.iAktion = "E"
elif key == "w":
self.iAktion = "W"
elif key == "v":
self.iAktion = "V"
def collisionInit(self):
# Kollisionserkennung, um auf dem Boden zu laufen. Der Collisionray
# erkennt die Hoehe des Gelaendes und wenn ein Objekt da ist, wird
# die Bewegung als illegal gewertet.
self.cTrav = CollisionTraverser()
self.spielerGroundRay = CollisionRay()
self.spielerGroundRay.setOrigin(0,0,1000)
self.spielerGroundRay.setDirection(0,0,-1)
self.spielerGroundCol = CollisionNode('spielerRay')
self.spielerGroundCol.addSolid(self.spielerGroundRay)
self.spielerGroundCol.setFromCollideMask(BitMask32.bit(0))
self.spielerGroundCol.setIntoCollideMask(BitMask32.allOff())
self.spielerGroundColNp = self.spieler.actor.attachNewNode(self.spielerGroundCol)
self.spielerGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.spielerGroundColNp, self.spielerGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
self.gegnerGroundRay = CollisionRay()
self.gegnerGroundRay.setOrigin(0,0,1000)
self.gegnerGroundRay.setDirection(0,0,-1)
self.gegnerGroundCol = CollisionNode('gegnerRay')
self.gegnerGroundCol.addSolid(self.gegnerGroundRay)
self.gegnerGroundCol.setFromCollideMask(BitMask32.bit(0))
self.gegnerGroundCol.setIntoCollideMask(BitMask32.allOff())
self.gegnerGroundColNp = self.gegner.actor.attachNewNode(self.gegnerGroundCol)
self.gegnerGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.gegnerGroundColNp, self.gegnerGroundHandler)
def setupSkySphere(self):
self.skysphere = loader.loadModel("models/LinearPinkSkySphere.bam")
# Textur für den Himmel laden
self.sky_tex = loader.loadTexture("Images/Sterne.jpg")
# Himmel Textur konfigurieren
self.skysphere.setTexture(self.sky_tex, 1)
self.skysphere.setBin('background', 1)
self.skysphere.setDepthWrite(0)
self.skysphere.reparentTo(render)
self.skysphere.setScale(40)
taskMgr.add(self.skysphereTask, "SkySphere Task")
def skysphereTask(self, task):
self.skysphere.setPos(base.camera, 0, 0, 0)
return task.cont
def createMenu(self):
self.createFrame()
itemListe = self.spieler.inventar.anzeigen(1)
standardpos = [0.18, 0.98, 0.83]
self.buttonListe = []
beutelLabel = DirectLabel(text = itemListe[0][0], pos = (0.18, 0.98, 0.95), scale = 0.07, text_fg = (1,0,0,1), text_bg = (0, 50, 50, 1), textMayChange = 1)
del itemListe [0][0]
for zeile in range(4):
for i in range(0,5):
Button = DirectButton(text = itemListe [zeile] [i], pos = standardpos, scale = 0.07, text_fg = (1,0,0,1), text_bg = (0, 50, 50, 1), textMayChange = 1, extraArgs = [zeile,i], command = self.inventarAktion)
self.buttonListe.append (Button)
standardpos[0] += 0.25
standardpos[0] = 0.18
standardpos[2] -= 0.15
def createFrame(self):
self.myFrame = DirectFrame(frameColor=(0, 50, 50, 0.5),
frameSize=(-1, 1, -.7, 1),
pos=(1, -1, 1))
def inventarAktion(self,zeile,spalte):
if self.iAktion == "E":
self.spieler.inventar.entfernen(1,[zeile,spalte])
self.myFrame.destroy()
i = 0
for item in self.buttonListe:
self.buttonListe [i].destroy()
i += 1
del self.buttonListe[:]
self.createMenu()
elif self.iAktion == "W":
self.altIPos = [zeile,spalte]
elif self.iAktion == "V":
self.spieler.inventar.verschieben(1,1,self.altIPos,[zeile,spalte])
self.myFrame.destroy()
i = 0
for item in self.buttonListe:
self.buttonListe [i].destroy()
i += 1
del self.buttonListe[:]
self.createMenu()
# Erkennt den Status der Eingabe
def setKey(self, key, value):
self.keyMap[key] = value
def screentexts(self,task):
self.textObjectSpieler.destroy()
self.textObjectSpieler = OnscreenText(text = self.spieler.name+": "+str(self.spieler.energie)+"/"+str(self.spieler.maxenergie)+" HP", pos = (-0.90, -0.98), scale = 0.07, fg = (1,0,0,1))
self.textObjectGegner.destroy()
if self.kampf.active == True:
self.textObjectGegner = OnscreenText(text = str(self.gegner.name)+": "+str(self.gegner.energie)+"/"+str(self.gegner.maxenergie)+" HP", pos = (0.90, -0.98), scale = 0.07, fg = (1,0,0,1))
else:
self.textObjectGegner = OnscreenText(text = "Kein Gegner vorhanden", pos = (0.90, -0.98), scale = 0.07, fg = (1,0,0,1))
return Task.cont
def camera(self):
# cam-left Key: Kamera nach links
# cam-right Key: Kamera nach rechts
base.camera.lookAt(self.spieler.actor)
if (self.keyMap["cam-left"]!=0):
base.camera.setX(base.camera, -20 * globalClock.getDt())
if (self.keyMap["cam-right"]!=0):
base.camera.setX(base.camera, +20 * globalClock.getDt())
# Wenn die Kamera zu weit weg ist, zoom heran.
# Wenn die Kamera zu nah dran ist, zoom weg.
camvec = self.spieler.actor.getPos() - base.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if (camdist > 10.0):
base.camera.setPos(base.camera.getPos() + camvec*(camdist-10))
camdist = 10.0
if (camdist < 5.0):
base.camera.setPos(base.camera.getPos() - camvec*(5-camdist))
camdist = 5.0
# Haelt die Kamera einen Schritt über dem Boden
# oder zwei Schritte ueber dem Spieler, je nachdem, was groesser ist.
entries = []
for i in range(self.camGroundHandler.getNumEntries()):
entry = self.camGroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"):
base.camera.setZ(entries[0].getSurfacePoint(render).getZ()+1.0)
if (base.camera.getZ() < self.spieler.actor.getZ() + 2.0):
base.camera.setZ(self.spieler.actor.getZ() + 2.0)
# Die Kamera soll in die Richtung des Spielers gucken, aber auch
# immer horizontal bleiben.
self.floater.setPos(self.spieler.actor.getPos())
self.floater.setZ(self.spieler.actor.getZ() + 2.0)
base.camera.lookAt(self.floater)
def collisions(self,startpos):
# Überprüfen auf Itemkollision
if self.item <> None:
if (self.item.actor.getX() - self.spieler.actor.getX() < 1
and self.item.actor.getY() - self.spieler.actor.getY() < 1
and self.item.actor.getZ() - self.spieler.actor.getZ() <1
and self.itemDa == True):
self.itemDa = False
self.item.actor.detachNode()
self.spieler.inventar.einfuegen(self.item)
self.myFrame.destroy()
del self.buttonListe[:]
self.createMenu()
# Start der Kollisionserkennung
self.cTrav.traverse(render)
# Aendert die Z Koordinate des Spielers. Wenn er etwas trifft, bewegt
# ihn entsprechend, wenn er nichts trifft, setzt die Koordinate
# auf den Stand des letzten Frames
self.dummyMethode(self.spielerGroundHandler, self.spieler.actor,startpos)
def move(self,task):
self.camera();
# Speichert die Startposition, damit der Spieler zurueckgesetzt
# werden kann, sollte er irgendwo runterfallen
startpos = self.spieler.actor.getPos()
# Wenn einer der Move Keys gedrueckt wird, wird der Spieler
# in die ensprechende Richtung bewegt
if (self.keyMap["left"]!=0):
self.spieler.actor.setH(self.spieler.actor.getH() + 150 * globalClock.getDt())
if (self.keyMap["right"]!=0):
self.spieler.actor.setH(self.spieler.actor.getH() - 150 * globalClock.getDt())
if (self.keyMap["forward"]!=0):
self.spieler.actor.setY(self.spieler.actor, -12 * globalClock.getDt())
self.collisions(startpos);
return Task.cont
def gegnermove(self):
# Zeit seit dem letzten Frame. Benötigt fuer
# framerateunabhaengige Bewegung.
elapsed = globalClock.getDt()
startpos = self.gegner.actor.getPos()
# Aendert die Z Koordinate des Gegners. Wenn er etwas trifft, bewegt
# ihn entsprechend, wenn er nichts trifft, setzt die Koordinate
# auf den Stand des letzten Frames
self.cTrav.traverse(render)
self.dummyMethode(self.gegnerGroundHandler, self.gegner.actor,startpos)
self.gegner.actor.setP(0)
if self.gegner.energie == 0:
return Task.done
else:
return Task.cont
def dummyMethode(self, handler, actor,startpos):
entries = []
for i in range(handler.getNumEntries()):
entry = handler.getEntry(i)
entries.append(entry)
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"):
actor.setZ(entries[0].getSurfacePoint(render).getZ())
else:
actor.setPos(startpos)
def setAI(self):
# Erstellt die AI World
self.AIworld = AIWorld(render)
self.AIchar = AICharacter("gegner",self.gegner.actor, 100, 0.02, 1)
self.AIworld.addAiChar(self.AIchar)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.AIbehaviors.wander(360, 0, 15, 1.0)
#AI World update zum Tasknamager hinzufügen
taskMgr.add(self.AIUpdate,"AIUpdate")
# Update der AI World
def AIUpdate(self,task):
if self.kampf.active == False:
self.AIworld.update()
self.gegnermove()
return Task.cont
# Startet bei einem Abstand von 4 zwischen Spieler und Gegner einen Kampf
def erkenneKampf(self,task):
if (self.spieler.actor.getX() - self.gegner.actor.getX() < 4
and self.spieler.actor.getX() - self.gegner.actor.getX() > -4
and self.kampf.active == False):
self.kampf.active = True
self.startzeit = globalClock.getLongTime()
if self.kampf.active == True:
self.Kampf(self)
if self.gegner.energie == 0:
return Task.done
else:
return Task.cont
def gegnerErstellen(self,pos):
self.gegner = Monster.Goblin(Actor("models/box.x"))
self.gegner.actor.reparentTo(render)
self.gegner.actor.setPos(pos)
self.gegnerAltPos = pos
self.setAI()
def gegnerTod(self):
self.kampf.active = False
itemPos = self.gegner.actor.getPos()
self.gegner.actor.detachNode()
self.item = Items.Axt()
self.item.ID = self.itemID
self.itemID += 1
self.itemDa = True
self.item.actor.setScale(0.3)
self.item.actor.reparentTo(render)
self.item.actor.setPos(itemPos)
gegnerNeuPos = random.choice(self.gegnerStartPos)
while gegnerNeuPos == self.gegnerAltPos:
gegnerNeuPos = random.choice(self.gegnerStartPos)
self.gegnerErstellen(gegnerNeuPos)
# Lässt Spieler und Gegner nach bestimmter Zeit Aktionen ausführen. Bei Tod des
# Gegners wird ein neuer Gegner sowie ein Item generiert
def Kampf(self,task):
if ((int(globalClock.getLongTime()) - int(self.startzeit)) % 5 == 0
and self.kampf.active == True):
erg = self.kampf.Kampf(self.spieler,self.gegner)
self.spieler = erg[0]
self.gegner = erg[1]
self.startzeit -= 1
if self.spieler.energie == 0:
sys.exit
elif self.gegner.energie == 0:
self.gegnerTod();
if self.startzeit <= 0:
self.startzeit = globalClock.getLongTime()
class Keyboard(object):
def __init__(self, state=None, *a, **k):
super(Keyboard, self).__init__(*a, **k)
if state:
self.state = state
self.active = False
self.cfg = GlobalConf().path('game.player0.keys')
self.keys_txt = {
'on_move_forward': (1, "Forward"),
'on_move_backward': (2, "Backward"),
'on_strafe_left': (3, "Strafe left"),
'on_strafe_right': (4, "Strafe right"),
'on_steer_left': (5, "Steer left"),
'on_steer_right': (6, "Steer right"),
'on_throw_weapon': (7, "Throw weapon"),
'on_place_stick': (8, "Place stick"),
'on_feed': (9, "Feed"),
'on_jump': (10, "Jump"),
'on_run': (11, "Run"),
'on_hit': (12, "Hit")
}
def get_key_name(self, event):
if event is None or event == 'no-event':
return "?"
else:
return event[6:]
def do_paint(self):
tx_scale = (0.6, 0.6)
init = -0.15
dif = -0.06
self.keys_btn = {}
self.keys_lab = {}
for func, (i, bt_text) in self.keys_txt.iteritems():
self.keys_btn[func] = DirectButton(
text=bt_text,
text_font=self.state.font,
text_scale=tx_scale,
text_align=TextNode.ARight,
scale=.1,
pos=(0.3, 0, init + dif * i),
relief=None,
command=lambda func=func: self.det_key(func))
self.keys_lab[func] = OnscreenText(text=self.get_key_name(
self.cfg.child(func).value),
font=self.state.font,
align=TextNode.ALeft,
pos=(0.7, init + dif * i),
scale=0.07)
self.cfg.child(func).on_conf_change += (self.on_key_change)
self.info_txt = OnscreenText(text='Select action',
font=self.state.font,
pos=(0.4, init + dif * 13 - 0.02),
scale=0.04)
self.active = True
def do_enable(self):
if self.active:
for n in self.keys_btn.itervalues():
n.setProp('state', DGG.NORMAL)
def do_disable(self):
if self.active:
for n in self.keys_btn.itervalues():
n.setProp('state', DGG.DISABLED)
def do_destroy(self):
for n in self.keys_btn.itervalues():
n.destroy()
for n in self.keys_lab.itervalues():
n.destroy()
self.info_txt.destroy()
self.active = False
self.on_key_change.disconnect_sources()
def det_key(self, key):
# Deactivate all buttons
self.state.do_disable()
self.keys_lab[key].setText('?')
self.info_txt.setText('Click any key to config')
self.slot = self.state.events.on_any_event.connect(
lambda ev, *a, **k: self.get_key(ev, key))
def get_key(self, ev, key):
if is_key_event(ev):
self.state.do_enable()
self.state.events.on_any_event -= self.slot
for c in self.cfg.childs():
if c.value == ev:
c.set_value('no-event')
self.cfg.child(key).set_value(ev)
@slot
def on_key_change(self, cfg):
if self.keys_lab[cfg.name]:
self.keys_lab[cfg.name].setText(self.get_key_name(cfg.value))
self.info_txt.setText('Select button')
class PhilosophicalDiners(ShowBase):
def __init__(self):
ShowBase.__init__(self)
#
self.wp = WindowProperties()
self.wp.setSize(1280, 720)
base.win.requestProperties(self.wp)
self.fork_height = 2.3
self.frame_time = 0.0
self.textObject = OnscreenText(text='',
pos=(-1.0, 0.9), scale = 0.10, fg=(255, 255, 255, 200))
# create sockets, get h constants
self.p_constants = get_constants()
self.context, self.socket = self._create_socket_context()
# Load textures
self.bowl_tex = self.loader.loadTexture(
ASSETS_DIR + "marble.jpg")
self.wood_tex = self.loader.loadTexture(
ASSETS_DIR + "derevo_mebel.jpg")
self.chair_tex = self.loader.loadTexture(
ASSETS_DIR + "02_1.bmp")
self.black_tex = self.loader.loadTexture(ASSETS_DIR + "black.png")
# Load models
# Load environment (really just a plane)
self.environ = self._load_model(
"house", scale=[25, 25, 25], pos=[0, 0, -10])
# Load the "table"
self.table = self._load_model(
"round_table", scale=[27, 27, 14], pos=[0, 0, 0])
# Load and place forks, chairs
self._load_forks()
self._load_chairs()
self._load_bowls()
# Apply textures to models
self.environ.setTexture(self.black_tex)
self.table.setTexture(self.wood_tex)
self.table.setTexScale(
TextureStage.getDefault(), 0.005, 0.005)
# Start sim
self.rnum = 0
self.philos = subprocess.Popen("./philos", shell=True)
# Tasks
self.taskMgr.add(self.spin_camera, "spin_camera")
self.taskMgr.add(self._comm, "comm")
def _comm(self, task):
"""Communicate with sim
This is a blocking function
"""
if task.time - self.frame_time > 0.35:
self.socket.send("Hello") # Send generic request
# Get message, if wait longer than timeout, quit
try:
message = self.socket.recv()
except zmq.error.Again:
for fork in self.forks:
fork.setZ(self.fork_height)
raw_input(
"Looks like everyone is done! Press enter to exit . . .")
exit(0)
if self.p_constants["VERBOSE"]:
print "Received reply ", self.rnum, "[", message, "]"
self._anim_fork(int(message[0]), int(message[2]))
self._anim_bowl(int(message[1]), int(message[2]))
self.rnum += 1
self.frame_time = task.time
return Task.cont
def _anim_bowl(self, bowl_num, fork_pos):
bowl_num = (bowl_num + 1) % self.p_constants["NPHILOSOPHERS"]
self.textObject.destroy()
ost = "\n".join(["{} has eaten {} meals".format(
n, self.bowls[n]["meals"]) for n in xrange(self.p_constants["NPHILOSOPHERS"])])
self.textObject = OnscreenText(text=ost,
pos=(-1.26, 0.9), scale=0.08, fg=(130, 130, 130, 125))
if fork_pos:
self.bowls[bowl_num]["num_up"] += 1
else:
self.bowls[bowl_num]["num_up"] -= 1
if self.bowls[bowl_num]["num_up"] == 2:
self.bowls[bowl_num]["meals"] += 1
self.bowls[bowl_num]["bowl"].setPos(*self.bowls[bowl_num]["pos"])
else:
self.bowls[bowl_num]["bowl"].setPos(*[100, 100, 100])
def _anim_fork(self, fork_num, fork_pos):
curr_Z = self.forks[fork_num].getZ()
self.forks[fork_num].setZ(curr_Z + 1 if fork_pos else curr_Z - 1)
def _load_model(self, name, **kwargs):
"""Load name.egg as name as name in self.models
Also sets scale, pos, and/or hpr as per kwargs
"""
model = self.loader.loadModel(ASSETS_DIR + name)
model.reparentTo(self.render)
if kwargs.get("scale"):
assert len(kwargs.get("scale")) == 3
assert isinstance(kwargs.get("scale"), list)
model.setScale(*kwargs.get("scale"))
if kwargs.get("pos"):
assert len(kwargs.get("pos")) == 3
assert isinstance(kwargs.get("pos"), list)
model.setPos(*kwargs.get("pos"))
if kwargs.get("hpr"):
assert len(kwargs.get("hpr")) == 3
assert isinstance(kwargs.get("hpr"), list)
model.setHpr(*kwargs.get("hpr"))
if kwargs.get("H"):
assert isinstance(kwargs.get("H"), float)
model.setH(model, kwargs.get("H"))
return model
def _load_forks(self):
"""Load and place forks"""
self.forks = self.p_constants["NPHILOSOPHERS"] * [0]
for i in xrange(self.p_constants["NPHILOSOPHERS"]):
x, y, angle = self._get_fork_coord(i)
self.forks[i] = self._load_model(
"fork", scale=[3, 3, 3], pos=[x, y, self.fork_height], H=rad2deg(angle) + 90)
def _load_chairs(self):
"""Load and place chairs"""
self.chairs = self.p_constants["NPHILOSOPHERS"] * [0]
for i in xrange(self.p_constants["NPHILOSOPHERS"]):
x, y, angle = self._get_chair_coord(i, 5.0)
self.chairs[i] = self._load_model(
"chair1", scale=[7, 7, 7], pos=[x, y - 1, 0], H=rad2deg(angle) + 15)
self.chairs[i].setTexture(self.chair_tex)
self.chairs[i].setTexScale(
TextureStage.getDefault(), 0.005, 0.005)
def _load_bowls(self):
"""Load and place bowls"""
self.bowls = [{} for x in xrange(self.p_constants["NPHILOSOPHERS"])]
for i in xrange(self.p_constants["NPHILOSOPHERS"]):
x, y, angle = self._get_chair_coord(i, 3.6)
self.bowls[i]["bowl"] = self._load_model(
"bowl", scale=[2, 2, 2], pos=[100, 100, 100], H=rad2deg(angle))
self.bowls[i]["pos"] = [x, y - 1, self.fork_height]
self.bowls[i]["num_up"] = 0
self.bowls[i]["meals"] = 0
self.bowls[i]["bowl"].setTexture(self.bowl_tex)
self.bowls[i]["bowl"].setTexScale(
TextureStage.getDefault(), 0.005, 0.005)
def _get_chair_coord(self, num, diam):
"""Do mathemagics to get cartesian coordinates of a fork by its number
on the table
"""
circumf = pi * diam
angle1 = num * 2 * pi / self.p_constants["NPHILOSOPHERS"]
angle2 = (num + 1) * 2 * pi / self.p_constants["NPHILOSOPHERS"]
ang_diff = angle1 - angle2
angle = angle1 + ang_diff / 2
return (circumf / 2 * cos(angle), circumf / 2 * sin(angle), angle)
def _get_fork_coord(self, num):
"""Do mathemagics to get cartesian coordinates of a fork by its number
on the table
"""
circumf = pi * 3.6
angle = num * 2 * pi / self.p_constants["NPHILOSOPHERS"]
return (circumf / 2 * cos(angle), circumf / 2 * sin(angle), angle)
def spin_camera(self, task):
"""Spin the camera around the table"""
angleDegrees = 0 # task.time * 6.0
angleRadians = angleDegrees * (pi / 180.0)
self.camera.setPos(
35 * sin(angleRadians) - 3.3, -27.5 * cos(angleRadians), 16)
self.camera.setHpr(angleDegrees, -30, 0)
return Task.cont
def _create_socket_context(self):
"""Creates context, socket and returns them"""
# Find upper bound on ACTIME from constants and set timeout to double
# that
timeout = int(2000 * self.p_constants["ACTIME_UPPER"])
context = zmq.Context() # Create Context
socket = context.socket(zmq.REQ) # Create socket
# Connect to dining philosophers
socket.connect(self.p_constants["SERV_ADDR"])
socket.RCVTIMEO = timeout # Set timeout
return context, socket
class Screen (object):
def __init__(self, state = None, *a, **k):
super (Screen, self).__init__ (*a, **k)
if state:
self.state = state
self.active = False
self.cfg_p = GlobalConf().child ('panda')
self.cfg_g = GlobalConf().child ('game')
def do_paint (self):
# Get possible screen resolutions NOT AVAILABLE IN OSX
# di = base.pipe.getDisplayInformation()
# for index in range(di.getTotalDisplayModes()):
# sizes += ( str(di.getDisplayModeWidth(index)),
# str(di.getDisplayModeHeight(index))
# )
actual_full = self.cfg_p.child ('fullscreen').value
actual_width = self.cfg_p.child ('width').value
actual_height = self.cfg_p.child ('height').value
self.active = True
self.sizes = [ (640, 480),
(800, 600),
(1024, 768),
(1280, 800),
(1280, 1024),
(1440, 900)
]
self.sizes_tx = []
for h, w in self.sizes:
self.sizes_tx += [str (h)+"x"+str (w)]
# Gets the position of the actual config from self.sizes
init_item = self.sizes.index ((actual_width, actual_height))
#
# TO DO: add images to check buttos
#
# Create a frame
tx_scale = (0.9, 0.9)
self.res_txt = OnscreenText (text = "Resolution",
font = self.state.font,
align = TextNode.ALeft,
pos = (-0.1, -0.4)
)
self.res_menu = DirectOptionMenu (text = "Resolution",
highlightScale = tx_scale,
text_font = self.state.font,
text_scale = tx_scale,
item_text_font = self.state.font,
item_text_scale = tx_scale,
scale = 0.08,
items = self.sizes_tx,
initialitem = init_item,
highlightColor = (0.65,0.65,0.65,1),
command = self.change_res,
pos = (0.5, 0, -0.4)
)
#checked = loader.loadModel ('menu/checked.egg')
#unchecked = loader.loadModel ('menu/unchecked.egg')
self.full_screen = DirectCheckButton (text = "Full screen",
text_font = self.state.font,
text_scale = tx_scale,
#text_pos = (0.5, 0, -0.7),
text_align = TextNode.ALeft,
indicatorValue = self.cfg_p.child ('fullscreen').value,
scale = .08,
relief = None,
boxPlacement = 'right',
boxRelief = None,
#boxImage = (unchecked, checked , None),
#boxImageScale = 0.15,
command = self.change_full,
pos = (-0.1, 0, -0.6)
)
self.fps_display = DirectCheckButton (text = "FPS display",
text_font = self.state.font,
text_scale = tx_scale,
text_align = TextNode.ALeft,
indicatorValue = self.cfg_p.child ('frame-meter').value,
scale = .08,
relief = None,
boxPlacement = 'right',
boxRelief = None,
command = self.change_fps,
pos = (-0.1, 0, -0.75)
)
self.sha_display = DirectCheckButton (text = "Shaders",
text_font = self.state.font,
text_scale = tx_scale,
text_align = TextNode.ALeft,
indicatorValue = self.cfg_g.child ('shader').value,
scale = .08,
relief = None,
boxPlacement = 'right',
boxRelief = None,
command = self.change_shad,
pos = (-0.1, 0, -0.9)
)
def do_enable (self):
pass
def do_disable (self):
pass
def do_destroy (self):
self.res_txt.destroy ()
self.res_menu.destroy ()
self.fps_display.destroy ()
self.full_screen.destroy ()
self.sha_display.destroy ()
self.active = False
def change_shad (self, status):
self.cfg_g.child ('shader').set_value (bool(status))
def change_fps (self, status):
self.cfg_p.child ('frame-meter').set_value (bool(status))
def change_full (self, status):
self.cfg_p.child ('fullscreen').set_value (bool(status))
self.cfg_p.nudge ()
def change_res (self, arg):
i = self.sizes_tx.index(arg)
self.cfg_p.child ('width').set_value (self.sizes[i][0])
self.cfg_p.child ('height').set_value (self.sizes[i][1])
self.cfg_p.nudge ()
class Debug(Tool):
"""Tool for debugging."""
pressed: bool
last_point: Point
hud_text: OnscreenText
card: NodePath
text_dict: Dict[str, str]
selected_agent: Optional[TrafficAgent]
path_np: NodePath
KEY = 'i'
def prepare(self):
"""Initialize tool."""
self.pressed = False
self.last_point = None
self.hud_text = OnscreenText(text='',
pos=(5, -20),
scale=22.0,
fg=(1.0, 1.0, 1.0, 0.9),
shadow=(0.0, 0.0, 0.0, 0.9),
align=TextNode.A_left,
font=p3d.ttf,
parent=p3d.pixel2d,
mayChange=True)
self.card = None
self.text_dict = {
'position': None,
'network_position': None,
'distance': None,
'agent': None
}
self.selected_agent = None
self.path_np = None
self._update_position()
self._update_hud_text()
def on_update(self):
"""Update callback called every frame."""
if self.selected_agent is not None:
self.text_dict['agent'] = \
self.selected_agent.debug_str().replace('\n', '\n' + ' ' * 4)
self._update_hud_text()
def on_button1_press(self):
"""Button 1 pressed callback."""
self.pressed = True
self._update_selection(just_pressed=True)
point = self.cursor.position
if self.last_point is not None:
distance = self.last_point.distance(point)
self.text_dict['distance'] = f'{distance:.2f}'
self.last_point = point
self._update_hud_text()
def on_button1_release(self):
"""Button 1 released callback."""
self.pressed = False
def on_button2_press(self):
"""Button 2 pressed callback."""
self._clear_agent()
self._update_selection(agents_only=True,
follow=False,
just_pressed=True,
show_path=False)
if isinstance(self.selected_agent, Car):
self.selected_agent.remove(INDEX.simulation.ready_buffer,
INDEX.simulation.ready_buffer, False)
self._clear_agent()
def on_button3_press(self):
"""Button 3 pressed callback."""
self._clear_selection()
self._update_hud_text()
def on_cursor_move(self):
"""Cursor moved callback."""
if self.pressed:
self._update_selection()
self._update_position()
self._update_hud_text()
def cleanup(self):
"""Clean up before changing tool."""
self.hud_text.destroy()
self._clear_selection()
def _update_selection(self,
*,
agents_only: bool = False,
follow: bool = True,
just_pressed: bool = False,
show_path: bool = True):
agent_selected = False
if just_pressed and self.cursor.pointed_at:
id_ = int(self.cursor.pointed_at.parent.tags['id'])
agent = INDEX.entities.get(id_, None)
if agent is not None and hasattr(agent, 'debug_str'):
self.selected_agent = agent
agent_selected = True
if show_path:
self._update_path_np()
if follow:
p3d.messenger.send('follow', [agent])
if agents_only:
return
selected = INDEX.get_at(self.cursor.position, of_type=Node)
if selected and just_pressed:
if not agent_selected:
self._clear_intersection()
self.card = create_lane_connections_card(
selected[0], p3d.render)
else:
selected = INDEX.get_at(self.cursor.position, of_type=Way)
try:
selected = selected[0]
except IndexError:
return
self.text_dict['network_position'] = f'{selected} - {selected.xurl}'
if isinstance(selected, Way):
position = selected.way_position_raw(self.cursor.position)
way_position, lane_index = position
lane = selected.lanes[lane_index]
try:
lane_position = lane.way_to_lane_position(way_position)
except ValueError:
lane_position = 0.0
oriented_position = (lane.lane_to_oriented_position(lane_position)
if lane_position is not None else 0.0)
stats = (INDEX.stats[OrientedWay].get(lane.oriented_way, None)
or EMPTY_STATS)
self.text_dict['network_position'] += (
f'\n way_position={way_position:.2f}, '
f'oriented_position={oriented_position:.2f},'
f'\n lane_position={lane_position:.2f}, '
f'lane={lane_index}, '
f'max_speed={mps_to_kph(selected.max_speed):.1f} kph'
f'\n average_speed_kph={stats.average_speed_kph}, '
f'throughput_cars_per_minute='
f'{stats.throughput_cars_per_minute}')
def _clear_selection(self):
"""Clear all seleted objects."""
self._clear_agent()
self._clear_intersection()
self.text_dict['network_position'] = None
self.text_dict['distance'] = None
def _clear_agent(self):
"""Clear current agent selection."""
self.selected_agent = None
self.text_dict['agent'] = None
self._clear_path_np()
def _clear_path_np(self):
"""Clear current path mesh and node path."""
if self.path_np is not None:
self.path_np.remove_node()
self.path_np = None
def _clear_intersection(self):
"""Clear current intersection selection."""
if self.card is not None:
self.card.get_texture().clear()
self.card.remove_node()
self.card = None
def _update_position(self):
self.text_dict['position'] = (f'{self.cursor.position.x:8.2f}, '
f'{self.cursor.position.y:8.2f}')
def _update_path_np(self):
self._clear_path_np()
try:
path = self.selected_agent.path
self.path_np = Factory.create_path(p3d.render, path)
except AttributeError:
pass
def _update_hud_text(self):
self.hud_text.text = '\n'.join(f"\n['{k}']: {v}"
for k, v in self.text_dict.items()
if v is not None)
class TeamActivityGui:
COUNTDOWN_TASK_NAME = 'updateCountdownTask'
timer = None
statusText = None
countdownText = None
exitButton = None
switchButton = None
def __init__(self, activity):
self.activity = activity
def load(self):
buttonModels = loader.loadModel('phase_3.5/models/gui/inventory_gui')
upButton = buttonModels.find('**//InventoryButtonUp')
downButton = buttonModels.find('**/InventoryButtonDown')
rolloverButton = buttonModels.find('**/InventoryButtonRollover')
self.exitButton = DirectButton(relief=None, text=TTLocalizer.PartyTeamActivityExitButton, text_fg=(1, 1, 0.65, 1), text_pos=(0, -0.15), text_scale=0.5, image=(upButton, downButton, rolloverButton), image_color=(1, 0, 0, 1), image_scale=(14.5, 1, 9), pos=(0, 0, 0.8), scale=0.15, command=self.handleExitButtonClick)
self.exitButton.hide()
if self.activity.toonsCanSwitchTeams():
self.switchButton = DirectButton(relief=None, text=TTLocalizer.PartyTeamActivitySwitchTeamsButton, text_fg=(1, 1, 1, 1), text_pos=(0, 0.1), text_scale=0.5, image=(upButton, downButton, rolloverButton), image_color=(0, 1, 0, 1), image_scale=(15, 1, 15), pos=(0, 0, 0.5), scale=0.15, command=self.handleSwitchButtonClick)
self.switchButton.hide()
else:
self.switchButton = None
buttonModels.removeNode()
self.countdownText = OnscreenText(text='', pos=(0.0, -0.2), scale=PartyGlobals.TeamActivityTextScale * 1.2, fg=(1.0, 1.0, 0.65, 1.0), align=TextNode.ACenter, font=ToontownGlobals.getSignFont(), mayChange=True)
self.countdownText.hide()
self.statusText = OnscreenText(text='', pos=(0.0, 0.0), scale=PartyGlobals.TeamActivityTextScale, fg=PartyGlobals.TeamActivityStatusColor, align=TextNode.ACenter, font=ToontownGlobals.getSignFont(), mayChange=True)
self.statusText.hide()
self.timer = PartyUtils.getNewToontownTimer()
self.timer.hide()
return
def unload(self):
self.hideWaitToStartCountdown()
if self.exitButton is not None:
self.exitButton.destroy()
self.exitButton = None
if self.switchButton is not None:
self.switchButton.destroy()
self.switchButton = None
if self.countdownText is not None:
self.countdownText.destroy()
self.countdownText.removeNode()
self.countdownText = None
if self.statusText is not None:
self.statusText.destroy()
self.statusText.removeNode()
self.statusText = None
if self.timer is not None:
self.timer.destroy()
del self.timer
return
def showStatus(self, text):
self.statusText.setText(text)
self.statusText.show()
def hideStatus(self):
self.statusText.hide()
def enableExitButton(self):
self.exitButton.show()
def disableExitButton(self):
self.exitButton.hide()
def handleExitButtonClick(self):
self.disableExitButton()
self.disableSwitchButton()
self.activity.d_toonExitRequest()
def enableSwitchButton(self):
self.switchButton.show()
def disableSwitchButton(self):
if self.switchButton is not None:
self.switchButton.hide()
return
def handleSwitchButtonClick(self):
self.disableSwitchButton()
self.disableExitButton()
self.activity.d_toonSwitchTeamRequest()
def showWaitToStartCountdown(self, duration, waitToStartTimestamp, almostDoneCallback = None):
self._countdownAlmostDoneCallback = almostDoneCallback
currentTime = globalClock.getRealTime()
waitTimeElapsed = currentTime - waitToStartTimestamp
if duration - waitTimeElapsed > 1.0:
countdownTask = Task(self._updateCountdownTask)
countdownTask.duration = duration - waitTimeElapsed
self.countdownText.setText(str(int(countdownTask.duration)))
self.countdownText.show()
taskMgr.remove(TeamActivityGui.COUNTDOWN_TASK_NAME)
taskMgr.add(countdownTask, TeamActivityGui.COUNTDOWN_TASK_NAME)
def hideWaitToStartCountdown(self):
taskMgr.remove(TeamActivityGui.COUNTDOWN_TASK_NAME)
self._countdownAlmostDoneCallback = None
if self.countdownText is not None:
self.countdownText.hide()
return
def _updateCountdownTask(self, task):
countdownTime = int(task.duration - task.time)
seconds = str(countdownTime)
if self.countdownText['text'] != seconds:
self.countdownText['text'] = seconds
if countdownTime == 3 and self._countdownAlmostDoneCallback is not None:
self._countdownAlmostDoneCallback()
self._countdownAlmostDoneCallback = None
if task.time >= task.duration:
return Task.done
else:
return Task.cont
return
def showTimer(self, duration):
self.timer.setTime(duration)
self.timer.countdown(duration, self._handleTimerExpired)
self.timer.show()
def hideTimer(self):
self.timer.hide()
self.timer.stop()
def _handleTimerExpired(self):
self.activity.handleGameTimerExpired()
class Keyboard (object):
def __init__(self, state = None, *a, **k):
super (Keyboard, self).__init__ (*a, **k)
if state:
self.state = state
self.active = False
self.cfg = GlobalConf ().path ('game.player0.keys')
self.keys_txt = {
'on_move_forward' : (1, "Forward"),
'on_move_backward' : (2, "Backward"),
'on_strafe_left' : (3, "Strafe left"),
'on_strafe_right' : (4, "Strafe right"),
'on_steer_left' : (5, "Steer left"),
'on_steer_right' : (6, "Steer right"),
'on_throw_weapon' : (7, "Throw weapon"),
'on_place_stick' : (8, "Place stick"),
'on_feed' : (9, "Feed"),
'on_jump' : (10, "Jump"),
'on_run' : (11, "Run"),
'on_hit' : (12, "Hit")
}
def get_key_name (self, event):
if event is None or event == 'no-event':
return "?"
else:
return event [6:]
def do_paint (self):
tx_scale = (0.6, 0.6)
init = -0.15
dif = -0.06
self.keys_btn = {}
self.keys_lab = {}
for func, (i, bt_text) in self.keys_txt.iteritems ():
self.keys_btn [func] = DirectButton(
text = bt_text,
text_font = self.state.font,
text_scale = tx_scale,
text_align = TextNode.ARight,
scale = .1,
pos = (0.3, 0, init + dif*i),
relief = None,
command = lambda func=func: self.det_key (func)
)
self.keys_lab [func] = OnscreenText(text = self.get_key_name (
self.cfg.child (func).value),
font = self.state.font,
align = TextNode.ALeft,
pos = (0.7, init+dif*i),
scale = 0.07
)
self.cfg.child (func).on_conf_change += (self.on_key_change)
self.info_txt = OnscreenText (text = 'Select action',
font = self.state.font,
pos = (0.4, init+dif*13-0.02),
scale = 0.04
)
self.active = True
def do_enable (self):
if self.active:
for n in self.keys_btn.itervalues ():
n.setProp ('state', DGG.NORMAL)
def do_disable (self):
if self.active:
for n in self.keys_btn.itervalues ():
n.setProp ('state', DGG.DISABLED)
def do_destroy (self):
for n in self.keys_btn.itervalues ():
n.destroy ()
for n in self.keys_lab.itervalues ():
n.destroy ()
self.info_txt.destroy()
self.active = False
self.on_key_change.disconnect_sources ()
def det_key (self, key):
# Deactivate all buttons
self.state.do_disable ()
self.keys_lab [key].setText ('?')
self.info_txt.setText ('Click any key to config')
self.slot = self.state.events.on_any_event.connect (
lambda ev, *a, **k: self.get_key (ev, key))
def get_key (self, ev, key):
if is_key_event (ev):
self.state.do_enable ()
self.state.events.on_any_event -= self.slot
for c in self.cfg.childs ():
if c.value == ev:
c.set_value ('no-event')
self.cfg.child (key).set_value (ev)
@slot
def on_key_change (self, cfg):
if self.keys_lab [cfg.name]:
self.keys_lab [cfg.name].setText (self.get_key_name (cfg.value))
self.info_txt.setText ('Select button')
class PhilosophicalDiners(ShowBase):
def __init__(self):
ShowBase.__init__(self)
#
self.wp = WindowProperties()
self.wp.setSize(1280, 720)
base.win.requestProperties(self.wp)
self.fork_height = 2.3
self.frame_time = 0.0
self.textObject = OnscreenText(text='',
pos=(-1.0, 0.9),
scale=0.10,
fg=(255, 255, 255, 200))
# create sockets, get h constants
self.p_constants = get_constants()
self.context, self.socket = self._create_socket_context()
# Load textures
self.bowl_tex = self.loader.loadTexture(ASSETS_DIR + "marble.jpg")
self.wood_tex = self.loader.loadTexture(ASSETS_DIR +
"derevo_mebel.jpg")
self.chair_tex = self.loader.loadTexture(ASSETS_DIR + "02_1.bmp")
self.black_tex = self.loader.loadTexture(ASSETS_DIR + "black.png")
# Load models
# Load environment (really just a plane)
self.environ = self._load_model("house",
scale=[25, 25, 25],
pos=[0, 0, -10])
# Load the "table"
self.table = self._load_model("round_table",
scale=[27, 27, 14],
pos=[0, 0, 0])
# Load and place forks, chairs
self._load_forks()
self._load_chairs()
self._load_bowls()
# Apply textures to models
self.environ.setTexture(self.black_tex)
self.table.setTexture(self.wood_tex)
self.table.setTexScale(TextureStage.getDefault(), 0.005, 0.005)
# Start sim
self.rnum = 0
self.philos = subprocess.Popen("./philos", shell=True)
# Tasks
self.taskMgr.add(self.spin_camera, "spin_camera")
self.taskMgr.add(self._comm, "comm")
def _comm(self, task):
"""Communicate with sim
This is a blocking function
"""
if task.time - self.frame_time > 0.35:
self.socket.send("Hello") # Send generic request
# Get message, if wait longer than timeout, quit
try:
message = self.socket.recv()
except zmq.error.Again:
for fork in self.forks:
fork.setZ(self.fork_height)
raw_input(
"Looks like everyone is done! Press enter to exit . . .")
exit(0)
if self.p_constants["VERBOSE"]:
print "Received reply ", self.rnum, "[", message, "]"
self._anim_fork(int(message[0]), int(message[2]))
self._anim_bowl(int(message[1]), int(message[2]))
self.rnum += 1
self.frame_time = task.time
return Task.cont
def _anim_bowl(self, bowl_num, fork_pos):
bowl_num = (bowl_num + 1) % self.p_constants["NPHILOSOPHERS"]
self.textObject.destroy()
ost = "\n".join([
"{} has eaten {} meals".format(n, self.bowls[n]["meals"])
for n in xrange(self.p_constants["NPHILOSOPHERS"])
])
self.textObject = OnscreenText(text=ost,
pos=(-1.26, 0.9),
scale=0.08,
fg=(130, 130, 130, 125))
if fork_pos:
self.bowls[bowl_num]["num_up"] += 1
else:
self.bowls[bowl_num]["num_up"] -= 1
if self.bowls[bowl_num]["num_up"] == 2:
self.bowls[bowl_num]["meals"] += 1
self.bowls[bowl_num]["bowl"].setPos(*self.bowls[bowl_num]["pos"])
else:
self.bowls[bowl_num]["bowl"].setPos(*[100, 100, 100])
def _anim_fork(self, fork_num, fork_pos):
curr_Z = self.forks[fork_num].getZ()
self.forks[fork_num].setZ(curr_Z + 1 if fork_pos else curr_Z - 1)
def _load_model(self, name, **kwargs):
"""Load name.egg as name as name in self.models
Also sets scale, pos, and/or hpr as per kwargs
"""
model = self.loader.loadModel(ASSETS_DIR + name)
model.reparentTo(self.render)
if kwargs.get("scale"):
assert len(kwargs.get("scale")) == 3
assert isinstance(kwargs.get("scale"), list)
model.setScale(*kwargs.get("scale"))
if kwargs.get("pos"):
assert len(kwargs.get("pos")) == 3
assert isinstance(kwargs.get("pos"), list)
model.setPos(*kwargs.get("pos"))
if kwargs.get("hpr"):
assert len(kwargs.get("hpr")) == 3
assert isinstance(kwargs.get("hpr"), list)
model.setHpr(*kwargs.get("hpr"))
if kwargs.get("H"):
assert isinstance(kwargs.get("H"), float)
model.setH(model, kwargs.get("H"))
return model
def _load_forks(self):
"""Load and place forks"""
self.forks = self.p_constants["NPHILOSOPHERS"] * [0]
for i in xrange(self.p_constants["NPHILOSOPHERS"]):
x, y, angle = self._get_fork_coord(i)
self.forks[i] = self._load_model("fork",
scale=[3, 3, 3],
pos=[x, y, self.fork_height],
H=rad2deg(angle) + 90)
def _load_chairs(self):
"""Load and place chairs"""
self.chairs = self.p_constants["NPHILOSOPHERS"] * [0]
for i in xrange(self.p_constants["NPHILOSOPHERS"]):
x, y, angle = self._get_chair_coord(i, 5.0)
self.chairs[i] = self._load_model("chair1",
scale=[7, 7, 7],
pos=[x, y - 1, 0],
H=rad2deg(angle) + 15)
self.chairs[i].setTexture(self.chair_tex)
self.chairs[i].setTexScale(TextureStage.getDefault(), 0.005, 0.005)
def _load_bowls(self):
"""Load and place bowls"""
self.bowls = [{} for x in xrange(self.p_constants["NPHILOSOPHERS"])]
for i in xrange(self.p_constants["NPHILOSOPHERS"]):
x, y, angle = self._get_chair_coord(i, 3.6)
self.bowls[i]["bowl"] = self._load_model("bowl",
scale=[2, 2, 2],
pos=[100, 100, 100],
H=rad2deg(angle))
self.bowls[i]["pos"] = [x, y - 1, self.fork_height]
self.bowls[i]["num_up"] = 0
self.bowls[i]["meals"] = 0
self.bowls[i]["bowl"].setTexture(self.bowl_tex)
self.bowls[i]["bowl"].setTexScale(TextureStage.getDefault(), 0.005,
0.005)
def _get_chair_coord(self, num, diam):
"""Do mathemagics to get cartesian coordinates of a fork by its number
on the table
"""
circumf = pi * diam
angle1 = num * 2 * pi / self.p_constants["NPHILOSOPHERS"]
angle2 = (num + 1) * 2 * pi / self.p_constants["NPHILOSOPHERS"]
ang_diff = angle1 - angle2
angle = angle1 + ang_diff / 2
return (circumf / 2 * cos(angle), circumf / 2 * sin(angle), angle)
def _get_fork_coord(self, num):
"""Do mathemagics to get cartesian coordinates of a fork by its number
on the table
"""
circumf = pi * 3.6
angle = num * 2 * pi / self.p_constants["NPHILOSOPHERS"]
return (circumf / 2 * cos(angle), circumf / 2 * sin(angle), angle)
def spin_camera(self, task):
"""Spin the camera around the table"""
angleDegrees = 0 # task.time * 6.0
angleRadians = angleDegrees * (pi / 180.0)
self.camera.setPos(35 * sin(angleRadians) - 3.3,
-27.5 * cos(angleRadians), 16)
self.camera.setHpr(angleDegrees, -30, 0)
return Task.cont
def _create_socket_context(self):
"""Creates context, socket and returns them"""
# Find upper bound on ACTIME from constants and set timeout to double
# that
timeout = int(2000 * self.p_constants["ACTIME_UPPER"])
context = zmq.Context() # Create Context
socket = context.socket(zmq.REQ) # Create socket
# Connect to dining philosophers
socket.connect(self.p_constants["SERV_ADDR"])
socket.RCVTIMEO = timeout # Set timeout
return context, socket
class Labryn(ShowBase):
def setCamera(self, spin):
# set camera spin state
self.spin = spin
def displayInformation(self):
self.title = addTitle("Single Player")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[wasd]: Move")
self.inst3 = addInstructions(0.85, "[q/e]: spin camera")
self.inst4 = addInstructions(0.80, "[z/c]: zoom in/out")
self.inst5 = addInstructions(0.75, "[shift]: hold and pan")
self.inst6 = addInstructions(0.70, "[1/2/3]: use moves")
self.inst7 = addInstructions(0.65, "[h]: hide instructions")
self.insts = [self.title, self.inst1, self.inst2, self.inst3,
self.inst4, self.inst5, self.inst6, self.inst7]
def hideInstructions(self):
if self.instStatus == "show":
self.instStatus = "hide"
groupHide(self.insts)
else: # instructions are hidden
self.instStatus = "show"
groupShow(self.insts)
def loadNextMusic(self, task):
# random load background music
if (self.music.status()!=self.music.PLAYING):
# not playing
self.musicCounter += 1
index = self.musicCounter % len(_BGMUSIC)
self.music = load_bgmusic(_BGMUSIC[index])
self.music.play()
return task.cont
def spinCamera(self, task):
# deal with spinning the camera
# _FOCUS: focus point, changed by panning the camera
# CAM_R: radius, changed by zooming
# cameraSpinCount: amount of spinning, changed by spinning
if self.spin == 1: # spin counter-clockwise
self.cameraSpinCount += 1
angleDegrees = self.cameraSpinCount
angleRadians = angleDegrees * (pi/ 180)
self.CAM_RAD = angleRadians
camera.setPos(_FOCUS[0]+self.CAM_R*cos(-pi/2+self.CAM_RAD),
_FOCUS[1]+self.CAM_R*sin(-pi/2+self.CAM_RAD),
(25.0/12)*self.CAM_R)
camera.setHpr(angleDegrees,-65,0)
elif self.spin == 2: # spin clockwise
self.cameraSpinCount -= 1
angleDegrees = self.cameraSpinCount
angleRadians = angleDegrees * (pi/ 180)
self.CAM_RAD = angleRadians
camera.setPos(_FOCUS[0]+self.CAM_R*cos(-pi/2+self.CAM_RAD),
_FOCUS[1]+self.CAM_R*sin(-pi/2+self.CAM_RAD),
(25.0/12)*self.CAM_R)
camera.setHpr(angleDegrees,-65,0)
elif self.spin == 3: # ZOOM IN not spin
self.cameraZoomCount += 1
deltaR = self.cameraZoomCount * 0.1
new_R = 12-deltaR
self.CAM_R = new_R
camera.setPos(_FOCUS[0] + self.CAM_R*cos(-pi/2+self.CAM_RAD),
_FOCUS[1] + self.CAM_R*sin(-pi/2+self.CAM_RAD),
(25.0/12)*new_R)
elif self.spin == 4: # ZOOM OUT
self.cameraZoomCount -= 1
deltaR = self.cameraZoomCount * 0.1
new_R = 12-deltaR
self.CAM_R = new_R
camera.setPos(_FOCUS[0] + self.CAM_R*cos(-pi/2+self.CAM_RAD),
_FOCUS[1] + self.CAM_R*sin(-pi/2+self.CAM_RAD),
(25.0/12)*self.CAM_R)
return Task.cont
def takeRecord(self):
def myCMP(aString, bString):
a = float(aString.split(',')[0])
b = float(bString.split(',')[0])
return int(10*(a - b))
msg = "%.2f,%s\n" %(self.clock/100.0, time.ctime())
with open('record.txt') as f:
data = f.readlines()
# if has no previous data
if len(data) == 0:
data.append(msg)
with open('record.txt','w') as f:
f.writelines(data)
else:
data.append(msg)
processedData = sorted(data, myCMP)
with open('record.txt', 'w') as f:
f.writelines(processedData)
def printResults(self):
addEndMessage(self.clock)
with open('record.txt') as f:
data = f.readlines()
for i in xrange(0, len(data)):
if i < 5: # only print the top 5
string = data[i]
printRank(i, string)
def checkForWin(self, task):
if (checkWin(self.pikachu.getX(), self.pikachu.getY(),
self.ballRoot.getX(), self.ballRoot.getY()) and
self.gameOver == False):
self.takeRecord()
self.printResults()
self.gameOver = True
# if top 10, if top 1,
print "WIN"
# print previous best 10 results
return Task.cont
def pikachuBark(self, task):
if self.distance < 3:
if random.randint(1,200) == 1:
# randomly bark dangerous sound
if self.dangerous.status() != self.dangerous.PLAYING:
self.dangerous.play()
elif self.distance > 10:
if random.randint(1,430) == 1:
if self.safe.status() != self.safe.PLAYING:
self.safe.play()
return Task.cont
def checkMouse(self, task):
# get mouse position
if base.mouseWatcherNode.hasMouse():
self.mouseX=base.mouseWatcherNode.getMouseX()
self.mouseY=base.mouseWatcherNode.getMouseY()
return Task.cont
def dropRock(self):
# when the user clicks, rock is dropped
if self.pokeMoveChoice == 1: # selected Geodude
result = MAZE.canDropRock(self.rockX, self.rockY)
if result != False: # can place rock here
MAZE.dropRock(result[0],result[1])
self.rock.setPos(self.rockX, self.rockY, 1)
self.rockOnMaze = True
self.pokeMoveChoice = None
self.myPokeName.hide()
self.myPokeName = None
self.updateTwoD()
self.playerCandyCount -= 1
def restart(self):
sys.exit()
def useFlame(self):
# use flame to Pikachu -> cannot move
self.onFire = True # on fire
self.playerCandyCount -= 1
self.pokeStatus = 1
self.flame = ParticleEffect()
self.flame.loadConfig("fireish.ptf")
self.flame.setPos(self.pikachu.getPos())
self.flame.start(parent=render, renderParent=render)
self.updateTwoD()
def useStringShot(self):
# use string shot -> speed goes down
self.pokeStatus = 2
self.updateTwoD()
def useThunder(self):
self.onThunder = True
self.pokeCandyCount -= 1
self.thunder = ParticleEffect()
self.thunder.loadConfig("thunder.ptf")
self.thunder.start(parent=render, renderParent=render)
self.use.play()
def placeRock(self, task):
# rock moves with mouse cursor
if self.pokeMoveChoice == 1: # selected Geodude
dX,dY = ((self.mouseX-self.rockRefX),
(self.mouseY-self.rockRefY))
self.rockX, self.rockY = MAZE.translateRockPosition(self.rockRefX,
self.rockRefY,
dX, dY)
self.rock.show()
self.rock.setPos(self.rockX, self.rockY, 1)
self.updateTwoD()
return Task.cont
def placeRareCandy(self, task):
# place rare candy with interval
# needs to be improved
if int(task.time) % 4 == 9 and self.candyOnBoard:
self.candy.hide()
self.candyOnBoard = False
MAZE.clearCandy()
if int(task.time) % 10 == 0 and (self.candyOnBoard == False):
# every 10 seconds
self.candy.setPos(MAZE.generateCandyPos())
self.candy.show()
self.candyOnBoard = True
return Task.cont
def updateTwoD(self):
# update player candy count
self.playerCandyStatus.destroy()
self.playerCandyStatus = candyStatus(0, self.playerCandyCount)
self.pokeCandyStatus.destroy()
self.pokeCandyStatus = candyStatus(1, self.pokeCandyCount)
# update my pokes color
if self.playerCandyCount == 0 :
groupHide(self.myPokesBright)
groupShow(self.myPokesDark)
# update name
if self.myPokeName != None:
self.myPokeName.destroy()
def clearRock(self):
# clear rock
self.rock.hide()
self.rockOnMaze = False
MAZE.clearRock() # clear it in 2D
def clearFlame(self):
# clear flame
self.onFire = False
self.flame.cleanup()
self.pokeStatus = 0
self.pokeMoveChoice = None
try:
self.myPokeName.destroy()
except:
pass
self.myPokeName = None
def clearString(self):
# clear string shot
self.pokeStatus = 0
self.pokeMoveChoice = None
try:
self.myPokeName.destroy()
except:
pass
self.myPokeName = None
def clearThunder(self):
self.onThunder = False
try:
self.thunder.cleanup()
except:
pass
def timer(self, task): # deals with moves' lasting effects
##############################################################
self.clock += 1
if self.rockOnMaze: # rock on maze
self.rockCounter += 1
elif self.rockCounter != 1: # rock not on maze, counter not cleared
self.rockCounter = 0
if self.onFire:
self.fireCounter += 1
elif self.fireCounter != 1:
self.fireCounter = 0
if self.pokeStatus == 2: # string shot
self.stringCounter += 1
elif self.stringCounter != 1:
self.stringCounter = 0
if self.onThunder: # thunderbolt
self.thunderCounter += 1
elif self.thunderCounter != 1:
self.thunderCounter = 0
if self.gameOver == True: # game is over
self.gameOverCounter += 1
##################################################################
if self.rockCounter >= 100:
self.clearRock()
if self.fireCounter >= 80:
self.clearFlame()
if self.thunderCounter >= 150:
self.clearThunder()
if self.stringCounter >= 120:
self.clearString()
if self.gameOverCounter >= 800: # quit the game
sys.exit()
return Task.cont
def usePokeMove(self, number):
# use pokemon move
if self.playerCandyCount > 0: # have more than one candy
if number == 1 and self.rockOnMaze == False:
if self.pokeMoveChoice == None: # no choice
# set to center position
centerx = base.win.getProperties().getXSize()/2
centery = base.win.getProperties().getYSize()/2
base.win.movePointer(0,centerx,centery)
self.pokeMoveChoice = 1 # placeRock called here
self.rockRefX, self.rockRefY = 0,0
self.rock.show()
self.rock.setPos(0,0,1)
elif self.pokeMoveChoice != 1:
pass
else: # self.pokeMoveChoice is already 1, cancel the choice
self.pokeMoveChoice = None
self.clearRock() # clear rock
elif number == 2:
if self.pokeMoveChoice == None:
self.pokeMoveChoice = 2
self.useFlame()
elif self.pokeMoveChoice != 2:
pass
else:
self.pokeMoveChoice = None
elif number == 3:
if self.pokeMoveChoice == None:
self.pokeMoveChoice = 3
self.useStringShot()
elif self.pokeMoveChoice != 3:
pass
else: # already 3
self.pokeMoveChoice = None
if self.pokeMoveChoice == None: # no choice
if self.myPokeName != None: # there is a name on board
self.myPokeName.destroy() # kill it
else: # no name
pass
else: # there is a choice
if self.myPokeName != None:
self.myPokeName.destroy()
self.myPokeName = writePokeName(self.pokeMoveChoice)
def loadRareCandy(self):
# load rare candy (a box)
# needs to be improved
self.candy = Model_Load.loadRareCandy()
self.candy.reparentTo(render)
self.candy.setScale(0.1)
self.candy.hide()
def eatRareCandy(self, task):
# check who eats candy
if self.candyOnBoard: # candy on board
if checkEat(self.ballRoot.getX(), self.ballRoot.getY(),
self.candy.getX(), self.candy.getY()): # ball eats
self.candy.hide() # eaten
self.candyOnBoard = False
if self.playerCandyCount < 3:
self.playerCandyCount += 1
groupShow(self.myPokesBright)
MAZE.clearCandy()
elif checkEatPika(self.pikachu.getX(), self.pikachu.getY(),
self.candy.getX(), self.candy.getY()):
self.candy.hide()
self.candyOnBoard = False
if self.pokeCandyCount < 3:
self.pokeCandyCount += 1
MAZE.clearCandy()
return Task.cont
def setFocus(self, changing):
# set focus of the camera while panning
self.changingFocus = changing
if changing == True: # Just Pressed
self.referenceX, self.referenceY = self.mouseX, self.mouseY
else: # cursor moves up
self.referenceX, self.referenceY = None, None
def resetView(self):
# reset the view to default
self.CAM_R, self.CAM_RAD = 12, 0
self.cameraSpinCount, self.cameraZoomCount = 0, 0
# _FOCUS = [0,0,0] does not work WHY???
_FOCUS[0], _FOCUS[1], _FOCUS[2] = 0,0,0
self.changingFocus = False
self.referenceX, self.referenceY = None, None
camera.setPos(_FOCUS[0], _FOCUS[1]-self.CAM_R, 25)
camera.setHpr(0, -65, 0)
def changeFocus(self, task):
# change focus with displacement of mouse cursor
if (self.changingFocus == True and self.mouseX != None and
self.mouseY != None ):
dX, dY = ((self.mouseX - self.referenceX)*0.1,
(self.mouseY - self.referenceY)*0.1)
_FOCUS[0] += dX
_FOCUS[1] += dY
camera.setPos(_FOCUS[0] + self.CAM_R*cos(-pi/2+self.CAM_RAD),
_FOCUS[1] + self.CAM_R*sin(-pi/2+self.CAM_RAD),
(25.0/12)*self.CAM_R)
return Task.cont
def thunderbolt(self, task):
if self.onThunder == True:
self.thunder.setPos(self.ballRoot.getPos())
return Task.cont
def displayClock(self, task):
msg = "Time: %.2f" %(self.clock/100.0)
if self.clockMSG == None:
self.clockMSG = OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(1.3, .95), align=TextNode.ALeft,
scale = .05)
else:
self.clockMSG.destroy()
self.clockMSG = OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(1.3, .95), align=TextNode.ALeft,
scale = .05)
return task.cont
def initialize(self):
taskMgr.stop()
self.musicCounter, self.clock = 0, 0
self.gameOverCounter = 0
self.clockMSG = None
self.music = load_bgmusic(_BGMUSIC[0])
self.background = loadBackground()
base.cam2dp.node().getDisplayRegion(0).setSort(-20)
self.candyOnBoard = False
self.playerCandyCount, self.pokeCandyCount = 0, 0
self.gameOver = False
self.displayInformation()
self.instStatus = "show"
######################Rare Candy###############################
pokes=['caterpie', 'charmander', 'geodude']
self.myPokesDark = loadMyPokemon_Dark(pokes) # my pokemons
self.myPokesBright = loadMyPokemon_Bright()
groupHide(self.myPokesBright)
self.loadRareCandy() # load rare candy
######################Camera Initialization####################
self.CAM_R, self.CAM_RAD = 12, 0
camera.setPos(_FOCUS[0],_FOCUS[1]-12,_FOCUS[2]+25)
camera.setHpr(0, -65, 0)
self.cameraSpinCount, self.cameraZoomCount = 0, 0
self.changingFocus = False
self.spin = 0
#######################ICONS###################################
self.myIcon = loadMyIcon()
self.pokeIcon = loadPokeIcon()
self.playerCandyStatus = candyStatus(0, self.playerCandyCount)
self.pokeCandyStatus = candyStatus(1, self.pokeCandyCount)
self.rareCandyImage = loadRareCandyImage()
self.pokeRareCandyImage = loadRareCandyImage(pos=(-.3,0,-.75))
#######################FLAMES##################################
base.enableParticles()
self.fireCounter = 0
self.onFire = False
#######################STRINGSHOT#############################
self.stringCounter = 0
#######################THUNDER################################
self.thunderCounter = 0
#######################SOUND##################################
self.dangerous = load_sound("pikachu_d.wav")
self.safe = load_sound("pikachu_s1.wav")
self.use = load_sound("pikachu_u.wav")
#######################"GLOBALS"##############################
self.speedCounter = 0
self.onThunder = False
self.direction = 's'
self.myDirection = ['zx', 'zy']
self.rockCounter = 0
self.rockX, self.rockY = None, None
self.rockOnMaze = False
self.pokeMoveChoice = None
self.myPokeName = None
self.arrowKeyPressed = False
self.pokemonDirection = 'd'
self.mouseX, self.mouseY = None, None
# direction the ball is going
self.jerkDirection = None
base.disableMouse()
self.jerk = Vec3(0,0,0)
self.MAZE = Model_Load.loadLabyrinth()
Control.keyControl(self)
self.loadPokemonLevel1()
self.light()
self.loadBall()
self.pokeStatus = 0 # 0 is normal, 1 is burned, 2 is slow-speed
########################################ROCK###################
self.rock = Model_Load.loadRock()
self.rock.reparentTo(render)
self.rock.hide() # Do not show, but load beforehand for performance
def loadPokemonLevel1(self):
self.pikachu = load_model("pikachu.egg")
self.pikachu.reparentTo(render)
self.pikachu.setScale(0.3)
endPos = self.MAZE.find("**/end").getPos()
self.pikachu.setPos(endPos)
def light(self):
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def loadBall(self):
self.ballRoot = render.attachNewNode("ballRoot")
self.ball = load_model("ball")
self.ball.reparentTo(self.ballRoot)
self.ball_tex = load_tex("pokeball.png")
self.ball.setTexture(self.ball_tex,1)
self.ball.setScale(0.8)
# Find the collision sphere for the ball in egg.
self.ballSphere = self.ball.find("**/ball")
self.ballSphere.node().setFromCollideMask(BitMask32.bit(0))
self.ballSphere.node().setIntoCollideMask(BitMask32.allOff())
#self.ballSphere.show()
# Now we create a ray to cast down at the ball.
self.ballGroundRay = CollisionRay()
self.ballGroundRay.setOrigin(0,0,10)
self.ballGroundRay.setDirection(0,0,-1)
# Collision solids go in CollisionNode
self.ballGroundCol = CollisionNode('groundRay')
self.ballGroundCol.addSolid(self.ballGroundRay)
self.ballGroundCol.setFromCollideMask(BitMask32.bit(1))
self.ballGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ballGroundColNp = self.ballRoot.attachNewNode(self.ballGroundCol)
# light
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0,0,-1))
directionalLight.setColor(Vec4(0.375,0.375,0.375,1))
directionalLight.setSpecularColor(Vec4(1,1,1,1))
self.ballRoot.setLight(render.attachNewNode(ambientLight))
self.ballRoot.setLight(render.attachNewNode(directionalLight))
# material to the ball
m = Material()
m.setSpecular(Vec4(1,1,1,1))
m.setShininess(96)
self.ball.setMaterial(m,1)
def __init__(self):
self.initialize()
self.WALLS = self.MAZE.find("**/Wall.004")
self.WALLS.node().setIntoCollideMask(BitMask32.bit(0))
# collision with the ground. different bit mask
#self.mazeGround = self.maze.find("**/ground_collide")
#self.mazeGround.node().setIntoCollideMask(BitMask32.bit(1))
self.MAZEGROUND = self.MAZE.find("**/Cube.004")
self.MAZEGROUND.node().setIntoCollideMask(BitMask32.bit(1))
# add collision to the rock
cs = CollisionSphere(0, 0, 0, 0.5)
self.cnodePath = self.rock.attachNewNode(CollisionNode('cnode'))
self.cnodePath.node().addSolid(cs)
self.cnodePath.node().setIntoCollideMask(BitMask32.bit(0))
# CollisionTraversers calculate collisions
self.cTrav = CollisionTraverser()
#self.cTrav.showCollisions(render)
#self.cTrav.showCollisions(render)
# A list collision handler queue
self.cHandler = CollisionHandlerQueue()
# add collision nodes to the traverse.
# maximum nodes per traverser: 32
self.cTrav.addCollider(self.ballSphere,self.cHandler)
self.cTrav.addCollider(self.ballGroundColNp,self.cHandler)
self.cTrav.addCollider(self.cnodePath, self.cHandler)
# collision traversers have a built-in tool to visualize collisons
#self.cTrav.showCollisions(render)
self.start()
def pokemonTurn(self, pokemon, direction):
if direction == 'l' and self.pokemonDirection != 'l':
self.pokemonDirection = 'l'
pokemon.setH(-90)
if direction == 'r' and self.pokemonDirection != 'r':
self.pokemonDirection = 'r'
pokemon.setH(90)
if direction == 'd' and self.pokemonDirection != 'd':
self.pokemonDirection = 'd'
pokemon.setH(0)
if direction == 'u' and self.pokemonDirection != 'u':
self.pokemonDirection = 'u'
pokemon.setH(180)
def pokemonMove(self, pokemon, direction):
self.pokemonTurn(pokemon, direction)
if self.pokeStatus == 0: speed = _SPEED
elif self.pokeStatus == 1: speed = 0
else: # self.pokeStatus == 2
speed = _SPEED/2.0
if direction == 'l':
newX = pokemon.getX() - speed
pokemon.setX(newX)
elif direction == 'r':
newX = pokemon.getX() + speed
pokemon.setX(newX)
elif direction == 'u':
newY = pokemon.getY() + speed
pokemon.setY(newY)
elif direction == 'd':
newY = pokemon.getY() - speed
pokemon.setY(newY)
elif direction == "s": # stop
pass
def whereToGo(self, task):
# this returns the direction pokemon should go
# tell MAZE pokemon and ball's board position
self.pokemonMove(self.pikachu, self.direction)
MAZE.setPokeCoord(self.pikachu.getX(), self.pikachu.getY(),
self.pokemonDirection)
MAZE.setBallCoord(self.ballRoot.getX(), self.ballRoot.getY())
MAZE.sendInformation(self.myDirection, self.rockOnMaze,
self.onThunder, self.playerCandyCount,
self.pokeCandyCount, self.distance)
# find out which direction to go
self.direction = MAZE.getDecision()
self.pokemonMove(self.pikachu,self.direction)
return Task.cont
def whatToDo(self, task):
# determines when to use thunder
if self.pokeCandyCount > 0: # Pikachu has candies
decision = MAZE.useThunderDecision()
if decision == True:
self.useThunder()
return Task.cont
def getInformation(self, task):
# get information on the board
self.speedCounter += 1 # sample every other call to avoid
if self.speedCounter % 2 == 0:
dX = self.ballRoot.getX() - self.oldPos[0]
dY = self.ballRoot.getY() - self.oldPos[1]
if dX < 0 :
# print "going left"
self.myDirection[0] = 'l'
elif abs(dX) < _EPSILON:
# print "not moving horiz"
self.myDirection[0] = 'zx'
else:
# print "going right"
self.myDirection[0] = 'r'
if dY < 0 :
# print "going down"
self.myDirection[1] = 'd'
elif abs(dY) < _EPSILON:
# print "not moving verti"
self.myDirection[1] = 'zy'
else:
# print "going up"
self.myDirection[1] = 'u'
self.oldPos = self.ballRoot.getPos()
# calculate distance
self.distance = MAZE.getDistance()
return Task.cont
def start(self):
# maze model has a locator in it
# self.ballRoot.show()
self.startPos = self.MAZE.find("**/start").getPos()
self.oldPos = self.MAZE.find("**/start").getPos()
self.ballRoot.setPos(self.startPos) # set the ball in the pos
self.ballV = Vec3(0,0,0) # initial velocity
self.accelV = Vec3(0,0,0) # initial acceleration
# for a traverser to work, need to call traverser.traverse()
# base has a task that does this once a frame
base.cTrav = self.cTrav
# create the movement task, make sure its not already running
taskMgr.remove("rollTask")
taskMgr.add(self.placeRock, "placeRock")
taskMgr.add(self.displayClock, "displayClock")
taskMgr.add(self.timer, "timer")
taskMgr.add(self.loadNextMusic, "loadNextMusic")
taskMgr.add(self.getInformation, "getInformation")
taskMgr.add(self.eatRareCandy, "eatRareCandy")
taskMgr.add(self.placeRareCandy, "placeRareCandy")
taskMgr.add(self.checkMouse, "checkMouse")
taskMgr.add(self.spinCamera, "spinCamera")
taskMgr.add(self.changeFocus, "changeFocus")
taskMgr.add(self.whereToGo, "whereToGo")
taskMgr.add(self.whatToDo, "whatToDo")
taskMgr.add(self.moveBall, "moveBall")
taskMgr.add(self.thunderbolt, "thunderbolt")
taskMgr.add(self.checkForWin, "checkForWin")
taskMgr.add(self.pikachuBark, "pikachuBark")
self.mainLoop = taskMgr.add(self.rollTask, "rollTask")
self.mainLoop.last = 0
def moveBallWrapper(self, direction):
# wrapper for moving the ball
# needs to be improved
if direction == False:
self.arrowKeyPressed = False
else:
self.arrowKeyPressed = True
self.jerkDirection = direction
def moveBall(self, task):
# move the ball
# a key press changes the jerk
direction = self.jerkDirection
if self.arrowKeyPressed == True and self.onThunder == False:
if direction == "u":
self.jerk = Vec3(0,_JERK,0)
elif direction == "d":
self.jerk = Vec3(0,-_JERK,0)
elif direction == "l":
self.jerk = Vec3(-_JERK,0,0)
elif direction == "r":
self.jerk = Vec3(_JERK,0,0)
elif self.onThunder == True:
self.jerk = self.jerk
return Task.cont
# collision between ray and ground
# info about the interaction is passed in colEntry
def groundCollideHandler(self,colEntry):
# set the ball to the appropriate Z for it to be on the ground
newZ = colEntry.getSurfacePoint(render).getZ()
self.ballRoot.setZ(newZ+.4)
# up vector X normal vector
norm = colEntry.getSurfaceNormal(render)
accelSide = norm.cross(UP)
self.accelV = norm.cross(accelSide)
# collision between the ball and a wall
def wallCollideHandler(self,colEntry):
# some vectors needed to do the calculation
norm = colEntry.getSurfaceNormal(render) * -1
norm.normalize()
curSpeed = self.ballV.length()
inVec = self.ballV/curSpeed
velAngle = norm.dot(inVec) # angle of incidance
hitDir = colEntry.getSurfacePoint(render) - self.ballRoot.getPos()
hitDir.normalize()
hitAngle = norm.dot(hitDir)
# deal with collision cases
if velAngle > 0 and hitAngle >.995:
# standard reflection equation
reflectVec = (norm * norm.dot(inVec*-1)*2) + inVec
# makes velocity half of hitting dead-on
self.ballV = reflectVec * (curSpeed * (((1-velAngle)*.5)+.5))
# a collision means the ball is already a little bit buried in
# move it so exactly touching the wall
disp = (colEntry.getSurfacePoint(render) -
colEntry.getInteriorPoint(render))
newPos = self.ballRoot.getPos() + disp
self.ballRoot.setPos(newPos)
def rollTask(self,task):
# standard technique for finding the amount of time
# since the last frame
dt = task.time - task.last
task.last = task.time
# If dt is large, then there is a HICCUP
# ignore the frame
if dt > .2: return Task.cont
# dispatch which function to handle the collision based on name
for i in range(self.cHandler.getNumEntries()):
entry = self.cHandler.getEntry(i)
name = entry.getIntoNode().getName()
if name == "Wall.004":
self.wallCollideHandler(entry)
elif name=="Cube.004":
self.groundCollideHandler(entry)
else:
if self.rockOnMaze == True:
self.wallCollideHandler(entry)
self.accelV += self.jerk
# move the ball, update the velocity based on accel
self.ballV += self.accelV * dt * ACCELERATION
# clamp the velocity to the max speed
if self.ballV.lengthSquared() > MAX_SPEED_SQ:
self.ballV.normalize()
self.ballV *= MAX_SPEED
# update the position
self.ballRoot.setPos(self.ballRoot.getPos() + (self.ballV*dt))
# uses quaternion to rotate the ball
prevRot = LRotationf(self.ball.getQuat())
axis = UP.cross(self.ballV)
newRot = LRotationf(axis, 45.5 * dt * self.ballV.length())
self.ball.setQuat(prevRot * newRot)
return Task.cont # continue the task
class Pose3dViz(ShowBase):
""" Initialize the ShowBase class from which we inherit, which will
create a window and set up everything we need for rendering into it."""
def __init__(self,
body_props,
face_pos,
cam,
args,
pifpaf,
pose3d,
with_azure=False):
ShowBase.__init__(self)
# Set up Panda3d environment
self.disableMouse()
self.setBackgroundColor(0.5, 0.6, 0.9)
self.setupLights()
### initialize all the required variables ###
# set face and body proportions to construct the avatar
self.body_props = body_props
self.face_pos = face_pos
# set the input video capture
self.cam = cam
# initialise the predictive models
self.pifpaf = pifpaf
self.pose3d = pose3d
self.args = args
# moving average variables and parameters
self.buffer_counter = 0
self.buffer_size = 5
self.buffer = np.zeros((17, self.buffer_size))
#kinect azure boolean
self.with_azure = with_azure
# variables to estimate frame rate
self.iter_count = 0
self.frame_rate = 0
self.previous_time = time.time()
# error text initializing
if self.with_azure:
self.text = OnscreenText(text='my text string',
pos=(-0.5, 0.02),
scale=0.07)
# recording attributes
self.stored_vals = {
"azure": {
"head": [],
"back": [],
"orient": []
},
"pose3d": {
"head": [],
"back": [],
"orient": []
}
}
self.stored_kinect_data = []
self.stored_pifpaf = []
self.record_id = str(int(time.time()))
# create the folders to store the recorded results of the session
os.mkdir("posture-app/results/" + self.record_id)
os.mkdir("posture-app/results/" + self.record_id + "/images")
self.record_count = 0
self.is_recording = False
# initialize the angle dicts
angles = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, math.pi / 2, math.pi / 2,
math.pi / 2, 0, 0, 0, 0, 0, 0, 0, 0)
self.angle_dic = {
'head': angles[:3],
'back': angles[3:6],
'x': [angles[6]],
'y': [angles[7]],
'z': [angles[8]],
'left arm': angles[9:13],
'right arm': angles[13:]
}
self.azure_angle_dic = {}
# create the pose skeleton
self.create_pose(self.body_props, self.face_pos, self.angle_dic,
self.with_azure)
# necessary to read blender 3D objects
gltf.patch_loader(self.loader)
# adds the body part blender models to the skeleton
self.create_avatar()
# creates 3D points for each joints (used only for debugging angle conversions)
self.points = [Create3DPoint() for _ in range(21)]
# adds the update function as a thread to be called at every step of the game engine
self.taskMgr.add(self.update, "change_angles")
def setupLights(self):
"""setup the lighting"""
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(LVector3(0, 0, -2.5))
directionalLight.setColor((0.9, 0.8, 0.9, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def create_pose(self, body_props, face_pos, angle_dic, with_azure=True):
"""creates the skeleton of the avatar with given proportions and initial angles"""
#check if azure is connected
segments_dic = {}
if with_azure:
segments_azure_dic = {}
#define the eye distance and rotation
len_eye = np.linalg.norm(face_pos['eye'])
eye_z_rot = (180 / np.pi) * math.acos(face_pos['eye'][1] / len_eye)
eye_y_rot = (180 / np.pi) * math.acos(face_pos['eye'][0] / len_eye)
#define all the skeleton segments data as follow:
# (segment_name, segment_length, parent_name, distance_from_parent, rotation_angles)
seg_data = [
('left_hip', 0.5 * body_props['hip'], render, 0, [0, 0, 270]),
('right_hip', 0.5 * body_props['hip'], 'left_hip', 0, [0, 180, 0]),
('lower_back', body_props['back'], 'left_hip', 0, [0, 90, 0]),
('upper_back', body_props['back'], 'lower_back',
body_props['back'], [0, 0, 0]),
('left_shoulder', body_props['shoulder'], 'upper_back',
body_props['back'], [0, 90, 0]),
('left_biceps', body_props['biceps'], 'left_shoulder',
body_props['shoulder'], [0, 90, 0]),
('left_forearm', body_props['forearm'], 'left_biceps',
body_props['biceps'], [0, 0, 90]),
('right_shoulder', body_props['shoulder'], 'upper_back',
body_props['back'], [0, 270, 0]),
('right_biceps', body_props['biceps'], 'right_shoulder',
body_props['shoulder'], [0, 270, 0]),
('right_forearm', body_props['forearm'], 'right_biceps',
body_props['biceps'], [0, 0, 90]),
('lower_neck', body_props['neck'], 'upper_back',
body_props['back'], [0, 0, 0]),
('upper_neck', body_props['neck'], 'lower_neck',
body_props['neck'], [0, 0, 0]),
('nose', face_pos['nose'][2], 'upper_neck', body_props['neck'],
[0, 0, 90]),
('r_eye', len_eye, 'upper_neck', body_props['neck'],
[0, eye_y_rot, eye_z_rot]),
('l_eye', len_eye, 'upper_neck', body_props['neck'],
[0, -eye_y_rot, eye_z_rot]),
('r_ear', face_pos['ear'][0], 'upper_neck', body_props['neck'],
[0, 90, 0]),
('l_ear', face_pos['ear'][0], 'upper_neck', body_props['neck'],
[0, -90, 0])
]
# generate the skeleton for both pose3d and azure if azure is connected
for name, length, parent, z_displacement, rots in seg_data:
segments_dic[name] = Segment(length=AVATAR_SCALE_FACTOR *
length).draw()
if with_azure:
segments_azure_dic[name] = Segment(length=AVATAR_SCALE_FACTOR *
length).draw()
if type(parent) == str:
parent_obj = segments_dic[parent]
if with_azure:
parent_azure_obj = segments_azure_dic[parent]
else:
parent_obj = parent
if with_azure:
parent_azure_obj = parent
segments_dic[name].reparentTo(parent_obj)
segments_dic[name].setPosHprScale(
0, 0, AVATAR_SCALE_FACTOR * z_displacement, rots[0], rots[1],
rots[2], 1., 1., 1.)
if with_azure:
segments_azure_dic[name].reparentTo(parent_azure_obj)
segments_azure_dic[name].setPosHprScale(
0, 0, AVATAR_SCALE_FACTOR * z_displacement, rots[0],
rots[1], rots[2], 1., 1., 1.)
self.segments_dic = segments_dic
if with_azure:
self.segments_azure_dic = segments_azure_dic
else:
self.segments_azure_dic = None
def create_avatar(self):
"""connect the different body part models to the skeleton"""
## (part name, parent name, [angles, scaling])
avatar_data = [
('head', 'upper_neck', [270, 0 + 180, 180, 20, 20, 20]),
('neck', 'lower_neck', [270, 30 + 180, 180, 15, 15, 15]),
('torso', 'upper_back', [270, 0 + 180, 180, 25, 15, 25]),
('rightarm', 'right_biceps', [270, 0, 90, 20, 15, 15]),
('rightforearm', 'right_forearm', [270, 180, 90, 20, 15, 15]),
('leftarm', 'left_biceps', [270, 180, 90, 20, 15, 15]),
('leftforearm', 'left_forearm', [270, 0, 90, 20, 15, 15]),
('spine', 'lower_back', [270, 0 + 180, 180, 15, 15, 45]),
('pelvis', 'lower_back', [270, 0 + 180, 180, 25, 15, 15])
]
# attach each model part to the corresponding skeleton for pose3d and azure
avatar_dic = {}
for name, parent, rs in avatar_data:
avatar_dic[name] = self.loader.loadModel(
'visuals/models3d/man3D.' + name + '.glb')
avatar_dic[name].reparentTo(self.segments_dic[parent])
avatar_dic[name].setHprScale(rs[0], rs[1], rs[2], rs[3], rs[4],
rs[5])
self.avatar_dic = avatar_dic
if self.segments_azure_dic:
# change the skeleton color for azure and move the skeleton and camera
self.segments_azure_dic['left_hip'].setColor(0.0, 0.9, 0.9, 0.0)
self.segments_azure_dic['left_hip'].setPos(50, 0, 0)
self.segments_dic['left_hip'].setPos(-50, 0, 0)
camera.setPosHpr(25, -20, 200, 0, -90, 180)
avatar_azure_dic = {}
for name, parent, rs in avatar_data:
avatar_azure_dic[name] = self.loader.loadModel(
'visuals/models3d/man3D.' + name + '.glb')
avatar_azure_dic[name].reparentTo(
self.segments_azure_dic[parent])
avatar_azure_dic[name].setHprScale(rs[0], rs[1], rs[2], rs[3],
rs[4], rs[5])
self.avatar_azure_dic = avatar_azure_dic
def process_azure_data(self, azure_data):
"""process the azure data to convert it into a corresponding format for the avatar
(works well for the head, back and absolute orientation but can still not working perfectly for arms)"""
def angle_from_3pts(a, b, c):
"""get the acute angle between 3 3D points (used for the elbow angle)"""
ba = a - b
bc = c - b
cosine_angle = np.dot(
ba, bc) / (np.linalg.norm(ba) * np.linalg.norm(bc))
angle = np.arccos(cosine_angle)
return np.degrees(angle)
azure_angles_dic = {}
#find absolute xyz
xyz = azure_data[0, 3:7]
xyz = R.from_quat(xyz).as_euler('xyz', degrees=True) + np.array(
[90, 0, 0])
azure_angles_dic['x'] = -xyz[0]
azure_angles_dic['y'] = xyz[1]
azure_angles_dic['z'] = xyz[2]
#find the back angles
key_rots = R.from_quat(azure_data[1:3, 3:7])
key_times = [0, 1]
back_slerp = Slerp(key_times, key_rots)
back_azure = back_slerp([0.5])[0].as_euler(
'xyz', degrees=True) + np.array([90, 0, 90])
back_azure = np.array([-back_azure[2], back_azure[0], -back_azure[1]])
azure_angles_dic['back'] = back_azure
#find the head angles
head_azure = azure_data[26, 3:7]
head_azure = R.from_quat(head_azure).as_euler(
'xyz', degrees=True) + np.array([90, 45, 90])
head_azure = [-head_azure[2], -head_azure[0], -head_azure[1]]
azure_angles_dic['head'] = head_azure
#find the left shoulder angles
left_shoulder_azure = Quaternion(
azure_data[5, 3:7]) #*Quaternion(azure_data[4,3:7]).inverse
left_shoulder_azure = R.from_quat(
left_shoulder_azure.elements).as_euler(
'zyx', degrees=True) + np.array([0, 0, 180])
left_shoulder_azure = [
left_shoulder_azure[0], -left_shoulder_azure[2],
left_shoulder_azure[1]
]
azure_angles_dic['left arm'] = left_shoulder_azure
#find the right shoulder angles
right_shoulder_azure = Quaternion(
azure_data[12, 3:7]) #*Quaternion(azure_data[11,3:7]).inverse
right_shoulder_azure = R.from_quat(
right_shoulder_azure.elements).as_euler(
'zyx', degrees=True) + np.array([0, 0, 180])
right_shoulder_azure = [
-right_shoulder_azure[0], -right_shoulder_azure[2],
-right_shoulder_azure[1]
]
azure_angles_dic['right arm'] = right_shoulder_azure
#find the left elbow angles
left_elbow_azure = -angle_from_3pts(
azure_data[5, :3], azure_data[6, :3], azure_data[7, :3]) + 180
azure_angles_dic['left arm'].append(left_elbow_azure)
#find the right elbow angles
right_elbow_azure = angle_from_3pts(
azure_data[12, :3], azure_data[13, :3], azure_data[14, :3]) + 180
azure_angles_dic['right arm'].append(right_elbow_azure)
#change the reference
azure_angles_dic['back'] = np.array(back_azure) + np.array([
azure_angles_dic['z'], azure_angles_dic['x'], azure_angles_dic['y']
]) + np.array([90, 0, 0])
azure_angles_dic['head'] = np.array(head_azure) - np.array(
[back_azure[0], -back_azure[1], back_azure[2]])
return azure_angles_dic
def process_pose3d_data(self, pose3d_outputs):
"""convert from pose3d angles format to avatar angles"""
a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17 = pose3d_outputs[
0]
a0, a1, a2, a3, a4, a5, a6, a7, a8 = ( pose3d_outputs[0][0], -pose3d_outputs[0][1], -pose3d_outputs[0][2], pose3d_outputs[0][3], -pose3d_outputs[0][4],\
-pose3d_outputs[0][5], -pose3d_outputs[0][8], pose3d_outputs[0][7]+math.pi/2, -pose3d_outputs[0][6])
a9, a10, a11, a12, a13, a14, a15, a16 = (pose3d_outputs[0][9], pose3d_outputs[0][10], pose3d_outputs[0][11], pose3d_outputs[0][12], pose3d_outputs[0][13],\
pose3d_outputs[0][14], pose3d_outputs[0][15], pose3d_outputs[0][16])
self.buffer[:, self.buffer_counter %
self.buffer_size] = (a0, a1, a2, a3, a4, a5, a6, a7, a8,
a9, a10, a11, a12, a13, a14, a15, a16)
self.buffer_counter += 1
a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16 = np.mean(
self.buffer, axis=1)
self.angle_dic = {
'head': [a0, a1, a2],
'back': [a3, a4, a5],
'x': [a6],
'y': [a7],
'z': [a8],
'left arm': [a9, a10, a11, a12],
'right arm': [a13, a14, a15, a16]
}
self.angle_dic['head'][0], self.angle_dic['head'][1], self.angle_dic['head'][2] = (180/np.pi)*self.angle_dic['head'][1],\
-(180/np.pi)*self.angle_dic['head'][2], -(180/np.pi)*self.angle_dic['head'][0]
self.angle_dic['back'][0], self.angle_dic['back'][1], self.angle_dic['back'][2] = (180/np.pi)*self.angle_dic['back'][1],\
-(180/np.pi)*self.angle_dic['back'][2], -(180/np.pi)*self.angle_dic['back'][0]
self.angle_dic['x'], self.angle_dic['y'], self.angle_dic['z'] = -(180/np.pi)*self.angle_dic['x'][0], -(180/np.pi)*self.angle_dic['z'][0]+20,\
-(180/np.pi)*self.angle_dic['y'][0]
self.angle_dic['left arm'][0], self.angle_dic['left arm'][1], self.angle_dic['left arm'][2], self.angle_dic['left arm'][3] =\
((180/np.pi)*self.angle_dic['left arm'][0])-90,(180/np.pi)*self.angle_dic['left arm'][1],\
(180/np.pi)*self.angle_dic['left arm'][2], (180/np.pi)*self.angle_dic['left arm'][3]
self.angle_dic['right arm'][0], self.angle_dic['right arm'][1], self.angle_dic['right arm'][2], self.angle_dic['right arm'][3] = \
((180/np.pi)*self.angle_dic['right arm'][0])-90, (180/np.pi)*self.angle_dic['right arm'][1],\
(180/np.pi)*self.angle_dic['right arm'][2], (180/np.pi)*self.angle_dic['right arm'][3]
def keyboard_action_check(self):
"""Check for actions and update the object accordingly"""
### recording ###
# for start and stop recording you press a then r
if keyboard.is_pressed('a'):
keyboard.wait('r')
self.recording_text = OnscreenText(text='',
pos=(0.0, -0.4),
scale=0.07)
if self.is_recording:
self.recording_text.destroy()
saving_text = OnscreenText(text='saving',
pos=(0.0, -0.4),
scale=0.07)
# if previous state was recording then we store the data in json tables and reset the variables
json.dump(
self.stored_vals,
open(
'posture-app/results/' + self.record_id +
'/pose3d_data.txt', 'w'))
json.dump(
np.array(self.stored_kinect_data).tolist(),
open(
'posture-app/results/' + self.record_id +
'/kinect_data.txt', 'w'))
json.dump(
self.stored_pifpaf,
open(
'posture-app/results/' + self.record_id +
'/pifpaf_data.txt', 'w'))
self.stored_vals = {
"azure": {
"head": [],
"back": [],
"orient": []
},
"pose3d": {
"head": [],
"back": [],
"orient": []
}
}
self.stored_kinect_data = []
self.stored_pifpaf = []
self.record_id = str(int(time.time()))
self.record_count = 0
saving_text.destroy()
else:
self.recording_text = OnscreenText(text='recording',
pos=(0.0, -0.4),
scale=0.07)
self.is_recording = not self.is_recording
def get_frame_rate(self):
"""gives back the frame rate of the model"""
if time.time() > (self.previous_time + 1):
self.frame_rate = self.iter_count
self.iter_count = 0
self.previous_time = time.time()
self.iter_count += 1
def update_segment_dic(self, segments_dic, angles_dic):
"""Update the angles of a segment dictionary with new angles"""
segments_dic['upper_neck'].setPosHprScale(0, 0, AVATAR_SCALE_FACTOR*(self.body_props['neck']), angles_dic['head'][0],\
angles_dic['head'][1], angles_dic['head'][2], 1., 1., 1.)
segments_dic['upper_back'].setPosHprScale(0, 0, AVATAR_SCALE_FACTOR*(self.body_props['back']), angles_dic['back'][0],\
angles_dic['back'][1], angles_dic['back'][2], 1., 1., 1.)
segments_dic['left_hip'].setHpr(angles_dic['x'], angles_dic['y'],
angles_dic['z'])
segments_dic['left_biceps'].setPosHprScale(0, 0, AVATAR_SCALE_FACTOR*(self.body_props['shoulder']),\
angles_dic['left arm'][0], angles_dic['left arm'][1], angles_dic['left arm'][2], 1., 1., 1.)
segments_dic['left_forearm'].setPosHprScale(0, 0, AVATAR_SCALE_FACTOR*(self.body_props['biceps']), 0, 0,\
angles_dic['left arm'][3], 1., 1., 1.)
segments_dic['right_biceps'].setPosHprScale(0, 0, AVATAR_SCALE_FACTOR*(self.body_props['shoulder']),\
angles_dic['right arm'][0], angles_dic['right arm'][1], angles_dic['right arm'][2], 1., 1., 1.)
segments_dic['right_forearm'].setPosHprScale(0, 0, AVATAR_SCALE_FACTOR*(self.body_props['biceps']), 0, 0,\
angles_dic['right arm'][3], 1., 1., 1.)
def get_pifpaf_values(self, args, pifpaf):
"""Process the cam image and get the main pifpaf detection and the intrinsic matrix"""
# get the camera image and process it
_, frame = self.cam.read()
image = cv2.resize(frame, None, fx=args.scale, fy=args.scale)
height, width, _ = image.shape
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
processed_image_cpu = image_transform(image.copy())
processed_image = processed_image_cpu.contiguous().to(
args.device, non_blocking=True)
# run the pifpaf model
fields = pifpaf.fields(torch.unsqueeze(processed_image, 0))[0]
_, _, pifpaf_out = pifpaf.forward(image, processed_image_cpu, fields)
if pifpaf_out:
# will only leave the largest person detected in the frame
pifpaf_out = [
pifpaf_out[np.argmax(
list(
map(
lambda pp: max(pp['keypoints'][1::3]) - min(pp[
'keypoints'][1::3]), pifpaf_out)))]
]
# define the intrinsic camera parameters
kk = [[x * width for x in LOGI_KK[0]],
[x * height for x in LOGI_KK[1]], LOGI_KK[2]]
return pifpaf_out, kk, frame
def store_data(self, azure_data, pifpaf_out, frame):
"""Calculate the error and store the values for the data recording"""
if self.with_azure:
azure_angles_dic = self.azure_angles_dic
head_error = abs(self.angle_dic['head'] - azure_angles_dic['head'])
back_error = abs(self.angle_dic['back'] - azure_angles_dic['back'])
orient_error = np.array([
abs(self.angle_dic['x'] - azure_angles_dic['x']),
abs(self.angle_dic['y'] - azure_angles_dic['y']),
abs(self.angle_dic['z'] - azure_angles_dic['z'])
])
if self.is_recording:
self.stored_vals['pose3d']['head'].append(
list(self.angle_dic['head']))
self.stored_vals['pose3d']['back'].append(
list(self.angle_dic['back']))
self.stored_vals['pose3d']['orient'].append([
self.angle_dic['x'], self.angle_dic['y'], self.angle_dic['z']
])
self.record_count += 1
print("saving")
cv2.imwrite(
"posture-app/results/" + self.record_id +
"/images/frame{}.jpg".format(self.record_count), frame)
if self.with_azure:
self.stored_vals['azure']['head'].append(
list(azure_angles_dic['head']))
self.stored_vals['azure']['back'].append(
list(azure_angles_dic['back']))
self.stored_vals['azure']['orient'].append([
azure_angles_dic['x'], azure_angles_dic['y'],
azure_angles_dic['z']
])
self.stored_kinect_data.append(azure_data)
self.stored_pifpaf.append(pifpaf_out[0])
if self.with_azure:
self.text.destroy()
text_2_show = 'head: '+str(head_error.astype(int))+\
'\nback: '+str(back_error.astype(int))+\
'\norient: '+str(orient_error.astype(int))
self.text = OnscreenText(text=text_2_show,
pos=(0., -0.2),
scale=0.07)
def update(self, task):
"""Function to update the visualization and run the model"""
self.keyboard_action_check()
self.get_frame_rate()
print("frame rate:", self.frame_rate)
#############get Azure Values###########################################
if self.with_azure:
azure_data = np.array(get_data()).reshape((32, 8))
self.azure_angles_dic = self.process_azure_data(azure_data)
self.update_segment_dic(self.segments_azure_dic,
self.azure_angles_dic)
# get the models and parameters
args = self.args
pifpaf = self.pifpaf
pose3d = self.pose3d
# get the pifpaf values and the intrinsic matrix
pifpaf_out, kk, frame = self.get_pifpaf_values(args, pifpaf)
if pifpaf_out:
# set camera position if kinect model is available
if self.with_azure == False:
camera.setPosHpr(0, -30, 300, 0, -90, 180)
# preprocess the pifpaf outputs for the pose3d model
pose3d_inputs = preprocess_pifpaf(pifpaf_out, self.body_props,
self.face_pos, kk, True)
# run the pose3d model
pose3d_outputs = pose3d.forward(
pose3d_inputs).cpu().detach().numpy()
########################process and store the angles for comparaison###################################
self.process_pose3d_data(pose3d_outputs)
self.segments_dic['left_hip'].setPos(0, 0, 0)
self.update_segment_dic(self.segments_dic, self.angle_dic)
self.store_data(azure_data, pifpaf_out, frame)
return Task.cont
class Network(object):
def __init__(self, cars, time, map, players, playername):
self.carHitSound = base.loader.loadSfx("Sounds/CRASH2.wav")
self.startSound = base.loader.loadSfx("Sounds/ENGINESTART.wav")
self.time = time
self.map = map
self.players = players
self.playername = playername
self.playername += " (0)"
self.playerscores = []
self.timer = -1
world_loader = w_loader()
world_loader.load_world(map)
self.textWaitObject = OnscreenText(text="Waiting for players...", style=1, fg=(1,1,1,1), pos=(0.7,-0.95), scale = .07)
global spawn_locations
self.carData = cars
self.carData.spos = spawn_locations
self.carData.addCar()
self.carData.index = 0
self.carUpdates = [() for c in self.carData.carlist]
self.ignore = []
self.cManager = QueuedConnectionManager()
self.cListener = QueuedConnectionListener(self.cManager, 0)
self.cReader = QueuedConnectionReader(self.cManager, 0)
self.cWriter = ConnectionWriter(self.cManager,0)
self.activeConnections = []
self.port_address = 9099 #No-other TCP/IP services are using this port
self.backlog = 1000 #If we ignore 1,000 connection attempts, something is wrong!
self.tcpSocket = self.cManager.openTCPServerRendezvous(self.port_address, self.backlog)
self.cListener.addConnection(self.tcpSocket)
taskMgr.add(self.tskListenerPolling,"Poll the connection listener",-39)
taskMgr.add(self.tskReaderPolling,"Poll the connection reader",-40)
def tskListenerPolling(self, taskdata):
# if a new connection is made, add it to the list
if self.cListener.newConnectionAvailable():
rendezvous = PointerToConnection()
netAddress = NetAddress()
newConnection = PointerToConnection()
if self.cListener.getNewConnection(rendezvous,netAddress,newConnection):
newConnection = newConnection.p()
self.activeConnections.append(newConnection) # Remember connection
self.cReader.addConnection(newConnection) # Begin reading connection
return Task.cont
def tskReaderPolling(self, taskdata):
# every frame, read messages, and then send out updates to all clients
selfCarDatagram = self.getCarPosDatagramFromCar(self.carData.index) # add self to list of updates
self.myProcessDataFunction(selfCarDatagram)
# loop through all messages recieved
while self.cReader.dataAvailable():
datagram=NetDatagram() # catch the incoming data in this instance
if self.cReader.getData(datagram):
self.myProcessDataFunction(datagram) # handle the message
#send out car and collision messages
carPosDatagrams = self.getCarPosDatagrams()
collisionDatagrams = self.getCollisionDatagrams()
for aClient in self.activeConnections:
for data in carPosDatagrams:
self.cWriter.send(data, aClient)
for data in collisionDatagrams:
self.cWriter.send(data, aClient)
# start game if enough players have joined
if self.timer == -1 and self.carData.go == False and len(self.carData.carlist) >= self.players:
startDatagram = self.startDatagram()
for aClient in self.activeConnections:
self.cWriter.send(startDatagram, aClient)
self.carData.go = True
self.textWaitObject.destroy()
self.timer = taskdata.time
self.startSound.play()
# run collisions
for pair in self.carData.collisionlist:
if pair[0] < pair[1]:
if pair[0] == 0:
self.carHitSound.play()
collisions.collideCars(self.carData.carlist[pair[0]], self.carData.carlist[pair[1]])
# if time is up, end game and print scores
if self.timer >= 0 and taskdata.time > self.timer + self.time * 60:
if self.carData.go:
self.carData.go = False
self.playerscores.append((self.playername, self.carData.carlist[self.carData.index].deaths))
stopDatagram = self.stopDatagram()
for aClient in self.activeConnections:
self.cWriter.send(stopDatagram, aClient)
elif len(self.playerscores) >= len(self.carData.carlist) or (taskdata.time > self.timer + self.time * 60 + 15 and self.playerscores != []):
self.playerscores = pairsort(self.playerscores)
textytext = "Most Numerous Deaths:"
for pair in self.playerscores:
textytext += "\n\n%s: %d"%pair
self.textScore = OnscreenText(text=textytext, style=1, fg=(1,1,1,1), pos=(0,0.9), scale = .08)
scoreDatagram = self.scoreDatagram()
for aClient in self.activeConnections:
self.cWriter.send(scoreDatagram, aClient)
self.playerscores = []
self.carData.collisionlist = []
self.clearCarData() #This is to prevent redundant messages from being sent
return Task.cont
def myProcessDataFunction(self, netDatagram):
# check a message and do what it says
myIterator = PyDatagramIterator(netDatagram)
msgID = myIterator.getUint8()
if msgID == PRINT_MESSAGE: # This is a debugging message
messageToPrint = myIterator.getString()
print messageToPrint
elif msgID == CAR_MESSAGE: # This updates a car
carNum = myIterator.getUint8()
for num in self.ignore: # if the car message is out of date, ignore it
if num == carNum:
break
else: # else update the car
carXpos = myIterator.getFloat32()
carYpos = myIterator.getFloat32()
carXvel = myIterator.getFloat32()
carYvel = myIterator.getFloat32()
carHeading = myIterator.getFloat32()
carInput = []
for i in range(5):
carInput.append(myIterator.getBool())
carLights = myIterator.getBool()
carHp = myIterator.getInt32()
self.updatePositions(carNum, (carXpos, carYpos, carXvel, carYvel, carHeading, carInput, carLights, carHp))
elif msgID == NEW_PLAYER_MESSAGE: # This creates a new player
if len(self.carData.carlist) >= self.players:
self.cWriter.send(self.startDatagram(), netDatagram.getConnection())
self.cWriter.send(self.mapDatagram(), netDatagram.getConnection())
self.cWriter.send(self.addNewCar(), netDatagram.getConnection())
self.returnAllCars(netDatagram.getConnection())
elif msgID == COLLIDED_MESSAGE: # This verifies that a car has recieved its collision message and is now up to date
carNum = myIterator.getUint8()
self.ignore.remove(carNum)
elif msgID == END_MESSAGE: # This recieves a player score
self.playerscores.append((myIterator.getString(), myIterator.getInt32()))
def myNewPyDatagram(self):
# Send a test message
myPyDatagram = PyDatagram()
myPyDatagram.addUint8(PRINT_MESSAGE)
myPyDatagram.addString("Hello, world!")
return myPyDatagram
def startDatagram(self):
# Send a test message
myPyDatagram = PyDatagram()
myPyDatagram.addUint8(BEGIN_MESSAGE)
return myPyDatagram
def stopDatagram(self):
# Send a test message
myPyDatagram = PyDatagram()
myPyDatagram.addUint8(END_MESSAGE)
myPyDatagram.addInt32(-1)
return myPyDatagram
def scoreDatagram(self):
# Send a test message
myPyDatagram = PyDatagram()
myPyDatagram.addUint8(END_MESSAGE)
myPyDatagram.addInt32(len(self.playerscores))
for pair in self.playerscores:
myPyDatagram.addString(pair[0])
myPyDatagram.addInt32(pair[1])
return myPyDatagram
def mapDatagram(self):
# Send a test message
myPyDatagram = PyDatagram()
myPyDatagram.addUint8(MAP_MESSAGE)
myPyDatagram.addString(self.map)
return myPyDatagram
def updatePositions(self, carNum, data):
if len(self.carUpdates) > carNum:
self.carUpdates[carNum] = data
else:
for i in range(len(self.carUpdates),carNum+1):
self.carUpdates.append(())
self.carUpdates[carNum] = data
if len(self.carData.carlist) > carNum:
if carNum != self.carData.index:
self.carData.carlist[carNum].model.setPos(data[0], data[1], 0)
self.carData.carlist[carNum].vel.setXY(data[2], data[3])
self.carData.carlist[carNum].model.setH(data[4])
self.carData.carlist[carNum].input = data[5]
self.carData.carlist[carNum].setHeadlights(data[6])
self.carData.carlist[carNum].hp = data[7]
else:
for i in range(len(self.carData.carlist), carNum+1):
self.carData.addCar()
self.carData.carlist[carNum].model.setPos(data[0], data[1], 0)
self.carData.carlist[carNum].vel.setXY(data[2], data[3])
self.carData.carlist[carNum].model.setH(data[4])
self.carData.carlist[carNum].input = data[5]
self.carData.carlist[carNum].setHeadlights(data[6])
self.carData.carlist[carNum].hp = data[7]
def finalizeUpdates(self): #currently unused
for i in range(len(self.carUpdates)):
if self.carUpdates[i] != ():
if len(self.carData.carData) > i:
self.carData.carlist[i].model.setPos(self.carUpdates[i][0], self.carUpdates[i][1], 0)
self.carData.carlist[i].vel.setXY(self.carUpdates[i][2], self.carUpdates[i][3])
else:
for j in range(len(self.carData.carData), i+1):
self.carData.carData.append(())
self.carData.carData[i] = self.carUpdates[i]
def clearCarData(self):
self.carUpdates = [() for c in self.carData.carlist]
def getCarPosDatagrams(self):
# makes a list of datagrams for each car that updated this frame
myDatagrams = []
for i in range(len(self.carUpdates)):
if self.carUpdates[i] != ():
newDatagram = self.getCarPosDatagram(i, self.carUpdates[i])
myDatagrams.append(newDatagram)
return myDatagrams
def getCarPosDatagram(self, num, data):
# creates a car_message datagram from data
newDatagram = PyDatagram()
newDatagram.addUint8(CAR_MESSAGE)
newDatagram.addUint8(num)
for j in range(5):
newDatagram.addFloat32(float(data[j]))
for j in range(5):
newDatagram.addBool(data[5][j])
newDatagram.addBool(data[6])
newDatagram.addInt32(data[7])
return newDatagram
def getCarPosDatagramFromCar(self, num):
# creates a car_message datagram from the entry in carData (used to get new cars up to date)
newDatagram = PyDatagram()
newDatagram.addUint8(CAR_MESSAGE)
newDatagram.addUint8(num)
newDatagram.addFloat32(self.carData.carlist[num].model.getX())
newDatagram.addFloat32(self.carData.carlist[num].model.getY())
vel = self.carData.carlist[num].vel.getXY()
newDatagram.addFloat32(vel[0])
newDatagram.addFloat32(vel[1])
newDatagram.addFloat32(self.carData.carlist[num].model.getH())
for j in range(5):
newDatagram.addBool(self.carData.carlist[num].input[j])
newDatagram.addBool(self.carData.carlist[num].lightsOn)
newDatagram.addInt32(self.carData.carlist[num].hp)
return newDatagram
def getNewCarPosDatagram(self, num):
# same as getCarPosDatagramFromCar, but is a player_assignment_message
newDatagram = PyDatagram()
newDatagram.addUint8(PLAYER_ASSIGNMENT_MESSAGE)
newDatagram.addUint8(num)
newDatagram.addFloat32(self.carData.carlist[num].model.getX())
newDatagram.addFloat32(self.carData.carlist[num].model.getY())
vel = self.carData.carlist[num].vel.getXY()
newDatagram.addFloat32(vel[0])
newDatagram.addFloat32(vel[1])
newDatagram.addFloat32(self.carData.carlist[num].model.getH())
for j in range(5):
newDatagram.addBool(self.carData.carlist[num].input[j])
newDatagram.addBool(self.carData.carlist[num].lightsOn)
newDatagram.addInt32(self.carData.carlist[num].hp)
return newDatagram
def getCollisionDatagrams(self):
# returns a list of collision datagrams
myDatagrams = []
for data in self.carData.collisionlist:
newDatagram = PyDatagram()
newDatagram.addUint8(COLLIDED_MESSAGE)
newDatagram.addUint8(data[0])
newDatagram.addUint8(data[1])
myDatagrams.append(newDatagram)
if data[0] != 0:
self.ignore.append(data[0])
return myDatagrams
def returnAllCars(self, connection):
# sends a car_message for each car in carData to a new connection
carPosDatagrams = [self.getCarPosDatagramFromCar(i) for i in range(len(self.carData.carlist))]
for data in carPosDatagrams:
self.cWriter.send(data, connection)
def addNewCar(self):
num = len(self.carData.carlist)
self.carData.addCar()
return self.getNewCarPosDatagram(num)
class login(DirectObject):
TEXT_COLOR = (1,1,1,1)
FONT_TYPE_01 = 0
TEXT_SHADOW_COLOR = (0,0,0,0.5)
usernameInput = ""
passwordInput = ""
frame = DirectFrame()
window = OnscreenImage()
username = OnscreenText()
password = OnscreenText()
cpassword = OnscreenText()
failed = OnscreenText()
userTextbox = DirectEntry()
passTextbox = DirectEntry()
submitBtn = DirectButton()
registerBtn = DirectButton()
cancelBtn = DirectButton()
registerUsername = ""
registerPassword = ""
registerCPassword = ""
regInputUser = DirectEntry()
regInputPass = DirectEntry()
regInputCPass = DirectEntry()
regRegisterBtn = DirectButton()
regCancelBtn = DirectButton()
def __init__(self, world):
self.world = world
print 'Loading Login...'
frame = DirectFrame(frameColor=(0, 0, 0, 1), #(R,G,B,A)
frameSize=(-1, 1, -1, 1),#(Left,Right,Bottom,Top)
pos=(-0.5, 0, 0.5))
self.createLoginWindow()
def clearPassText(self):
self.passTextbox.enterText('')
def clearUserText(self):
self.userTextbox.enterText('')
def clearRegUserText(self):
self.regInputUser.enterText('')
def clearRegPassText(self):
self.regInputPass.enterText('')
def clearRegCPassText(self):
self.regInputCPass.enterText('')
def getUserText(self):
self.usernameInput = self.userTextbox.get()
def getPassText(self):
self.passwordInput = self.passTextbox.get()
def setUserText(self, textEntered):
print "username: "******"password: "******"" and self.passwordInput is not ""):
print "You pressed Submit", self.usernameInput, " ; ",self.passwordInput
self.destroyLoginWindow()
self.world.cManager.sendRequest(Constants.CMSG_AUTH, self.usernameInput+" "+self.passwordInput);
else:
print "Please enter in a username and password"
def clickedCancel(self):
print "You pressed Cancel"
exit()
def clickedRegister(self):
print "You pressed Register"
self.createRegisterWindow()
def clickedRegRegister(self):
self.registerUsername = self.regInputUser.get()
self.registerPassword = self.regInputPass.get()
self.registerCPassword = self.regInputCPass.get()
if self.registerPassword == self.registerCPassword:
print "Success (",self.registerUsername, ", ",self.registerPassword,", ",self.registerCPassword,")"
self.world.cManager.sendRequest(Constants.CMSG_REGISTER, self.registerUsername+" "+self.registerPassword)
self.createLoginWindow()
else:
self.failed = OnscreenText(text="Your password does not match Confirm Password.", pos=(-0.5, 0.5), scale=0.06,fg=(1,0.1,0.1,1), align=TextNode.ALeft,mayChange=0)
print "Failed (",self.registerUsername, ", ",self.registerPassword,", ",self.registerCPassword,")"
def clickedRegCancel(self):
self.destroyRegisterWindow()
self.createLoginWindow()
def destroyLoginWindow(self):
self.frame.destroy()
self.username.destroy()
self.password.destroy()
self.userTextbox.destroy()
self.passTextbox.destroy()
self.submitBtn.destroy()
self.registerBtn.destroy()
self.cancelBtn.destroy()
def destroyRegisterWindow(self):
self.frame.destroy()
self.username.destroy()
self.password.destroy()
self.cpassword.destroy()
self.regInputUser.destroy()
self.regInputPass.destroy()
self.regInputCPass.destroy()
self.cancelBtn.destroy()
self.registerBtn.destroy()
self.failed.destroy();
def createLoginWindow(self):
self.window = OnscreenImage(image = "Interface/login_window.png", pos = (0,0,0), scale = (2, 1, 2) )
self.window.setTransparency(TransparencyAttrib.MAlpha)
self.userTextbox = DirectEntry(text = "" ,scale=.05, pos = (-0.3, 0, 0.3),command=self.setUserText,initialText="Username", numLines = 2,focus=0,focusInCommand=self.clearUserText, focusOutCommand=self.getUserText)
self.passTextbox = DirectEntry(text = "" ,scale=.05, pos = (-0.3, 0, 0.1),command=self.setPassText,initialText="password", numLines = 2,focus=0,focusInCommand=self.clearPassText, focusOutCommand=self.getPassText)
self.username = OnscreenText(text = "Username:"******"Password: "******"Interface/submitBtn.png", command=self.clickedSubmit, pos = (0.35, 0, -0.2),scale = (0.1, 1, 0.07))
self.submitBtn.setTransparency(TransparencyAttrib.MAlpha)
self.registerBtn = DirectButton(image = "Interface/registerBtn.png", command=self.clickedRegister, pos = (0.1, 0, -0.2),scale = (0.1, 1, 0.07))
self.registerBtn.setTransparency(TransparencyAttrib.MAlpha)
self.cancelBtn = DirectButton(image = "Interface/cancelBtn.png", command=self.clickedCancel, pos = (-0.35, 0, -0.2),scale = (0.1, 1, 0.07))
self.cancelBtn.setTransparency(TransparencyAttrib.MAlpha)
def createRegisterWindow(self):
self.window = OnscreenImage(image = "Interface/login_window.png", pos = (0,0,0), scale = (2, 1, 2) )
self.window.setTransparency(TransparencyAttrib.MAlpha)
self.username = OnscreenText(text = "Username:"******"Password: "******"Confirm Password: "******"" ,scale=.05, pos = (-0.3, 0, 0.3), command=self.setUserText,initialText="username", numLines = 1,focus=0,focusInCommand=self.clearRegUserText, focusOutCommand=self.getUserText)
self.regInputPass = DirectEntry(text = "" ,scale=.05, pos = (-0.3, 0, 0.1),command=self.setPassText,initialText="password", numLines = 1,focus=0,focusInCommand=self.clearRegPassText, focusOutCommand=self.getPassText)
self.regInputCPass = DirectEntry(text = "" ,scale=.05, pos = (-0.3, 0, -0.1),command=self.setPassText,initialText="confirm password", numLines = 1,focus=0,focusInCommand=self.clearRegCPassText, focusOutCommand=self.getPassText)
self.registerBtn = DirectButton(image = "Interface/registerBtn.png", command=self.clickedRegRegister, pos = (0.1, 0, -0.4),scale = (0.1, 1, 0.07))
self.registerBtn.setTransparency(TransparencyAttrib.MAlpha)
self.cancelBtn = DirectButton(image = "Interface/cancelBtn.png", command=self.clickedRegCancel, pos = (-0.35, 0, -0.4),scale = (0.1, 1, 0.07))
self.cancelBtn.setTransparency(TransparencyAttrib.MAlpha)
def processingLoginResponse(self, data):
self.msg1 = data.getInt32()
if self.msg1:
self.pl_list = []
self.welcome = data.getString()
self.pl_count = data.getInt32()
print "ResponseLogin - ", self.msg1
print "ResponseLogin msg- ", self.pl_count
for num in range (0,self.pl_count):
self.pl_list.append([num+1,data.getString()])
print self.pl_list
#h(self,self.welcome,self.pl_list)
self.world.CharSelect(self.welcome,self.pl_list)
else :
print "login error"
class Menu():
def __init__(self, parent):
self.parent = parent
self.whichfrom = "" #For telling backClicked which menu it came from
self.font = loader.loadFont("../assets/font/Orbitron Light.otf")
self.back = OnscreenImage(image = "../assets/2d/title_bg01.png", pos = (0, 0, 0), scale=(1.4,1,1))
self.startButton = DirectButton(image = "../assets/2d/buttons/start_on.png", image_scale = (.8, 1, .14), image_pos = (0, 0, .2), relief = None, command = self.startClicked)
self.rulesButton = DirectButton(image = "../assets/2d/buttons/rules_on.png", image_scale = (.8, 1, .14), image_pos = (0, 0, -.2), relief = None, command = self.rulesClicked)
#self.optButton = DirectButton(image = "../assets/2d/buttons/opt_on.png", image_scale = (.8, 1, .14), image_pos = (0, 0, -.4), relief = None, command = self.optClicked)
self.exitButton = DirectButton(image = "../assets/2d/buttons/exit_on.png", image_scale = (.8, 1, .14), image_pos = (0, 0, -.6), relief = None, command = self.exitClicked)
def startClicked(self):
self.startButton.destroy()
self.rulesButton.destroy()
#self.optButton.destroy()
self.exitButton.destroy()
self.back.destroy()
self.parent.beginGame() #This will make the rest of the game happen!
def rulesClicked(self):
self.startButton.destroy()
self.rulesButton.destroy()
#self.optButton.destroy()
self.exitButton.destroy()
self.back.destroy()
self.back = OnscreenImage(image = "../assets/2d/title_bg02.png", pos = (0, 0, 0), scale=(1.4,1,1))
self.line1 = OnscreenText(text = "Defeat enemy players by pushing them into the arena wall!", fg = (0,1,1,1), pos = (0, .8), scale = .07, font = self.font)
self.line2 = OnscreenText(text = "Use traps to snag them, and throw balls to push them!", fg = (0,1,1,1), pos = (0, .6), scale = .07, font = self.font)
self.line3 = OnscreenText(text = "Controls:", fg = (0,1,1,1), pos = (0, .4), scale = .1, font = self.font)
self.line4 = OnscreenText(text = "Left Click: Throw Ball/Place Trap", fg = (0,1,1,1), pos = (0, .2), scale = .07, font = self.font)
self.line5 = OnscreenText(text = "Scroll: Select Item", fg = (0,1,1,1), pos = (0, 0), scale = .07, font = self.font)
self.line6 = OnscreenText(text = "W/S: Jet Forward/Backward", fg = (0,1,1,1), pos = (0, -.2), scale = .07, font = self.font)
self.line7 = OnscreenText(text = "The more hits you take, the greater your momentum!", fg = (0,1,1,1), pos = (0, -.6), scale = .07, font = self.font)
self.whichfrom = "rules"
self.backButton = DirectButton(image = "../assets/2d/buttons/back_on.png", image_scale = (.4,1,.1), image_pos = (-.9, 0, -.87), relief = None, command = self.backClicked)
def optClicked(self):
print "options click!"
def backClicked(self):
self.backButton.destroy()
self.back.destroy()
if self.whichfrom == "rules":
self.line1.destroy()
self.line2.destroy()
self.line3.destroy()
self.line4.destroy()
self.line5.destroy()
self.line6.destroy()
self.line7.destroy()
self.__init__(self.parent) #Redoes the menu
def exitClicked(self):
sys.exit()
class EscenaMundo(DirectObject):
"""
* escena del mundo virtual
"""
Nombre = "mundo" # world
def __init__(self, contexto):
DirectObject.__init__(self)
# referencias
self.contexto = contexto
# componentes
self.mundo_fisica = BulletWorld() # physics world
self.debug_fisica = None
self.input = None
self.terreno = None # terrain
self.estaticos = None # static (model instances)
self.animados = list() # animated (model instances, actors)
self.items = None
self.atmosfera = None # atmosphere
self.cntrlcam = None # camera controller
self.texto_info = None # info text
self.debug_hud = None
# parametros
self.cargar_terreno = True
self.cargar_atmosfera = True
def iniciar(self):
log.info("iniciar")
self._establecer_parametros()
#
b = self.contexto.base
# física
self.mundo_fisica.setGravity(Vec3(0, 0, -9.81))
df = BulletDebugNode("debug_fisica")
self.mundo_fisica.setDebugNode(df)
self.debug_fisica = b.render.attachNewNode(df)
self.debug_fisica.hide()
self.accept("f11", self._toggle_debug_fisica)
# input
self.input = Input(self.contexto)
if not self.input.iniciar():
return False
# terreno
if self.cargar_terreno:
self.terreno = Terreno(self.contexto, self.mundo_fisica)
if not self.terreno.iniciar():
return False
# animados (actors)
self._iniciar_animados()
# atmosfera
if self.cargar_atmosfera:
self.atmosfera = Atmosfera(self.contexto)
if not self.atmosfera.iniciar():
return False
# controlador camara
self.cntrlcam = ControladorCamara(self.contexto)
if not self.cntrlcam.iniciar():
return False
# info texto
self.info_texto = OnscreenText(
text="cámara: f1:libre f2:1ºpers f3:3ºpers\n"
"debug física: f11")
# debug hud
self.debug_hud = OnscreenText(parent=b.a2dTopLeft,
text="Debug?",
pos=(0, -0.1),
scale=0.05,
align=TextNode.ALeft,
bg=(1, 1, 1, 0.3))
# pelota (ball)
pelota = b.loader.loadModel("modelos/items/pelota.egg")
pelota.reparentTo(b.render)
pelota.setPos(0, 0.5, 15)
b.messenger.send("establecer_objetivo", [pelota])
# eventos
self.accept("escape-up", self._salir)
# tasks
b.taskMgr.doMethodLater(0.1, self._update_debug_hud,
"Mundo_update_debug_hud")
b.taskMgr.add(self._update, "Mundo_update")
#
return True
def terminar(self):
log.info("terminar")
# tasks
self.contexto.base.taskMgr.remove("Mundo_update_debug_hud")
self.contexto.base.taskMgr.remove("Mundo_update")
# eventos
self.ignoreAll()
# camara
if self.cntrlcam:
self.cntrlcam.terminar()
self.cntrlcam = None
# debug hud
if self.debug_hud:
self.debug_hud.destroy()
self.debug_hud = None
# info texto
if self.info_texto:
self.info_texto.destroy()
self.info_texto = None
# atmosfera
if self.atmosfera:
self.atmosfera.terminar()
self.atmosfera = None
# animados
for animado in self.animados:
animado.terminar()
self.animados = list()
# terreno
if self.terreno:
self.terreno.terminar()
self.terreno = None
# input
if self.input:
self.input.terminar()
self.input = None
# física
self.mundo_fisica.clearDebugNode()
self.debug_fisica.removeNode()
def _establecer_parametros(self):
log.info("_establecer_parametros")
try:
cfg = self.contexto.config["mundo"]
self.cargar_terreno = cfg.getboolean("terreno")
self.cargar_atmosfera = cfg.getboolean("atmosfera")
except ValueError as e:
log.exception("error en el análisis de la configuración: " +
str(e))
def _iniciar_animados(self): # init animated (actors)
log.info("_iniciar_animados")
actor = Persona(self.contexto, self.input)
if actor.iniciar():
self.animados.append(actor)
def _toggle_texto_info(self):
pass
def _toggle_debug_fisica(self):
if self.debug_fisica.isHidden():
self.debug_fisica.show()
else:
self.debug_fisica.hide()
def _salir(self):
self.contexto.base.messenger.send("cambiar_escena", ["inicio"])
def _update_debug_hud(self, task):
info = "Debug\n"
#
info += self.input.obtener_info() + "\n"
if self.atmosfera:
info += self.atmosfera.obtener_info() + "\n"
#
self.debug_hud["text"] = info
return task.again
def _update(self, task):
# física
dt = self.contexto.base.taskMgr.globalClock.getDt()
self.mundo_fisica.doPhysics(dt, 10, 1.0 / 180.0)
#
return task.cont
class characterSelection(DirectObject):
TEXT_COLOR = (1, 1, 1, 1)
FONT_TYPE_01 = 0
TEXT_SHADOW_COLOR = (0, 0, 0, 0.5)
characterSelectionInput = ""
output = ""
frame = DirectFrame()
# character selection varaiables
createCharacter = DirectButton()
deleteCharacter = DirectButton()
selectCharacter = OnscreenText()
selectCharacterTextbox = DirectEntry()
selectCharacterInput = ""
referenceForSelection = OnscreenText()
myScrolledList = DirectScrolledList()
submitBtn = DirectButton()
cancelBtn = DirectButton()
# character deletion varaiables
selectCharactertodelete = OnscreenText()
deleteBtn = DirectButton()
delCancelBtn = DirectButton()
CharacterToDeleteTextbox = DirectEntry()
referenceForDeletion = OnscreenText()
CharacterToDeleteInput = " "
# character creation varaiables
v = [0]
v1 = [0]
nameOfChar = OnscreenText()
nameOfCharTextbox = DirectEntry()
factionSelection = OnscreenText()
nameOfCharInput = ""
def __init__(self):
print "Loading character selection..."
self.cManager = ConnectionManager()
self.startConnection()
frame = DirectFrame(
frameColor=(0, 0, 0, 1), # (R,G,B,A)
frameSize=(-3, 3, -3, 3), # (Left,Right,Bottom,Top)
pos=(-0.5, 0, 0.5),
)
self.createSelectionWindow()
def startConnection(self):
"""Create a connection to the remote host.
If a connection cannot be created, it will ask the user to perform
additional retries.
"""
if self.cManager.connection == None:
if not self.cManager.startConnection():
return False
return True
# character Creation
def createCreateCharWindow(self):
self.frame = DirectFrame(
frameColor=(0, 0, 0, 1), # (R,G,B,A)
frameSize=(-3, 3, -3, 3), # (Left,Right,Bottom,Top)
pos=(-0.5, 0, 0.9),
)
self.buttons = [
DirectRadioButton(
text=" Sword ", variable=self.v, value=[0], scale=0.07, pos=(-0.4, 0, 0.32), command=self.setText
),
DirectRadioButton(
text=" Axe ", variable=self.v, value=[1], scale=0.07, pos=(0.2, 0, 0.32), command=self.setText
),
]
for button in self.buttons:
button.setOthers(self.buttons)
self.nameOfChar = OnscreenText(
text="Name The Character :",
pos=(-0.2, -0.75),
scale=0.08,
fg=(1, 0.5, 0.5, 1),
align=TextNode.ACenter,
mayChange=0,
)
self.nameOfChar.reparentTo(self.frame)
self.nameOfCharTextbox = DirectEntry(
text="",
scale=0.07,
pos=(0.25, 0, -0.75),
command=self.setnameOfChar,
initialText="name of character",
numLines=1,
focus=0,
focusInCommand=self.clearnameOfChar,
focusOutCommand=self.getnameOfChar,
)
self.nameOfCharTextbox.reparentTo(self.frame)
self.factionSelection = OnscreenText(
text="Faction Selection :",
pos=(-0.15, -0.95),
scale=0.08,
fg=(1, 0.5, 0.5, 1),
align=TextNode.ACenter,
mayChange=0,
)
self.factionSelection.reparentTo(self.frame)
self.factionBtns = [
DirectRadioButton(
text=" Blue ", variable=self.v1, value=[0], scale=0.07, pos=(-0.05, 0, -0.05), command=self.setfaction
),
DirectRadioButton(
text=" Red ", variable=self.v1, value=[1], scale=0.07, pos=(0.3, 0, -0.05), command=self.setfaction
),
]
for button1 in self.factionBtns:
button1.setOthers(self.factionBtns)
self.okForCreateBtn = DirectButton(
text=("Ok", "Ok", "Ok", "disabled"), scale=0.08, command=self.clickedOkForCreateBtn, pos=(-0.05, 0.0, -1.25)
)
self.cancelForCreateBtn = DirectButton(
text=("Cancel", "Cancel", "Cancel", "disabled"),
scale=0.08,
command=self.clickedCancelForCreateBtn,
pos=(0.4, 0.0, -1.25),
)
self.okForCreateBtn.reparentTo(self.frame)
self.cancelForCreateBtn.reparentTo(self.frame)
def destroyCreateCharWindow(self):
self.frame.destroy()
self.nameOfChar.destroy()
self.nameOfCharTextbox.destroy()
self.factionSelection.destroy()
self.okForCreateBtn.destroy()
self.cancelForCreateBtn.destroy()
def clearnameOfChar(self):
self.nameOfCharTextbox.enterText("")
def getnameOfChar(self):
self.nameOfCharInput = self.nameOfCharTextbox.get()
def setnameOfChar(self, textEntered):
print "name Of Char: ", textEntered
self.nameOfChar = textEntered
def clickedOkForCreateBtn(self):
print "you have pressed the ok button for creating a character"
def clickedCancelForCreateBtn(self):
print "you have press the cancel button from the create character frame"
self.destroyCreateCharWindow()
self.createSelectionWindow()
def setText(status=None):
bk_text = "CurrentValue "
def setfaction(status=None):
bk_text = "CurrentValue "
# character deletion
def createDeleteCharWindow(self):
self.frame = DirectFrame(
frameColor=(0, 0, 0, 1), # (R,G,B,A)
frameSize=(-3, 3, -3, 3), # (Left,Right,Bottom,Top)
pos=(-0.5, 0, 0.9),
)
self.selectCharactertodelete = OnscreenText(
text="Select Character :",
pos=(-0.02, -0.35),
scale=0.08,
fg=(1, 0.5, 0.5, 1),
align=TextNode.ACenter,
mayChange=0,
)
self.selectCharactertodelete.reparentTo(self.frame)
self.selectCharacterToDeleteTextbox = DirectEntry(
text="",
scale=0.07,
pos=(0.45, 0, -0.35),
command=self.setselectCharacterToDelete,
initialText="name of character",
numLines=1,
focus=0,
focusInCommand=self.clearselectCharacterToDelete,
focusOutCommand=self.getselectCharacterToDelete,
)
self.selectCharacterToDeleteTextbox.reparentTo(self.frame)
self.referenceForDeletion = OnscreenText(
text="Reference to Character List:",
pos=(-0.15, -0.75),
scale=0.08,
fg=(1, 0.5, 0.5, 1),
align=TextNode.ACenter,
mayChange=0,
)
self.referenceForDeletion.reparentTo(self.frame)
self.deleteScrolledList = DirectScrolledList(
decButton_pos=(0.35, 0, 0.53),
decButton_text="Dec",
decButton_text_scale=0.04,
decButton_borderWidth=(0.005, 0.005),
incButton_pos=(0.35, 0, -0.02),
incButton_text="Inc",
incButton_text_scale=0.04,
incButton_borderWidth=(0.005, 0.005),
pos=(0.7, 0, -0.99),
numItemsVisible=4,
forceHeight=0.11,
itemFrame_frameSize=(-0.6, 0.6, -0.37, 0.11),
itemFrame_pos=(0.35, 0, 0.4),
)
for playerchar in ["xxxbluesword", "xxxblueaxe", "xxxredsword", "xxxredsword01", "xxx_red_sword04"]:
l = DirectLabel(text=playerchar, text_scale=0.1)
self.deleteScrolledList.addItem(l)
self.deleteScrolledList.reparentTo(self.frame)
self.deleteBtn = DirectButton(
text=("Delete", "Delete", "Delete", "disabled"),
scale=0.08,
command=self.clickedDelete,
pos=(-0.2, 0.0, -1.25),
)
self.delCancelBtn = DirectButton(
text=("Cancel", "Cancel", "Cancel", "disabled"),
scale=0.08,
command=self.clickedDelCancel,
pos=(0.3, 0.0, -1.25),
)
self.deleteBtn.reparentTo(self.frame)
self.delCancelBtn.reparentTo(self.frame)
def destroyDeleteCharWindow(self):
self.frame.destroy()
self.selectCharactertodelete.destroy()
self.deleteBtn.destroy()
self.delCancelBtn.destroy()
self.selectCharacterToDeleteTextbox.destroy()
self.referenceForDeletion.destroy()
def clearselectCharacterToDelete(self):
self.selectCharacterToDeleteTextbox.enterText("")
def getselectCharacterToDelete(self):
self.selectCharacterToDeleteInput = self.nameOfCharTextbox.get()
def setselectCharacterToDelete(self, textEntered):
print "name Of Char: ", textEntered
self.selectCharacterToDelete = textEntered
def clickedDelete(self):
print "You pressed delete a character"
def clickedDelCancel(self):
print "to go back to slection menu"
self.destroyDeleteCharWindow()
self.createSelectionWindow()
# character Selection
def createSelectionWindow(self):
self.frame = DirectFrame(
frameColor=(0, 0, 0, 1), # (R,G,B,A)
frameSize=(-3, 3, -3, 3), # (Left,Right,Bottom,Top)
pos=(-0.5, 0, 0.9),
)
self.createCharacter = DirectButton(
text=("Create Character", "Create Character", "Create Character", "disabled"),
scale=0.08,
command=self.clickedCreateChar,
pos=(-0.14, 0.0, -0.25),
)
self.deleteCharacter = DirectButton(
text=("Delete Character", "Delete Character", "Delete Character", "disabled"),
scale=0.08,
command=self.clickedDeleteChar,
pos=(-0.14, 0.0, -0.40),
)
self.createCharacter.reparentTo(self.frame)
self.deleteCharacter.reparentTo(self.frame)
self.selectCharacter = OnscreenText(
text="Select Character :",
pos=(-0.12, -0.55),
scale=0.08,
fg=(1, 0.5, 0.5, 1),
align=TextNode.ACenter,
mayChange=0,
)
self.selectCharacter.reparentTo(self.frame)
self.myScrolledList = DirectScrolledList(
decButton_pos=(0.35, 0, 0.53),
decButton_text="Dec",
decButton_text_scale=0.04,
decButton_borderWidth=(0.005, 0.005),
incButton_pos=(0.35, 0, -0.02),
incButton_text="Inc",
incButton_text_scale=0.04,
incButton_borderWidth=(0.005, 0.005),
pos=(0.05, 0, -0.3),
numItemsVisible=4,
forceHeight=0.11,
itemFrame_frameSize=(-0.6, 0.6, -0.37, 0.11),
itemFrame_pos=(0.35, 0, 0.4),
)
self.selectCharacterTextbox = DirectEntry(
text="",
scale=0.07,
pos=(0.28, 0, -0.55),
command=self.setselectCharacterTextbox,
initialText="name of character",
numLines=1,
focus=0,
focusInCommand=self.clearselectCharacterTextbox,
focusOutCommand=self.getselectCharacterTextbox,
)
self.selectCharacterTextbox.reparentTo(self.frame)
self.referenceForSeletion = OnscreenText(
text="Reference to Character List:\n that already exists",
pos=(-0.30, -0.75),
scale=0.08,
fg=(1, 0.5, 0.5, 1),
align=TextNode.ACenter,
mayChange=0,
)
self.referenceForSeletion.reparentTo(self.frame)
for playerchar in ["xxxbluesword", "xxxblueaxe", "xxxredsword", "xxxredsword01", "xxx_red_sword04"]:
l = DirectLabel(text=playerchar, text_scale=0.1)
self.myScrolledList.addItem(l)
self.submitBtn = DirectButton(
text=("Start", "Start", "Start", "disabled"), scale=0.08, command=self.clickedSubmit, pos=(-0.2, 0.0, -1.45)
)
self.cancelBtn = DirectButton(
text=("Cancel", "Cancel", "Cancel", "disabled"),
scale=0.08,
command=self.clickedCancel,
pos=(0.3, 0.0, -1.45),
)
self.submitBtn.reparentTo(self.frame)
self.cancelBtn.reparentTo(self.frame)
def destroySelectionWindow(self):
self.frame.destroy()
self.selectCharacter.destroy()
self.createCharacter.destroy()
self.deleteCharacter.destroy()
self.submitBtn.destroy()
self.cancelBtn.destroy()
def clearselectCharacterTextbox(self):
self.selectCharacterTextbox.enterText("")
def getselectCharacterTextbox(self):
self.selectCharacterTextbox = self.selectCharacterTextbox.get()
def setselectCharacterTextbox(self, textEntered):
print "name Of Char: ", textEntered
self.selectCharacterTextbox = textEntered
def clickedCreateChar(self):
print "You pressed create a new character"
self.destroySelectionWindow()
self.createCreateCharWindow()
def clickedDeleteChar(self):
print "You pressed delete a character"
self.destroySelectionWindow()
self.createDeleteCharWindow()
def clickedSubmit(self):
print "you pressed start button"
def clickedCancel(self):
print "You pressed Cancel"
class TeamActivityGui:
COUNTDOWN_TASK_NAME = 'updateCountdownTask'
timer = None
statusText = None
countdownText = None
exitButton = None
switchButton = None
def __init__(self, activity):
self.activity = activity
def load(self):
buttonModels = loader.loadModel('phase_3.5/models/gui/inventory_gui')
upButton = buttonModels.find('**//InventoryButtonUp')
downButton = buttonModels.find('**/InventoryButtonDown')
rolloverButton = buttonModels.find('**/InventoryButtonRollover')
self.exitButton = DirectButton(
relief=None,
text=TTLocalizer.PartyTeamActivityExitButton,
text_fg=(1, 1, 0.65, 1),
text_pos=(0, -0.15),
text_scale=0.5,
image=(upButton, downButton, rolloverButton),
image_color=(1, 0, 0, 1),
image_scale=(14.5, 1, 9),
pos=(0, 0, 0.8),
scale=0.15,
command=self.handleExitButtonClick)
self.exitButton.hide()
if self.activity.toonsCanSwitchTeams():
self.switchButton = DirectButton(
relief=None,
text=TTLocalizer.PartyTeamActivitySwitchTeamsButton,
text_fg=(1, 1, 1, 1),
text_pos=(0, 0.1),
text_scale=0.5,
image=(upButton, downButton, rolloverButton),
image_color=(0, 1, 0, 1),
image_scale=(15, 1, 15),
pos=(0, 0, 0.5),
scale=0.15,
command=self.handleSwitchButtonClick)
self.switchButton.hide()
else:
self.switchButton = None
buttonModels.removeNode()
self.countdownText = OnscreenText(
text='',
pos=(0.0, -0.2),
scale=PartyGlobals.TeamActivityTextScale * 1.2,
fg=(1.0, 1.0, 0.65, 1.0),
align=TextNode.ACenter,
font=ToontownGlobals.getSignFont(),
mayChange=True)
self.countdownText.hide()
self.statusText = OnscreenText(
text='',
pos=(0.0, 0.0),
scale=PartyGlobals.TeamActivityTextScale,
fg=PartyGlobals.TeamActivityStatusColor,
align=TextNode.ACenter,
font=ToontownGlobals.getSignFont(),
mayChange=True)
self.statusText.hide()
self.timer = PartyUtils.getNewToontownTimer()
self.timer.hide()
return
def unload(self):
self.hideWaitToStartCountdown()
if self.exitButton is not None:
self.exitButton.destroy()
self.exitButton = None
if self.switchButton is not None:
self.switchButton.destroy()
self.switchButton = None
if self.countdownText is not None:
self.countdownText.destroy()
self.countdownText.removeNode()
self.countdownText = None
if self.statusText is not None:
self.statusText.destroy()
self.statusText.removeNode()
self.statusText = None
if self.timer is not None:
self.timer.destroy()
del self.timer
return
def showStatus(self, text):
self.statusText.setText(text)
self.statusText.show()
def hideStatus(self):
self.statusText.hide()
def enableExitButton(self):
self.exitButton.show()
def disableExitButton(self):
self.exitButton.hide()
def handleExitButtonClick(self):
self.disableExitButton()
self.disableSwitchButton()
self.activity.d_toonExitRequest()
def enableSwitchButton(self):
self.switchButton.show()
def disableSwitchButton(self):
if self.switchButton is not None:
self.switchButton.hide()
return
def handleSwitchButtonClick(self):
self.disableSwitchButton()
self.disableExitButton()
self.activity.d_toonSwitchTeamRequest()
def showWaitToStartCountdown(self,
duration,
waitToStartTimestamp,
almostDoneCallback=None):
self._countdownAlmostDoneCallback = almostDoneCallback
currentTime = globalClock.getRealTime()
waitTimeElapsed = currentTime - waitToStartTimestamp
if duration - waitTimeElapsed > 1.0:
countdownTask = Task(self._updateCountdownTask)
countdownTask.duration = duration - waitTimeElapsed
self.countdownText.setText(str(int(countdownTask.duration)))
self.countdownText.show()
taskMgr.remove(TeamActivityGui.COUNTDOWN_TASK_NAME)
taskMgr.add(countdownTask, TeamActivityGui.COUNTDOWN_TASK_NAME)
def hideWaitToStartCountdown(self):
taskMgr.remove(TeamActivityGui.COUNTDOWN_TASK_NAME)
self._countdownAlmostDoneCallback = None
if self.countdownText is not None:
self.countdownText.hide()
return
def _updateCountdownTask(self, task):
countdownTime = int(task.duration - task.time)
seconds = str(countdownTime)
if self.countdownText['text'] != seconds:
self.countdownText['text'] = seconds
if countdownTime == 3 and self._countdownAlmostDoneCallback is not None:
self._countdownAlmostDoneCallback()
self._countdownAlmostDoneCallback = None
if task.time >= task.duration:
return Task.done
else:
return Task.cont
return
def showTimer(self, duration):
self.timer.setTime(duration)
self.timer.countdown(duration, self._handleTimerExpired)
self.timer.show()
def hideTimer(self):
self.timer.hide()
self.timer.stop()
def _handleTimerExpired(self):
self.activity.handleGameTimerExpired()
class Player(GameObject):
def __init__(self,
modelName,
model_anims,
max_health,
speed,
collider_name,
base,
pos,
hpr=Vec3(0, 0, 0),
scale=1.0):
GameObject.__init__(self, modelName, model_anims, max_health, speed,
collider_name, base, pos, hpr, scale)
self.player_init()
def player_init(self):
self.base.pusher.addCollider(self.collider, self.actor)
self.base.cTrav.addCollider(self.collider, self.base.pusher)
self.collider.setPythonTag("player", self)
self.score = 0
self.score_string = str(self.score)
# self.base.camLens.setFov(150) #----------------------------------------------
# self.base.camLens.setFov(5)
self.textObject = OnscreenText(text='Score:' + self.score_string,
pos=(-1.15, -0.95),
scale=0.1)
self.ray = CollisionRay(0, 0, 0, 0, -1, 0)
rayNode = CollisionNode("playerRay")
rayNode.addSolid(self.ray)
self.rayNodePath = self.actor.attachNewNode(rayNode)
self.rayQueue = CollisionHandlerQueue()
self.base.cTrav.addCollider(self.rayNodePath, self.rayQueue)
# self.damagePerSecond = -5.0
self.beamModel = self.base.loader.loadModel("models/frowney")
self.beamModel.reparentTo(self.actor)
self.beamModel.setZ(10)
self.beamModel.setLightOff()
self.beamModel.hide()
def move(self, movement_vector):
anim_controller = self.actor.getAnimControl("walk")
if not anim_controller.isPlaying():
self.actor.play("walk")
self.actor.setPos(self.actor, movement_vector * self.speed)
def stop(self):
anim_controller = self.actor.getAnimControl("walk")
anim_controller.stop()
def change_health(self, dHealth):
GameObject.change_health(self, dHealth)
if self.health == 0:
# imageOnject = OnscreenImage(image = "game_over.png")
self.cleanup()
sys.exit()
def update_score(self):
self.score_string = str(self.score)
self.textObject.destroy()
self.textObject = OnscreenText(text='Score:' + self.score_string,
pos=(-1.15, -0.95),
scale=0.1)
def shoot(self):
dt = globalClock.getDt()
# print(self.rayQueue.getNumEntries())
# print(self.rayQueue)
if self.rayQueue.getNumEntries() > 0:
self.rayQueue.sortEntries()
rayHit = self.rayQueue.getEntry(1)
hitPos = rayHit.getSurfacePoint(self.base.render)
# print(hitPos, "hitpos")
# print(rayHit, "rayhit")
# beamLength = (hitPos - self.actor.getPos()).length()
# print("length: ", beamLength)
hitNodePath = rayHit.getIntoNodePath()
# print(hitNodePath)
# print(hitNodePath.getPythonTag)
# print(hitPos)
# print(hitNodePath.getTag)
# print(hitNodePath.hasPythonTag("enemy"))
# print(rayHit.getFrom())
if hitNodePath.hasPythonTag("enemy"):
# print("here")
hitObject = hitNodePath.getPythonTag("enemy")
hitObject.change_health(-1)
# Find out how long the beam is, and scale the
# beam-model accordingly.
# print(self.actor.getPos())
beamLength = (hitPos - (self.actor.getPos())).length()
self.beamModel.setSy(-beamLength)
self.score += 1
self.update_score()
self.beamModel.show()
else:
# If we're not shooting, don't show the beam-model.
self.beamModel.hide()
class DeveloperConsole(InteractiveInterpreter, DirectObject):
"""The name says it all."""
def __init__(self, manager, xml):
sys.stdout = PseudoFile(self.writeOut)
sys.stderr = PseudoFile(self.writeErr)
tpErr = TextProperties()
tpErr.setTextColor(1, 0.5, 0.5, 1)
TextPropertiesManager.getGlobalPtr().setProperties("err", tpErr)
self.manager = manager
font = loader.loadFont("cmss12")
self.frame = DirectFrame(parent=base.a2dTopCenter,
text_align=TextNode.ALeft,
text_pos=(-base.getAspectRatio() +
TEXT_MARGIN[0], TEXT_MARGIN[1]),
text_scale=0.05,
text_fg=(1, 1, 1, 1),
frameSize=(-2.0, 2.0, -0.5, 0.0),
frameColor=(0, 0, 0, 0.5),
text='',
text_font=font)
self.entry = DirectEntry(parent=base.a2dTopLeft,
command=self.command,
scale=0.05,
width=1000.0,
pos=(-0.02, 0, -0.48),
relief=None,
text_pos=(1.5, 0, 0),
text_fg=(1, 1, 0.5, 1),
rolloverSound=None,
clickSound=None,
text_font=font)
self.otext = OnscreenText(parent=self.entry,
scale=1,
align=TextNode.ALeft,
pos=(1, 0, 0),
fg=(1, 1, 0.5, 1),
text=':',
font=font)
self.lines = [''] * 9
self.commands = [] # All previously sent commands
self.cscroll = None # Index of currently navigated command, None if current
self.command = '' # Currently entered command
self.block = '' # Temporarily stores a block of commands
self.hide()
self.initialized = False
def prevCommand(self):
if self.hidden: return
if len(self.commands) == 0: return
if self.cscroll == None:
self.cscroll = len(self.commands)
self.command = self.entry.get()
elif self.cscroll <= 0:
return
else:
self.commands[self.cscroll] = self.entry.get()
self.cscroll -= 1
self.entry.set(self.commands[self.cscroll])
self.entry.setCursorPosition(len(self.commands[self.cscroll]))
def nextCommand(self):
if self.hidden: return
if len(self.commands) == 0: return
if self.cscroll == None: return
self.commands[self.cscroll] = self.entry.get()
self.cscroll += 1
if self.cscroll >= len(self.commands):
self.cscroll = None
self.entry.set(self.command)
self.entry.setCursorPosition(len(self.command))
else:
self.entry.set(self.commands[self.cscroll])
self.entry.setCursorPosition(len(self.commands[self.cscroll]))
def writeOut(self, line, copy=True):
if copy: sys.__stdout__.write(line)
lines = line.split('\n')
firstline = lines.pop(0)
self.lines[-1] += firstline
self.lines += lines
self.frame['text'] = '\n'.join(self.lines[-9:])
def writeErr(self, line, copy=True):
if copy: sys.__stderr__.write(line)
line = '\1err\1%s\2' % line
lines = line.split('\n')
firstline = lines.pop(0)
self.lines[-1] += firstline
self.lines += lines
self.frame['text'] = '\n'.join(self.lines[-9:])
def command(self, text):
if not self.hidden:
self.cscroll = None
self.command = ''
self.entry.set('')
self.entry['focus'] = True
self.writeOut(self.otext['text'] + ' ' + text + '\n', False)
if text != '' and (len(self.commands) == 0
or self.commands[-1] != text):
self.commands.append(text)
# Insert plugins into the local namespace
locals = __main__.__dict__
locals['manager'] = self.manager
for plugin in self.manager.named.keys():
locals[plugin] = self.manager.named[plugin]
locals['panda3d'] = panda3d
# Run it and print the output.
if not self.initialized:
InteractiveInterpreter.__init__(self, locals=locals)
self.initialized = True
try:
if self.runsource(self.block + '\n' + text) and text != '':
self.otext['text'] = '.'
self.block += '\n' + text
else:
self.otext['text'] = ':'
self.block = ''
except Exception: # Not just "except", it will also catch SystemExit
# Whoops! Print out a traceback.
self.writeErr(traceback.format_exc())
def toggle(self):
if self.hidden:
self.show()
else:
self.hide()
def show(self):
self.accept('arrow_up', self.prevCommand)
self.accept('arrow_up-repeat', self.prevCommand)
self.accept('arrow_down', self.nextCommand)
self.accept('arrow_down-repeat', self.nextCommand)
self.hidden = False
self.entry['focus'] = True
self.frame.show()
self.entry.show()
self.otext.show()
def hide(self):
self.ignoreAll()
self.hidden = True
self.entry['focus'] = False
self.frame.hide()
self.entry.hide()
self.otext.hide()
def destroy(self):
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
self.ignoreAll()
self.frame.destroy()
self.entry.destroy()
self.otext.destroy()
class RaceDrone(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# initalize the window
base.disableMouse()
self.win.setClearColor((0, 0, 0, 1))
props = WindowProperties()
props.setCursorHidden(True)
props.setSize(1700,1000)
base.win.requestProperties(props)
# store keys
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "backward": 0,
"drift-left": 0, "drift-right": 0, "up": 0, "down": 0,
"restart": 0, "firstPerson": 0, "gravity": 0}
#instructions
self.ins2 = addInstructions(0.12, "[Left/Right Arrow]: Rotate Left/Right")
self.ins3 = addInstructions(0.18, "[Up/Down Arrow]: Fly Forward/Backward")
self.ins4 = addInstructions(0.24, "[A, D]: Move Camera")
self.ins5 = addInstructions(0.30, "[W, S]: Lift / Descent")
self.ins6 = addInstructions(0.36, "[F]: Toggle First Person/ Third Person")
self.ins7 = addInstructions(0.42, "[G]: Toggle Gravity")
self.ins8 = addInstructions(0.48, "[R]: Restart")
# Set up the playground
# other maps:
# models/toon/phase_15/hood/toontown_central.bam
# models/world
# CS_Map/myCSMAP.egg
# Race/RaceTrack/FullTrack.blend
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.mapScale = 1
"""
self.environ = loader.loadModel("The City/The City.obj")
self.environ.reparentTo(render)
myTexture = loader.loadTexture("The City/Maps/cty1.jpg")
self.environ.setTexture(myTexture)
self.environ.setHpr(0,90,0)
self.environ.setScale(.1)
"""
# Create drone and initalize drone position
self.Drone = Actor("models/mydrone.egg")
self.Drone.reparentTo(render)
# resize and reposition the drone
self.Drone.setScale(.1)
self.Drone.setPos(5,5,8)
self.Drone.setH(180)
# initial position is saved for restarting the game
self.DroneStartPos = self.Drone.getPos()
# User Controls
self.accept('escape', __import__('sys').exit, [0])
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("a", self.setKey, ["drift-left", True])
self.accept("d", self.setKey, ["drift-right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.accept("a-up", self.setKey, ["drift-left", False])
self.accept("d-up", self.setKey, ["drift-right", False])
self.accept("w", self.setKey, ["up", True])
self.accept("w-up", self.setKey, ["up", False])
self.accept("s", self.setKey, ["down", True])
self.accept("s-up", self.setKey, ["down", False])
self.accept("r", self.setKey, ["restart", True])
self.accept("r-up", self.setKey, ["restart", False])
self.accept("f", self.setKey, ["firstPerson", True])
self.accept("f-up", self.setKey, ["firstPerson", False])
self.accept("g", self.setKey, ["gravity", True])
self.accept("g-up", self.setKey, ["gravity", False])
taskMgr.add(self.move, "moveTask")
# Disable Mouse
self.disableMouse()
# Camera settings
self.cameraDistance = 5
self.cameraPitch = -10
# create the collision box for the drone
# this collision box will be used for collision detection
self.droneBox = CollisionBox((0,0,2.5), 3, 3, 0.7)
self.cnodePath = self.Drone.attachNewNode(CollisionNode('cnode'))
self.cnodePath.node().addSolid(self.droneBox)
# collision detection set up
self.cTrav = CollisionTraverser()
self.queue = CollisionHandlerQueue()
self.cTrav.addCollider(self.cnodePath, self.queue)
self.cTrav.traverse(render)
# Lighting portion are modified from an example provided by Panda3d – Roaming Ralph
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((1, 1, 1, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Crashed Text
self.crashed = OnscreenText()
self.firstPerson = False
# HPR setting
self.angle = 0
self.angleChange = 0.5
self.maxAngle = 15
# Speed Control
self.FBSpeed = self.mapScale * 6
self.LRSpeed = self.mapScale * 4
self.turnSpeed = 80
self.liftSpeed = self.mapScale * 80
self.downSpeed = self.mapScale * 80
# AI set up
self.AI = True
if self.AI:
self.droneAI = Actor("models/mydrone.egg")
self.droneAI.reparentTo(render)
self.droneAI.setScale(.1)
self.droneAI.setPos(5,5,5)
self.AI_actions = open("AI/RoamingRalph/AI_easy.txt", "r").readlines()
#######################
# additional features #
#######################
# acceleration
self.FBacceleration = 0
self.LRacceleration = 0
self.accelMax = 40
self.accelIncrement = 2
# gravity
self.gravity = True
self.gravity_value = 15 * self.mapScale
# Record user inputs
def setKey(self, key, value):
self.keyMap[key] = value
# Main Function (Deal with user interface and collision detection)
def move(self, task):
#debug
#print(self.queue.getEntries())
#print(self.drone.getPos())
#print(self.FBacceleration, self.LRacceleration)
# crash message
self.crashed.destroy()
self.crashed = OnscreenText(text="Crashed!!!" if len(self.queue.getEntries()) != 0 else "", pos = (-0.5, 0.02),
scale = 0.07, mayChange = True, fg = (255,255,255,1))
# Get the time that elapsed since last frame.
dt = globalClock.getDt()
# control the movement of AI
if self.AI:
if self.AI_actions != []:
curAction = self.AI_actions[0].split(" ")
self.droneAI.setX(float(curAction[0]))
self.droneAI.setY(float(curAction[1]))
self.droneAI.setZ(float(curAction[2]))
self.droneAI.setH(float(curAction[3]))
self.droneAI.setP(float(curAction[4]))
self.droneAI.setR(float(curAction[5]))
self.AI_actions.pop(0)
# Drone is movable only when it's not crashed
if len(self.queue.getEntries()) == 0:
# initial height
curHeight = self.Drone.getZ()
# move by acceleration
if self.FBacceleration != 0:
self.Drone.setX(self.Drone, self.FBSpeed * self.FBacceleration * dt)
self.FBacceleration += 1 if self.FBacceleration < 0 else -1
if self.LRacceleration != 0:
self.Drone.setY(self.Drone, self.LRSpeed * self.LRacceleration * dt)
self.LRacceleration += 1 if self.LRacceleration < 0 else -1
self.Drone.setZ(curHeight)
# tilting while drift left and right
if self.keyMap["drift-left"]:
#self.Drone.setY(self.Drone, self.LRSpeed * dt)
# tilt left when drift left
if self. angle > -self.maxAngle:
self.angle -= self.angleChange
self.Drone.setP(self.angle)
if self.LRacceleration < self.accelMax:
self.LRacceleration += self.accelIncrement
elif self.keyMap["drift-right"]:
#self.Drone.setY(self.Drone, -self.LRSpeed * dt)
# tilt right when drift right
if self. angle < self.maxAngle:
self.angle += self.angleChange
self.Drone.setP(self.angle)
if self.LRacceleration > -self.accelMax:
self.LRacceleration -= self.accelIncrement
# gradually stablize itself while drift-keys are not pressed
else:
if self.angle >=self.angleChange:
self.angle -= self.angleChange
elif self.angle <=-self.angleChange:
self.angle +=self.angleChange
self.Drone.setP(self.angle)
# turn left
if self.keyMap["left"]:
self.Drone.setH(self.Drone.getH() + self.turnSpeed * dt)
# turn right
if self.keyMap["right"]:
self.Drone.setH(self.Drone.getH() - self.turnSpeed * dt)
# go forward
if self.keyMap["forward"]:
#self.Drone.setX(self.Drone, self.FBSpeed * dt)
if self.FBacceleration < self.accelMax:
self.FBacceleration += self.accelIncrement
elif self.keyMap["backward"]:
#self.Drone.setX(self.Drone, -self.FBSpeed * dt)
if self.FBacceleration > -self.accelMax:
self.FBacceleration -= self.accelIncrement
# lift up
if self.keyMap["up"]:
self.Drone.setZ(self.Drone, self.liftSpeed * dt)
# go down
if self.keyMap["down"]:
self.Drone.setZ(self.Drone, -self.downSpeed * dt)
# gravity
if self.gravity:
self.Drone.setZ(self.Drone, -self.gravity_value * dt)
# restart game / reset position
if self.keyMap["restart"]:
self.Drone.setPos(self.DroneStartPos + (0, 0, 5))
self.collisionCount = False
self.crashed.destroy()
self.Drone.setH(180)
# First Person View / Third Person View Toggle
if self.keyMap["firstPerson"]:
self.firstPerson = not self.firstPerson
# Gravity Toggle
if self.keyMap["gravity"]:
self.gravity = not self.gravity
# uncomment the following code to see the collision box
########################
#self.cnodePath.show() #
########################
# set the position and HPR of the camera according to the position of the drone
# First Person View
if self.firstPerson:
base.camera.setH(self.Drone.getH()-90)
base.camera.setP(self.Drone.getR())
base.camera.setR(self.Drone.getP())
base.camera.setPos(self.Drone.getPos())
# Third Person View
else:
base.camera.setHpr(self.Drone.getHpr()+(180,0,0))
h,p,r = self.Drone.getHpr()
base.camera.setPos(self.Drone.getPos() + (math.cos(math.pi * h / 180) * -self.cameraDistance, \
math.sin(math.pi * h / 180) * -self.cameraDistance, 0.5))
viewTarget = Point3(self.Drone.getPos() + (0,0,0)) # the look-at point can be changed
base.camera.lookAt(viewTarget)
return task.cont
class Menu:
def __init__(self):
self.count = 0
self.x = {}
self.y = {}
self.z = {}
self.Gstart = 0
self.slist = False
self.nlist = False
self.connected = False
self.music = loader.loadSfx("sounds/music/menu.wav")
self.engine = loader.loadSfx("sounds/sfx/engine5.wav")
self.engine.setLoop(True)
self.engine.setVolume(.7)
self.music.setLoop(True)
self.music.setVolume(.7)
self.music.play()
self.name = ""
self.font = loader.loadFont("cmr12.egg")
self.myImage = OnscreenImage(image='bg.jpg',
pos=(0, 0, 0),
scale=(2, 2, 1))
self.myImage.setTransparency(TransparencyAttrib.MAlpha)
self.welcome = OnscreenText(
text="Welcome to 3d multiplayer Racing Game",
fg=Vec4(1, 1, 1, 1),
shadow=Vec4(0, 0, 0, 1),
scale=0.10,
pos=(0, .8, 0))
self.bk_text = " "
self.textObject = OnscreenText(text=self.bk_text,
pos=(0.95, -0.95),
scale=0.07,
fg=(1, 0.5, 0.5, 0),
align=TextNode.ACenter,
mayChange=1,
font=self.font,
shadow=Vec4(0, 0, 0, 1),
bg=(1, 1, 1, .2))
self.b = DirectEntry(scale=.05,
command=self.setText,
initialText="Enter your name",
numLines=1,
focus=0,
focusInCommand=self.clearText,
entryFont=self.font,
width=20,
pos=(-0.5, 0, 0),
borderWidth=(0.5, 0.5),
color=(1, 1, 1, 0.5),
autoCapitalize=1)
self.b.setTransparency(TransparencyAttrib.MDual)
def setText(self, textEntered):
self.name = textEntered
cl.SetName(self.name)
self.textObject.setText("Welcome " + textEntered)
self.client()
def createDirectlist(self):
numItemsVisible = 4
itemHeight = 0.11
myScrolledList = DirectScrolledList(
decButton_pos=(0.35, 0, 0.53),
decButton_text="Dec",
decButton_text_scale=0.04,
decButton_borderWidth=(0.005, 0.005),
incButton_pos=(0.35, 0, -0.02),
incButton_text="Inc",
incButton_text_scale=0.04,
incButton_borderWidth=(0.005, 0.005),
frameSize=(0.0, 0.7, -0.05, 0.59),
frameColor=(1, 0, 0, 0.5),
pos=(-1, 0, 0),
numItemsVisible=numItemsVisible,
forceHeight=itemHeight,
itemFrame_frameSize=(-0.2, 0.2, -0.37, 0.11),
itemFrame_pos=(0.35, 0, 0.4),
)
return myScrolledList
def clearText(self):
self.b['color'] = Vec4(1, 1, 1, 1)
self.b.enterText('')
def client(self):
self.b.destroy()
self.textObject['fg'] = Vec4(1, 1, 1, 1)
self.refresh = DirectButton(text=("", "", "", "disabled"),
scale=.05,
command=self.refresh,
pos=(0.95, -0.95, 0),
image="refresh.png",
image_scale=2)
self.refresh.setTransparency(TransparencyAttrib.MAlpha)
def refresh(self):
if self.slist:
self.slist.destroy()
if self.nlist:
self.nlist.destroy()
if self.connected:
self.getMembers()
else:
for k, v in cl.servers.iteritems():
self.addserver(k, v)
def addserver(self, k, v):
print "inside addserver()"
self.slist = self.createDirectlist()
self.x[self.count] = k
self.y[self.count] = v
self.z[self.count] = DirectButton(text=v,
scale=.05,
command=self.connectServer,
extraArgs=str(self.count))
self.slist.addItem(self.z[self.count])
self.count = self.count + 1
def clearServers(self):
for i in range(0, self.count):
self.z[i].destroy()
self.slist.destroy()
self.count = 0
def connectServer(self, count):
#print count
#print self.x[int(count)]
self.slist.destroy()
self.connected = True
self.clearServers()
cl.connectServer(str(self.x[int(count)]))
self.getMembers()
def getMembers(self):
self.nlist = self.createDirectlist()
cl.RequestServer()
x = int(cl.getTotalUsers())
cl.RequestServer()
cl.getUsers()
for i in range(0, x):
l = cl.getInput(1)
k = cl.getInput(int(l))
l = DirectLabel(text=str(k), text_scale=0.05)
self.nlist.addItem(l)
if x > 1:
self.start = DirectButton(text=("", "", "", "disabled"),
scale=.05,
command=self.destroy,
pos=(0.2, -0.95, 0),
image="start.jpg",
image_scale=2)
self.start.setTransparency(TransparencyAttrib.MAlpha)
cl.ExitReqServer()
#self.c.RequestServer()
#self.c.getTotalUsers()
#self.c.getTotalUsers(s)
def sendY(self, Y):
cl.sendY(Y)
def sendH(self, H):
cl.sendH(H)
def destroy(self):
self.Gstart = 1
self.nlist.destroy()
self.myImage.destroy()
self.welcome.destroy()
self.b.destroy()
self.textObject.destroy()
self.start.destroy()
self.start.destroy()
self.refresh.destroy()
self.self = None
return
class cApplication(DirectObject):
def __init__(self):
# create world
self.world = cWorld()
# setup controls
self.setupControls()
# display title information
self.title = OnscreenText(text='BOIDS.PY - SEEK & ARRIVE',
fg=(1.0, 1.0, 1.0, 1.0),
pos=(-.98, .9),
scale=0.06)
# display copright information
self.copyRight = OnscreenText(text='Copyright (C) 2016 David Lettier.',
fg=(1.0, 1.0, 1.0, 1.0),
pos=(.98, -.98),
scale=0.05)
# display panda version text
self.pandaVersion = OnscreenText(text='Panda Version 1.9.2',
fg=(1.0, 1.0, 1.0, 1.0),
pos=(-1.18, -.98),
scale=0.04)
# display print debug button
# this button calls the prntDebug function
self.prntDebugButton = DirectButton(text="Print Debug",
relief=DGG.RAISED,
scale=.1,
pad=(.5, .5),
pos=Vec3(-1.0, 0.0, -.8),
command=self.prntDebug)
def setupControls(self):
# accept the esc key to exit application
self.accept('escape', sys.exit)
def prntDebug(self):
# destory debug button
self.prntDebugButton.destroy()
# create new clear debug button
# this button calls the clearDebug function
self.clearDebugButton = DirectButton(text="Clear Debug",
relief=DGG.RAISED,
scale=.1,
pad=(.5, .5),
pos=Vec3(-1.0, 0.0, -.8),
command=self.clearDebug)
# create green target position text
self.greenPos = OnscreenText(
text='Green Target Pos: ' + str(int(self.world.target.getX())) +
", " + str(int(self.world.target.getY())) + ", " +
str(int(self.world.target.getZ())),
fg=(1.0, 1.0, 1.0, 1.0),
pos=(-.8, .8),
scale=0.05,
mayChange=True)
# create blue boid position text
self.bluePos = OnscreenText(
text='Blue Boid (Arrive) Pos: ' +
str(int(self.world.blueBoid.boidModel.getX())) + ", " +
str(int(self.world.blueBoid.boidModel.getY())) + ", " +
str(int(self.world.blueBoid.boidModel.getZ())),
fg=(1.0, 1.0, 1.0, 1.0),
pos=(-.8, .7),
scale=0.05,
mayChange=True)
# create green boid position text
self.redPos = OnscreenText(
text='Red Boid (Seek) Pos: ' +
str(int(self.world.redBoid.boidModel.getX())) + ", " +
str(int(self.world.redBoid.boidModel.getY())) + ", " +
str(int(self.world.redBoid.boidModel.getZ())),
fg=(1.0, 1.0, 1.0, 1.0),
pos=(-.8, .6),
scale=0.05,
mayChange=True)
# add the update on screen text task
taskMgr.add(self.updateOSTxt, 'updateOSTxt')
def updateOSTxt(self, Task):
# update green target position text
self.greenPos.setText('Green Target Pos: ' +
str(int(self.world.target.getX())) + ", " +
str(int(self.world.target.getY())) + ", " +
str(int(self.world.target.getZ())))
# update blue boid position text
self.bluePos.setText('Blue Boid (Arrive) Pos: ' +
str(int(self.world.blueBoid.boidModel.getX())) +
", " +
str(int(self.world.blueBoid.boidModel.getY())) +
", " +
str(int(self.world.blueBoid.boidModel.getZ())))
# update red boid position text
self.redPos.setText('Red Boid (Seek) Pos: ' +
str(int(self.world.redBoid.boidModel.getX())) +
", " +
str(int(self.world.redBoid.boidModel.getY())) +
", " +
str(int(self.world.redBoid.boidModel.getZ())))
# call task next frame
return Task.cont
def clearDebug(self):
# destory button
self.clearDebugButton.destroy()
# destory all debug on screen text
self.greenPos.destroy()
self.bluePos.destroy()
self.redPos.destroy()
# remove task
taskMgr.remove('updateOSTxt')
# create again the print debug button to start the cycle all over again
self.prntDebugButton = DirectButton(text="Print Debug",
relief=DGG.RAISED,
scale=.1,
pad=(.5, .5),
pos=Vec3(-1.0, 0.0, -.8),
command=self.prntDebug)
