def __init__(self, title_text, scale, parent=None, child=None, transparent=False, owner=None):
self.title_text = title_text
self.scale = scale
self.title_size = settings.ui_font_size
self.owner = owner
self.child = None
self.last_pos = None
self.title_color = (1, 1, 1, 1)
self.title_pad = tuple(self.scale * 2)
if parent is None:
parent = aspect2d
self.parent = parent
if transparent:
frameColor = (0, 0, 0, 0)
else:
frameColor = (0.5, 0.5, 0.5, 1)
self.pad = 0
self.event_handler = DirectObject()
self.button_thrower = base.buttonThrowers[0].node()
self.event_handler.accept("wheel_up-up", self.mouse_wheel_event, extraArgs = [-1])
self.event_handler.accept("wheel_down-up", self.mouse_wheel_event, extraArgs = [1])
self.scrollers = []
# if Window.texture is None:
# Window.texture = loader.loadTexture('textures/futureui1.png')
# image_scale = (scale[0] * Window.texture.get_x_size(), 1, scale[1] * Window.texture.get_y_size())
self.frame = DirectFrame(parent=parent, state=DGG.NORMAL, frameColor=frameColor)#, image=self.texture, image_scale=image_scale)
self.title_frame = DirectFrame(parent=self.frame, state=DGG.NORMAL, frameColor=(.5, .5, .5, 1))
self.title = OnscreenText(text=self.title_text,
style=Plain,
fg=self.title_color,
scale=tuple(self.scale * self.title_size),
parent=self.title_frame,
pos=(0, 0),
align=TextNode.ALeft,
font=None,
mayChange=True)
bounds = self.title.getTightBounds()
self.title_frame['frameSize'] = [0, bounds[1][0] - bounds[0][0] + self.title_pad[0] * 2,
0, bounds[1][2] - bounds[0][2] + self.title_pad[1] * 2]
self.title.setPos( -bounds[0][0] + self.title_pad[0], -bounds[0][2] + self.title_pad[1])
self.close_frame = DirectFrame(parent=self.frame, state=DGG.NORMAL, frameColor=(.5, .5, .5, 1))
self.close = OnscreenText(text='X',
style=Plain,
fg=self.title_color,
scale=tuple(self.scale * self.title_size),
parent=self.close_frame,
pos=(0, 0),
align=TextNode.ACenter,
font=None,
mayChange=True)
bounds = self.close.getTightBounds()
self.close_frame['frameSize'] = [0, bounds[1][0] - bounds[0][0] + self.title_pad[0] * 2,
self.title_frame['frameSize'][2], self.title_frame['frameSize'][3]]
self.close.setPos( -bounds[0][0] + self.title_pad[0], -bounds[0][2] + self.title_pad[1])
self.frame.setPos(0, 0, 0)
self.title_frame.bind(DGG.B1PRESS, self.start_drag)
self.title_frame.bind(DGG.B1RELEASE, self.stop_drag)
self.close_frame.bind(DGG.B1PRESS, self.close_window)
self.set_child(child)
def __init__(self, obj, name, frame):
MouseWatcherRegion.__init__(self, '%s-%s' % (name, id(self)), frame)
self.obj = obj
self.__inside = False
if not self.MOUSE_WATCHER_SETUP:
NametagGlobals._mouse_watcher.setEnterPattern('mouse-enter-%r')
NametagGlobals._mouse_watcher.setLeavePattern('mouse-leave-%r')
NametagGlobals._mouse_watcher.setButtonDownPattern(
'button-down-%r')
NametagGlobals._mouse_watcher.setButtonUpPattern('button-up-%r')
self.MOUSE_WATCHER_SETUP = True
self.slaveObject = DirectObject()
self.slaveObject.accept(
self.__getEvent(NametagGlobals._mouse_watcher.getEnterPattern()),
self.__mouseEnter)
self.slaveObject.accept(
self.__getEvent(NametagGlobals._mouse_watcher.getLeavePattern()),
self.__mouseLeave)
self.slaveObject.accept(
self.__getEvent(
NametagGlobals._mouse_watcher.getButtonDownPattern()),
self.__buttonDown)
self.slaveObject.accept(
self.__getEvent(
NametagGlobals._mouse_watcher.getButtonUpPattern()),
self.__buttonUp)
def __init__(self, app):
self.app = app
self.do = DirectObject()
self.running = False
self.displayRegion = None
self.root = NodePath('creditsRender')
self.camera = Camera('creditsCam')
self.cameraNP = NodePath(self.camera)
# Set parameters to match those of render2d
self.root.setDepthTest(0)
self.root.setDepthWrite(0)
self.root.setMaterialOff(1)
self.root.setTwoSided(1)
self.aspect2d = self.root # self.root.attachNewNode('creditsAspect')
lens = OrthographicLens()
lens.setFilmSize(2, 2)
lens.setFilmOffset(0, 0)
lens.setNearFar(-1000, 1000)
self.camera.setLens(lens)
self.cameraNP.reparentTo(self.root)
self.scrollTask = None
self.lastTime = None
self.creditsFileLoaded = False
def initPanda(self):
if hasattr(self, 'panda'):
# Allow multiple entry
return
if self.do is None:
self.do = DirectObject()
# The undecorated config option can't be changed at runtime, so we need
# to set it before the panda object is created.
if self.displaySettings.displayMode == NO_BORDER:
loadPrcFileData('', 'undecorated 1')
# The resolution /can/ be changed at runtime, but there's a split second
# flash of the window at the defualt resolution when first opening the
# game which looks quite ugly.
loadPrcFileData('', 'win-size %d %d' % self.displaySettings.size)
loadPrcFile(data.getPandaPath(data, 'config/config.prc'))
self.panda = ShowBase.ShowBase()
self.pandaScene = None
# See https://www.panda3d.org/manual/index.php/Mouse_Support
self.panda.disableMouse() # Name is misleading
self.displaySettings.applyTimings()
self.initPlaque()
self.displaySettings.onDetailLevelChanged.addListener(self.setShader)
self.setShader()
def Kampf(self, spieler, gegner):
"""Startet einen Kampf zwischen Spieler und Gegner, bis einer der beiden keine Energie mehr hat
Usereingaben sind moeglich wie Item oder Angriff"""
aktion = "angriff"
aktNr = 0
pos = [0, 0]
keyhandler = DirectObject()
keyMap = {"angriff": 0, "item": 0}
spieler = self.werteBerechnen(spieler)
DirectObject.accept(keyhandler, "a", self.setKey, ["angriff", 1])
DirectObject.accept(keyhandler, "i", self.setKey, ["item", 1])
if (keyMap["angriff"] != 0):
aktion = angriff
if (keyMap["item"] != 0):
aktion = item
if spieler.energie <= 0:
print "Spieler tot"
self.active = False
return [spieler, gegner]
elif gegner.energie <= 0:
print "Gegner besiegt"
self.active = False
return [spieler, gegner]
print "Spieler greift an"
self.eventhandleSpieler(aktion, spieler, gegner, aktNr, pos)
aktion = "angriff"
print "Gegner greift an"
self.eventhandleGegner(spieler, gegner)
self.anzeigen(spieler, gegner)
self.active = True
return [spieler, gegner]
def __init__(self, root_nodepath, world):
self.world = BulletWorld()
self.world.setGravity((0, 0, -9.81))
self._timestep = 1 / world.tick_rate
# # Seems that this does not function
# on_contact_added = PythonCallbackObject(self._on_contact_added)
# self.world.set_contact_added_callback(on_contact_added)
# on_filter = PythonCallbackObject(self._filter_collision)
# self.world.set_filter_callback(on_filter)
self.listener = DirectObject()
self.listener.accept('bullet-contact-added', self._on_contact_added)
self.listener.accept('bullet-contact-destroyed', self._on_contact_removed)
self.tracked_contacts = defaultdict(int)
self.existing_collisions = set()
# Debugging info
debug_node = BulletDebugNode('Debug')
debug_node.showWireframe(True)
debug_node.showConstraints(True)
debug_node.showBoundingBoxes(False)
debug_node.showNormals(False)
# Add to world
self.debug_nodepath = root_nodepath.attachNewNode(debug_node)
self.world.set_debug_node(debug_node)
self.debug_nodepath.show()
def finish(self, pos=(0, 0, 0), minWidth=1):
"""
adjust frame for uniform width with siblings
adjust pos relative to parent or older sibs
attach stateGraphics
"""
me = self.getPythonTag("extras")
item = me.item
scale = me.style['font-size']
kind = item['kind']
width, height, lineHeight, fram = getTextSize(item['txt'], me.style)
width = max(width, minWidth)
arrowhead = .5 * lineHeight
padding = me.style['padding']
padding = (padding[0] * scale, padding[1] * scale, padding[2] * scale,
padding[3] * scale)
bevel = me.style['bevel'] * scale
multiLineShim = 0
if '\n' in item['txt']:
multiLineShim = .04 # might need to change this to fit font
NodePath(self).setPos(pos)
if kind == 'separator':
sh = me.style['height'] * scale
frame = (-padding[0], width + padding[1], -sh / 2, sh / 2)
else:
frame = (fram[0], max(fram[1],
fram[0] + minWidth), fram[2], fram[3])
frame = (frame[0] - padding[0], frame[1] + padding[1],
frame[2] - padding[2] - multiLineShim,
frame[3] + padding[3])
stateGraphics = getBackgroundSet(self, frame, arrowhead)
for state in STATES:
self.clearStateDef(state) # in case we've been here befor
self.instanceToStateDef(state, stateGraphics[state])
DO = DirectObject()
if not self.clickAccepted: #JUSTIN'S INSERTED CODE
DO.accept(self.getEnterEvent(), onEnter,
[me.menuRoot.menuRootID, self])
DO.accept(self.getExitEvent(), onLeave,
[me.menuRoot.menuRootID, self])
if kind in ('button', 'checkBox', 'radioBTN', 'checkAllBTN',
'unCheckAllBTN', 'titleBar', 'close'):
if not self.clickAccepted: #JUSTIN'S INSERTED CODE
DO.accept(self.getPressEvent(MouseButton.one()), onPress,
[self])
DO.accept(self.getReleaseEvent(MouseButton.one()),
onRelease, [self])
# so we can simulate 'click' with messenger.send('press'+id, ['simClk']):
DO.accept('press' + item['id'], onPress, [self])
if not self.clickAccepted: #JUSTIN'S INSERTED CODE
self.clickAccepted = True
self.setActive(True)
if kind == 'parent': # accomodate arrowheads
self.setFrame(frame[0], frame[1] + arrowhead * 2 - bevel, frame[2],
frame[3])
else:
self.setFrame(frame)
def _handleWhisperModeSVChanged(self, handleWhisperMode):
if handleWhisperMode:
self._wmcListener = DirectObject()
self._wmcListener.accept(self.getEventName(SCWhisperModeChangeEvent), self._handleWhisperModeChange)
elif hasattr(self, '_wmcListener'):
self._wmcListener.ignoreAll()
del self._wmcListener
self.invalidate()
def initPlayerAbilities(self):
DO = DirectObject()
DO.accept('1', self.fireAbility, [1])
DO.accept('2', self.fireAbility, [2])
DO.accept('3', self.fireAbility, [3])
DO.accept('4', self.fireAbility, [4])
self.abilityDict = {'offensive':1, 'defensive':1, 'evasive':1, 'area':1}
def swordHitEnemy(self, task):
# When the sword collides with enemy, enemy dies
for enemy in self.enemies:
self.playerKill = CollisionHandlerEvent()
base.cTrav.addCollider(enemy.collider, self.playerKill)
self.playerKill.addInPattern('%fn-into-%in')
# perform the task
self.kill = DirectObject()
self.kill.accept('enemy' + str(enemy.numb) + '-into-swordCollider',
enemy.killEnemy)
self.swordHit = DirectObject()
self.swordHit.accept(
'enemy' + str(enemy.numb) + '-into-swordCollider',
self.swordHitSound)
if not enemy.isAlive:
self.enemies.remove(enemy)
return task.cont
def __init__(self,screen_manager,screen_name):
'''
Each GameScreen object takes in a screen manager and the screen's text name
The Screen's text name is useful for titles or inherited screens like the
service menu where you would want the inherited screen to display a unique title
at the top of the screen.
'''
self.screen_manager = screen_manager
self.name = screen_name
"""
In each screen, we have a 2d node and a 3d node. The render tree renders 2d and 3d objects
using separate branches, so all 2d objects must be parented to a 2d node. All 3d objects
must be parented to a 3d node.
Here we set up a 2d node for drawing 2d objects on our screen. We also set up a 3d node
that is responsible for drawing 3d objects. Both are parented to our screen manager
so the screen manager can easily remove these nodes from the tree in order to hide the screen.
"""
self.node2d = self.screen_manager.get2dNode().attachNewNode(PandaNode(screen_name + "2d"))
self.node = self.screen_manager.getNode().attachNewNode(PandaNode(screen_name + "3d"))
self.object = DirectObject()
"""
Each major playfield location can have stacks of objects. Objects that are placed using
place_model() with pos set to a keyword location (left_ramp, left_loop, center_ramp, side_ramp, right_ramp,
or right_loop) then the model is placed on top of the stack for that location.
When models are removed, the stacks move down
"""
self.stack = {}
self.stack['left_ramp'] = []
self.stack['left_loop'] = []
self.stack['center_ramp'] = []
self.stack['side_ramp'] = []
self.stack['right_ramp'] = []
self.stack['right_loop'] = []
self.last_removed_model = {}
self.last_removed_model['left_ramp'] = ""
self.last_removed_model['left_loop'] = ""
self.last_removed_model['center_ramp'] = ""
self.last_removed_model['side_ramp'] = ""
self.last_removed_model['right_ramp'] = ""
self.last_removed_model['right_loop'] = ""
self.lowest_position = {}
self.lowest_position['center_ramp'] = (1.5,120,-11)
self.lowest_position['side_ramp'] = (20, 120, -30)
self.lowest_position['right_ramp'] = (33.5, 120, -11)
self.lowest_position['left_ramp'] = (-13, 120, -23.5)
self.lowest_position['right_loop'] = (0,0,0)
self.lowest_position['left_loop'] = (0,0,0)
def __init__(self, app):
self.app = app
self.d = None
self.dialog = None
self.createAccountVar = None
self.retypeLabel = None
self.retypeBox = None
self.usernameBox = None
self.passwordBox = None
self.focus = None
self.do = DirectObject()
def _handleWhisperModeSVChanged(self, handleWhisperMode):
if handleWhisperMode:
# this terminal can't be whispered. we need to reconstruct
# our GUI element when the whisper mode changes
# listen for that mode change
# create a DirectObject to avoid conflicts with other parts of this
# object that are listening for this event
self._wmcListener = DirectObject()
self._wmcListener.accept(self.getEventName(SCWhisperModeChangeEvent),
self._handleWhisperModeChange)
else:
if hasattr(self, '_wmcListener'):
# we no longer need to listen for whisper mode changes
self._wmcListener.ignoreAll()
del self._wmcListener
# make sure our GUI element is appropriate
self.invalidate()
def __init__(self):
from direct.showbase.DirectObject import DirectObject
self._obj = DirectObject()
for event_name, remapped_name in keyboard_mapping.items():
self._obj.accept(event_name, self.broadcast_event, [("keyboard", "pressed", remapped_name)])
self._obj.accept("{}-up".format(event_name), self.broadcast_event,
[("keyboard", "released", remapped_name)])
for event_name, remapped_name in mouse_mapping.items():
self._obj.accept(event_name, self.broadcast_event, [("mouse", "pressed", remapped_name)])
self._obj.accept("{}-up".format(event_name), self.broadcast_event, [("mouse", "released", remapped_name)])
self._mouse_pos = None
self.event = None
self._hive = hive.get_run_hive()
def __init__(self, app, scene, parent):
self.app = app
self.scene = scene
self.parent = parent
self.keymap = self.app.keymap
self.do = DirectObject()
self.saveButton = None
self.finishButton = None
self.pendingChanges = False
# The KeyboadMapping provides a dict of keys to actions: this member
# does the opposite (provides a dict to actions to keys)
self.keys = {}
self.selectedAction = None
self.inputLookup = {}
self.layout = []
def __init__(self, **kwargs):
super(EventLogger, self).__init__(**kwargs)
self.listener = DirectObject()
# registering some events by hand
self.listener.accept('crossHair',self.logEvent)
uniqueFileName = self.config.logfile +"_"+ self.config.world.participantId + ".log"
self.eventLog = Logger(self.baseTime, uniqueFileName, 'w')
#self.eventLog.startLog()
self.eventLog.logEvent('Event logger started\n')
taskMgr.add( self.updateHooks, 'updateHooks' )
self.registeredEvents = messenger.getEvents()
for e in self.registeredEvents:
self.listener.accept(e, self.logEvent, [e])
self.hideElement()
def setupMouseCollision(self):
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0))
DO = DirectObject()
DO.accept('mouse1', self.onMouseDown)
DO.accept('mouse1-up', self.onMouseUp)
self.collisionHandler = CollisionHandlerQueue()
self.pickerCollNode = CollisionNode('mouseRay')
self.pickerNodePath = camera.attachNewNode(self.pickerCollNode)
self.pickerCollNode.setIntoCollideMask(BitMask32.allOff())
self.pickerCollNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerCollNode.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerNodePath, self.collisionHandler)
taskMgr.add(self.moveTask, 'moveTask')
taskMgr.add(self.attackTask, 'attackTask')
def __init__(self, game):
'''
Set up a 2d node and a 3d node for drawing 2d and 3d objects.
All objects must be parented to their respective nodes in order to be rendered
'''
self.game = game
self._flipNode = render.attachNewNode("flip_node")
self._flipNode2d = aspect2d.attachNewNode("flip_node2d")
if base.displayFlipped:
self._flipNode.setScale(-1, 1, 1)
self._flipNode2d.setScale(-1, 1, 1)
self._node = self._flipNode.attachNewNode(PandaNode("screen_manager"))
self._2dnode = self._flipNode2d.attachNewNode(
PandaNode("2dscreen_manager"))
self.logger = logging.getLogger("ScreenManager")
self.logger.info("Initializing Screen Manager")
# Create a dictionary to hold our screens
self.screens = {}
self.modal_screens = {}
# This shows the frame rate meter at the top right of the screen for diagnostic purposes
base.setFrameRateMeter(False)
self.modaltext = None
self.modal_text_color = ""
self.modal_text_blink_status = False
self.obj = DirectObject()
self.debug_text = OnscreenText("",
1,
font=base.fontLoader.load('arial.ttf'),
fg=(1, 1, 1, 1),
pos=(1.2, -0.9),
align=TextNode.ARight,
scale=.05,
mayChange=True,
parent=self._2dnode)
self.debug_text.hide()
def __init__(self, mainRef):
print("Player instantiated")
Unit.__init__(self)
FSM.__init__(self, 'playerFSM')
self._hudRef = None
self._mainRef = mainRef
self._enemyListRef = mainRef.enemyList
self._ddaHandlerRef = mainRef.DDAHandler
self._mapHandlerRef = mainRef.mapHandler
self._stateHandlerRef = mainRef.stateHandler
self._scenarioHandlerRef = mainRef.scenarioHandler
self.playerNode = mainRef.mainNode.attachNewNode('playerNode')
self.initPlayerAttributes()
self.initPlayerModel()
self.initPlayerCamera()
self.initPlayerAbilities()
self.initPlayerCollisionHandlers()
self.initPlayerCollisionSolids()
self.initPlayerDDA()
# Start mouse picking and movement
self.mouseHandler = utils.MouseHandler(self)
# Start player update task
playerUpdateTask = taskMgr.add(self.playerUpdate, 'playerUpdateTask')
# Initialize player FSM state
self.request('Idle')
DO = DirectObject()
DO.accept('shift-mouse1', self.onShiftDown)
DO.accept('shift-up', self.onShiftUp)
self._shiftButtonDown = False
def input_init(self):
self.DO = DirectObject()
self.DO.accept('mouse1', self.mouse_click, ["1-down"])
self.DO.accept('mouse1-up', self.mouse_click, ["1-up"])
self.DO.accept('mouse3', self.mouse_click, ["3-down"])
self.DO.accept('0', self.placement_ghost.change_player, [0])
self.DO.accept('1', self.placement_ghost.change_player, [1])
self.DO.accept('2', self.placement_ghost.change_player, [2])
self.DO.accept('a', self.placement_ghost.change_type, ["army"])
self.DO.accept('t', self.placement_ghost.change_type, ["tower"])
self.DO.accept('control-s', base.xml_manager.save)
self.DO.accept('mray-into-army', self.col_in_object)
self.DO.accept('mray-out-army', self.col_out_object)
self.DO.accept('mray-into-tower', self.col_in_object)
self.DO.accept('mray-out-tower', self.col_out_object)
self.DO.accept('ray_again_all', self.col_against_object)
def setupDebugHelp(APP):
def toggleOobe():
"""Switch between free camera (steering with the mouse) and
the camera controled by the game"""
APP.oobe()
def explorer():
"""activates the Panda3D halp tool to explore the
render Nodepath"""
APP.render.explore()
def analyze():
APP.render.analyze()
def toggleWireframe():
"""Switch between wired model view and normal view"""
base.toggleWireframe()
from time import strftime
def takeScreenshot():
# make a screenshot
path = os.path.join(Settings.settingsPath, "screenshots")
if not os.path.exists(path):
os.makedirs(path)
# create the filename with a name and the actual time
fn = "Screenshot" + strftime("_%a_%d-%m-%Y_%H:%M:%S") + ".png"
path = os.path.join(path, fn)
APP.win.saveScreenshot(Filename.fromOsSpecific(path))
logging.info(str.format("take Screenshot in: {0}", path))
# create a DirectObject object to handle the key input by the user
directobject = DirectObject()
directobject.accept("f2", analyze)
directobject.accept("f3", explorer)
directobject.accept("f4", toggleWireframe)
directobject.accept("f5", takeScreenshot)
directobject.accept("f12", toggleOobe)
def __init__(self, parent=None, **kw):
# Inherits from DirectFrame
# A Direct Frame can have:
# - A background texture (pass in path to image, or Texture Card)
# - A midground geometry item (pass in geometry)
# - A foreground text Node (pass in text string or Onscreen Text)
# For a direct entry:
# Each button has 3 states (focus, noFocus, disabled)
# The same image/geom/text can be used for all three states or each
# state can have a different text/geom/image
# State transitions happen automatically based upon mouse interaction
optiondefs = (
# Define type of DirectGuiWidget
('pgFunc', PGEntry, None),
('numStates', 3, None),
('state', DGG.NORMAL, None),
('entryFont', None, DGG.INITOPT),
('width', 10, self.setup),
('numLines', 1, self.setup),
('focus', 0, self.setFocus),
('cursorKeys', 1, self.setCursorKeysActive),
('obscured', 0, self.setObscureMode),
# Setting backgroundFocus allows the entry box to get keyboard
# events that are not handled by other things (i.e. events that
# fall through to the background):
('backgroundFocus', 0, self.setBackgroundFocus),
# Text used for the PGEntry text node
# NOTE: This overrides the DirectFrame text option
('initialText', '', DGG.INITOPT),
# Command to be called on hitting Enter
('command', None, None),
('extraArgs', [], None),
# Command to be called when enter is hit but we fail to submit
('failedCommand', None, None),
('failedExtraArgs', [], None),
# commands to be called when focus is gained or lost
('focusInCommand', None, None),
('focusInExtraArgs', [], None),
('focusOutCommand', None, None),
('focusOutExtraArgs', [], None),
# Sounds to be used for button events
('rolloverSound', DGG.getDefaultRolloverSound(),
self.setRolloverSound),
('clickSound', DGG.getDefaultClickSound(), self.setClickSound),
('autoCapitalize', 0, self.autoCapitalizeFunc),
('autoCapitalizeAllowPrefixes', DirectEntry.AllowCapNamePrefixes,
None),
('autoCapitalizeForcePrefixes', DirectEntry.ForceCapNamePrefixes,
None),
)
# Merge keyword options with default options
self.defineoptions(kw, optiondefs)
# Initialize superclasses
DirectFrame.__init__(self, parent)
if self['entryFont'] == None:
font = DGG.getDefaultFont()
else:
font = self['entryFont']
# Create Text Node Component
self.onscreenText = self.createcomponent(
'text',
(),
None,
OnscreenText,
(),
parent=hidden,
# Pass in empty text to avoid extra work, since its really
# The PGEntry which will use the TextNode to generate geometry
text='',
align=TextNode.ALeft,
font=font,
scale=1,
# Don't get rid of the text node
mayChange=1)
# We can get rid of the node path since we're just using the
# onscreenText as an easy way to access a text node as a
# component
self.onscreenText.removeNode()
# Bind command function
self.bind(DGG.ACCEPT, self.commandFunc)
self.bind(DGG.ACCEPTFAILED, self.failedCommandFunc)
self.accept(self.guiItem.getFocusInEvent(), self.focusInCommandFunc)
self.accept(self.guiItem.getFocusOutEvent(), self.focusOutCommandFunc)
# listen for auto-capitalize events on a separate object to prevent
# clashing with other parts of the system
self._autoCapListener = DirectObject()
# Call option initialization functions
self.initialiseoptions(DirectEntry)
if not hasattr(self, 'autoCapitalizeAllowPrefixes'):
self.autoCapitalizeAllowPrefixes = DirectEntry.AllowCapNamePrefixes
if not hasattr(self, 'autoCapitalizeForcePrefixes'):
self.autoCapitalizeForcePrefixes = DirectEntry.ForceCapNamePrefixes
# Update TextNodes for each state
for i in range(self['numStates']):
self.guiItem.setTextDef(i, self.onscreenText.textNode)
# Now we should call setup() again to make sure it has the
# right font def.
self.setup()
# Update initial text
self.unicodeText = 0
if self['initialText']:
self.enterText(self['initialText'])
separatorHeight=.3,
underscoreThickness=1,
BGColor=(.9,.9,.8,.94),
BGBorderColor=(.8,.3,0,1),
separatorColor=(0,0,0,1),
frameColorHover=(.3,.3,.3,1),
frameColorPress=(0,1,0,.85),
textColorReady=(0,0,0,1),
textColorHover=(1,.7,.2,1),
textColorPress=(0,0,0,1),
textColorDisabled=(.65,.65,.65,1),
draggable=True,
onMove=menuBarMoved
)
OnscreenText( parent=base.a2dBottomCenter,
text='Right click to pop up a context menu', fg=(1,1,1,1),
pos=(0,.02), scale=.045)
DO=DirectObject()
DO.accept('mouse3',createContextMenu)
DO.accept('control-s',func3)
DO.accept('control-g',func4)
DO.accept('escape',exit)
DO.accept('window-event',resetModButtons)
camera.setY(-5)
base.disableMouse()
run()
def __init__(self,base,Golog, folder_path = None, parent = None):
# Set up basic attributes
self.base = base
self.golog = Golog
self.bools = {'textboxes':True}
self.buttons = dict()
self.window_tasks = dict()
self.bt = None
self.mw = None
self.listener = DirectObject()
self.folder_path = folder_path #absolute path of golog folder '/path/to/golog/folder'
if self.folder_path:
self.file_path = os.path.abspath(self.folder_path + '/' + self.golog.label+ '.golog')
autosave = True
self.has_window = False
self.parent = parent #for autosaving up to original golog
self.reset = self.basic_reset
self.garbage = [] #list of deleted math_data/graphics_data etc.
#create a 2d rende
self.render2d = NodePath('2d render')
self.camera2D = self.render2d.attachNewNode(Camera('2d Camera'))
self.camera2D.setDepthTest(False)
self.camera2D.setDepthWrite(False)
lens = OrthographicLens()
lens.setFilmSize(2, 2)
lens.setNearFar(-1000, 1000)
self.camera2D.node().setLens(lens)
# make a dictionary of mode_heads in the underlying golog
if hasattr(self.golog,'mode_heads'):
m = 0
while m in self.golog.mode_heads.keys(): m+=1 #get smallest unused mode_head index
self.index = m
self.label = self.golog.label+"_mode_head_"+str(self.index)
self.golog.mode_heads[self.index] = self
else:
self.golog.mode_heads = dict()
self.index = 0
self.label = self.golog.label+"_mode_head_"+ str(self.index)
self.golog.mode_heads[self.index] = self
##########
### set up collision handling ###
self.queue = CollisionHandlerQueue()
### set up selection tools
self.create_list = [[],[]] #select nodes and add to create_list in order to create higher simplecies
self.bools = {'selecter':False,'textboxes':True,'shift_clicked':False} #some bools that will be usefull
self.dict = {'shift_pt':[None,None]}
# set up mouse picker
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = self.golog.camera.attachNewNode(self.pickerNode) #attach collision node to camera
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.pickerNode.set_into_collide_mask(0) #so that collision rays don't collide into each other if there are two mode_heads
self.golog.cTrav.addCollider(self.pickerNP,self.queue) #send collisions to self.queue
# set up plane for picking
self.planeNode = self.golog.render.attachNewNode("plane")
self.planeNode.setTag("mode_head",self.label) # tag to say it belongs to this mode_head
self.planeNode.setTag("mode_node", 'plane')
self.planeFromObject = self.planeNode.attachNewNode(CollisionNode("planeColNode"))
self.planeFromObject.node().addSolid(CollisionPlane(Plane(Vec3(0,-1,0),Point3(0,0,0))))
self.plane = self.planeFromObject.node().getSolid(0)
###
# set up preview text
self.textNP = self.render2d.attachNewNode(TextNode('text node'))
self.textNP.setScale(.2)
self.textNP.setPos(-1,0,0)
self.textNP.show()
#set up dragging info
self.grabbed_dict = dict()
self.drag_dict = dict() #a mapping from selected nodes to their original positions for dragging
self.mouse_down_loc = (0,0,0)
self.lowest_level = 3
def __init__(self, parent=None, **kw):
optiondefs = (
(
'pgFunc', PGEntry, None),
('numStates', 3, None),
(
'state', DGG.NORMAL, None),
(
'entryFont', None, DGG.INITOPT),
(
'width', 10, self.setup),
(
'numLines', 1, self.setup),
(
'focus', 0, self.setFocus),
(
'cursorKeys', 1, self.setCursorKeysActive),
(
'obscured', 0, self.setObscureMode),
(
'backgroundFocus', 0, self.setBackgroundFocus),
(
'initialText', '', DGG.INITOPT),
('command', None, None),
(
'extraArgs', [], None),
('failedCommand', None, None),
(
'failedExtraArgs', [], None),
('focusInCommand', None, None),
(
'focusInExtraArgs', [], None),
('focusOutCommand', None, None),
(
'focusOutExtraArgs', [], None),
(
'rolloverSound', DGG.getDefaultRolloverSound(), self.setRolloverSound),
(
'clickSound', DGG.getDefaultClickSound(), self.setClickSound),
(
'autoCapitalize', 0, self.autoCapitalizeFunc),
(
'autoCapitalizeAllowPrefixes', DirectEntry.AllowCapNamePrefixes, None),
(
'autoCapitalizeForcePrefixes', DirectEntry.ForceCapNamePrefixes, None))
self.defineoptions(kw, optiondefs)
DirectFrame.__init__(self, parent)
if self['entryFont'] == None:
font = DGG.getDefaultFont()
else:
font = self['entryFont']
self.onscreenText = self.createcomponent('text', (), None, OnscreenText, (), parent=hidden, text='', align=TextNode.ALeft, font=font, scale=1, mayChange=1)
self.onscreenText.removeNode()
self.bind(DGG.ACCEPT, self.commandFunc)
self.bind(DGG.ACCEPTFAILED, self.failedCommandFunc)
self.accept(self.guiItem.getFocusInEvent(), self.focusInCommandFunc)
self.accept(self.guiItem.getFocusOutEvent(), self.focusOutCommandFunc)
self._autoCapListener = DirectObject()
self.initialiseoptions(DirectEntry)
if not hasattr(self, 'autoCapitalizeAllowPrefixes'):
self.autoCapitalizeAllowPrefixes = DirectEntry.AllowCapNamePrefixes
if not hasattr(self, 'autoCapitalizeForcePrefixes'):
self.autoCapitalizeForcePrefixes = DirectEntry.ForceCapNamePrefixes
for i in range(self['numStates']):
self.guiItem.setTextDef(i, self.onscreenText.textNode)
self.setup()
self.unicodeText = 0
if self['initialText']:
self.enterText(self['initialText'])
return
# THE CREDITS TEXT
ost = OnscreenText(parent=textParent, font=loader.loadFont('cmss12'),
text='CREDITS\n\n'+'\n'.join([c*30 for c in string.ascii_letters]),
fg=(1,1,1,1),scale=.065)
ost.setP(-90)
ost.flattenLight()
ts=TextureStage('')
textParent.setTexGen(ts,TexGenAttrib.MWorldPosition)
textParent.setTexScale(ts,.5,.5)
textParent.setTexOffset(ts,.5,.5)
textParent.setTexture(ts,tex)
b3=textParent.getTightBounds()
dims=b3[1]-b3[0]
textParent.posInterval(50,Point3(0,dims[1]+2,0),Point3(0,-1.05,0)).start()
VPcam = Camera('vpcam')
VPcam.copyLens(base.cam2d.node().getLens())
VPcamNP = dummyParent.attachNewNode(VPcam)
VPcamNP.setP(-90)
dr=base.win.makeDisplayRegion()
dr.setCamera(VPcamNP)
dr.setSort(1000)
do=DirectObject()
do.accept('space',cycleAlpha)
do.accept('escape',sys.exit)
globalClock.setMode(ClockObject.MNormal)
run()
def __init__(self, app):
self.do = DirectObject()
super(KeyboardMapping, self).__init__(app)
def _leak(self, task):
self._leakers.append(DirectObject())
self._leakers[-1].accept('leak-msg', self._leak)
return task.cont
def _leak(self, task):
self._leakers.append(DirectObject())
self._leakers[-1].accept(uniqueName('leak-msg-listeners'), self._leak)
return task.cont
def __init__(self):
# Our standard title and instructions text
# probably not neccessary for main project
self.title = OnscreenText(
text=
"Sounds Test, Hold 'X' to start engine, Up Arrow to accelerate\n"
"Space bar for horn",
parent=base.a2dBottomCenter,
pos=(0, 0.08),
scale=0.08,
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, .5))
self.escapeText = OnscreenText(text="ESC: Quit",
parent=base.a2dTopLeft,
fg=(1, 1, 1, 1),
pos=(0.06, -0.1),
align=TextNode.ALeft,
scale=.05)
# Set up the key input
self.accept('escape', sys.exit)
# variables
self.start = 0
self.volume = 0
# Functions tocall sounds
# engine start idle sound
def startcar():
self.start = 1
self.start_sound.play()
self.start_sound.setTime(0.5)
self.engine_idle_sound.setVolume(0.60)
self.engine_idle_sound.play()
# engine stops idle sound
def stopcar():
self.start = 0
self.engine_idle_sound.stop()
# honk horn
def horn():
self.horn_sound.play()
#Controls
inputState.watchWithModifiers("F", "arrow_up")
do = DirectObject()
do.accept("x-repeat", startcar) # hold x to call function start car
do.accept("x", stopcar) # if x is pressed after car has started
do.accept("space", horn) # space bar for horn
# background music
self.musicBoxSound = loader.loadMusic('Sounds/bensound-dance.ogg')
self.musicBoxSound.setVolume(0.60) # set volume/ Set from 0 - 1
self.musicBoxSound.setLoop(True) # Set background music to loop
self.musicBoxSound.play()
# Sounds
self.horn_sound = loader.loadSfx("Sounds/car+horn+x.wav")
self.start_sound = loader.loadSfx("Sounds/StartCar.wav")
self.engine_idle_sound = loader.loadSfx("Sounds/engineidle.ogg")
self.engine_idle_sound.setLoop(True)
self.accelerate_sound = loader.loadSfx("Sounds/enginethrottle.ogg")
# accepts input to initiate sounds
def inputTests(dt):
if inputState.isSet("F"):
self.accelerate_sound.play()
# Update the program
def update(task):
dt = globalClock.getDt()
inputTests(dt)
return task.cont
taskMgr.add(update, "Update")
