class Renderer(ShowBase):
def __init__(self):
super(Renderer, self).__init__()
self.props = WindowProperties()
self.props.setTitle( 'Simulation Viewer' )
self.GUI = MainGUI()
base.win.requestProperties(self.props)
def updateCoordinates(self, x, y):
self.GUI.coords.setText('coords: x= {0} y= {1}'.format(x, y))
def updateTime(self, date):
self.GUI.time.setText('time: {0[0]}, {0[1]}, {0[2]}, {0[3]}'.format(date))
def updateMapView(self, source):
shape = (2, self.GUI.mapView.xRange, self.GUI.mapView.yRange)
for x in range(shape[1]):
xM = x + self.GUI.mapView.origin[0]
for y in range(shape[2]):
yM = y + self.GUI.mapView.origin[1]
if source[0][1][xM, yM] != 0 or source[0][1][xM, yM] != 0.:
self.GUI.mapView.panels[x][y].setText(str(source[0][1][xM, yM])[:4])
else:
self.GUI.mapView.panels[x][y].setText(' ')
if source[0][1][xM, yM] >= source[1]:
self.GUI.mapView.panels[x][y].setCardColor(0.22/2, 0.24/2, 0.32/2, 1)
else:
if source[2] is not None:
self.GUI.mapView.panels[x][y].setCardColor(source[2][1, xM, yM])
else:
self.GUI.mapView.panels[x][y].setCardColor(self.GUI.mapView.colorSpace[x, y])
def __init__(self):
""" Initialisiert die Kamera, die Runtime und den Eventhandler. Ladet die Planeten und startet das Programm
"""
props = WindowProperties()
props.setTitle('Solarsystem')
base.win.requestProperties(props)
base.setBackgroundColor(0, 0, 0)
# The global variables we used to control the speed and size of objects
self.yearscale = 60
self.dayscale = self.yearscale / 365.0 * 5
self.orbitscale = 10
self.sizescale = 0.6
self.skySize = 80
self.runtime = RuntimeHandler()
self.camera = Camera(render, self.skySize)
self.loadLuminaries()
self.runtime.rotateLuminaries()
self.eventHandler = EventHandler(self.runtime, self.camera,
self.runtime.getLuminary('sun'))
def __init__(self):
""" Initialisiert die Kamera, die Runtime und den Eventhandler. Ladet die Planeten und startet das Programm
"""
props = WindowProperties()
props.setTitle('Solarsystem')
base.win.requestProperties(props)
base.setBackgroundColor(0, 0, 0)
# The global variables we used to control the speed and size of objects
self.yearscale = 60
self.dayscale = self.yearscale / 365.0 * 5
self.orbitscale = 10
self.sizescale = 0.6
self.skySize = 80
self.runtime = RuntimeHandler()
self.camera = Camera(render, self.skySize)
self.loadLuminaries()
self.runtime.rotateLuminaries()
self.eventHandler = EventHandler(self.runtime, self.camera, self.runtime.getLuminary('sun'))
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
props = WindowProperties()
props.setTitle('Test')
self.win.requestProperties(props)
# self.render.setAntiAlias(AntialiasAttrib.MAuto)
self.transitions = Transitions(self.loader)
self.transitions.setFadeColor(0, 0, 0)
self.filters = CommonFilters(self.win, self.cam)
# self.filters.setCartoonInk()
self.filters.setBlurSharpen(1)
# self.filters.setVolumetricLighting(self.render)
# self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize())
# print self.buffer.getYSize()
# self.texture = self.buffer.getTexture()
# self.buffer.setSort(-100)
#
# self.originalCamera = self.camera
# self.offScreenCamera = self.makeCamera(self.buffer)
# self.camera = self.offScreenCamera
#
# self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5))
self.scene = None
self.channel = Channel()
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
props = WindowProperties()
props.setTitle('Test')
self.win.requestProperties(props)
# self.render.setAntiAlias(AntialiasAttrib.MAuto)
self.transitions = Transitions(self.loader)
self.transitions.setFadeColor(0, 0, 0)
self.filters = CommonFilters(self.win, self.cam)
# self.filters.setCartoonInk()
self.filters.setBlurSharpen(1)
# self.filters.setVolumetricLighting(self.render)
# self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize())
# print self.buffer.getYSize()
# self.texture = self.buffer.getTexture()
# self.buffer.setSort(-100)
#
# self.originalCamera = self.camera
# self.offScreenCamera = self.makeCamera(self.buffer)
# self.camera = self.offScreenCamera
#
# self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5))
self.scene = None
self.channel = Channel()
def __init__(self):
ShowBase.__init__(self)
self.decisions = []
self.isReady = False
self.red = 0
self.messageNode = TextNode("Message")
self.choiceOneNode = TextNode("ChoiceOne")
self.choiceTwoNode = TextNode("ChoiceTwo")
self.instructionsNode = TextNode("Instructions")
self.messageNode.setText('"Antigone, stop screaming!"')
self.choiceOneNode.setText("[stop]")
self.choiceTwoNode.setText("[scream louder]")
self.instructionsNode.setText("Use the arrow keys to make a choice.")
base.setBackgroundColor(self.red, 0, 0)
base.disableMouse()
props = WindowProperties()
props.setTitle("Antigo Me")
base.win.requestProperties(props)
self.textDisplay()
self.showText()
self.isReady = True
self.accept("arrow_left", self.decision, [0])
self.accept("arrow_right", self.decision, [1])
def set_defaults(self):
"""Sets some environment defaults that might be overridden by the modules."""
font = loader.loadFont('arial.ttf',textureMargin=5)
font.setPixelsPerUnit(128)
base.win.setClearColorActive(True)
base.win.setClearColor((0.3, 0.3, 0.3, 1))
winprops = WindowProperties()
winprops.setTitle('SNAP')
base.win.requestProperties(winprops)
def set_defaults(self):
"""Sets some environment defaults that might be overridden by the modules."""
font = loader.loadFont('arial.ttf', textureMargin=5)
font.setPixelsPerUnit(128)
base.win.setClearColorActive(True)
base.win.setClearColor((0.3, 0.3, 0.3, 1))
winprops = WindowProperties()
winprops.setTitle('SNAP')
base.win.requestProperties(winprops)
def initWindow(self):
props = WindowProperties()
props.setTitle('Open Space Drive')
base.win.requestProperties(props)
base.pipe.getDisplayWidth()
props = WindowProperties()
props.setSize(base.pipe.getDisplayWidth(),
base.pipe.getDisplayHeight())
base.win.requestProperties(props)
base.setFrameRateMeter(True)
def __init__(self):
ShowBase.__init__(self) # initializes Panda window from ShowBase
# change window name from "panda" to app name
properties = WindowProperties()
properties.setTitle("Shinsai-Simulator")
base.win.requestProperties(properties)
# adds algorithm to render closer objects first
binManager = CullBinManager.getGlobalPtr()
binManager.addBin("ftb", CullBinManager.BTFrontToBack, 1)
# base.setFrameRateMeter(True)
self.tName = None # name of terrain
self.magnitude = None # magnitude of earthquake
self.titleScreen()
def __init__(self):
print("began")
self.taskMgr = taskMgr
with open('config.json') as data_file:
self.conf = json.load(data_file)
self.ServerConnection = ServerConnection()#uncomment when going live
self.ServerConnection.connect(self.conf['host'],self.conf['port'])#uncomment when going live
props = WindowProperties( )
props.setTitle( 'Log In' )
props.setFixedSize(True)
props.setSize(1280,740)
props.setOrigin(-2,-2)
base.win.requestProperties( props )
self.base = ShowBase
self.main_theme = base.loader.loadSfx("assets/sounds/terminator_theme.ogg")
self.main_theme.play()
self.username = ""
self.authConnection = AuthConnectionModel(self)#uncomment when going live
self.heartbeatConnection = HeartbeatConnectionModel()#uncomment when going live
self.ServerConnection.setupConnectionModel(self.heartbeatConnection)#uncomment when going live
self.globalChatConnection = ChatConnectionModel(self)
self.ServerConnection.setupConnectionModel(self.globalChatConnection)
self.queueConnection = QueueConnectionModel(self)
self.ServerConnection.setupConnectionModel(self.authConnection)#uncomment when going live
self.friendConnection = FriendConnectionModel(self)
self.ServerConnection.setupConnectionModel(self.friendConnection)
self.taskMgr.doMethodLater(self.conf['heartbeatRate'], self.doHeartbeat, "heartbeat")#uncomment when going live
self.taskMgr.doMethodLater(self.conf['heartbeatRate'], self.doHeartbeat, "heartbeat")
self.screen = Login(self)#uncomment when going live
#self.screen = Menu(self)#comment this one when you are trying to log into it like normal
self.ServerConnection.setupConnectionModel(self.queueConnection)
self.taskMgr.doMethodLater(self.conf['heartbeatRate'], self.doHeartbeat, "heartbeat")
self.taskMgr.doMethodLater(1, self.doSong, "song")
self.screenType = "login"
self.screen.run()
def __init__(self, scene_file, pedestrian_file, dir, mode):
ShowBase.__init__(self)
self.globalClock = ClockObject.getGlobalClock()
self.globalClock.setMode(ClockObject.MSlave)
self.directory = dir
self.model = Model(dir)
self.loadScene(scene_file)
self.loadPedestrians(pedestrian_file)
self.cam_label = OST("Top Down",
pos=(0, 0.95),
fg=(1, 1, 1, 1),
scale=0.05,
mayChange=True)
self.time_label = OST("Time: 0.0",
pos=(-1.3, 0.95),
fg=(1, 1, 1, 1),
scale=0.06,
mayChange=True,
align=TextNode.ALeft)
self.accept("arrow_right", self.changeCamera, [1])
self.accept("arrow_left", self.changeCamera, [-1])
self.accept("escape", self.exit)
self.accept("aspectRatioChanged", self.setAspectRatio)
self.accept("window-event", self.windowChanged)
#base.disableMouse()
lens = OrthographicLens()
lens.setFilmSize(1550, 1000)
self.display_region = base.win.makeDisplayRegion()
self.default_camera = render.attachNewNode(Camera("top down"))
self.default_camera.node().setLens(lens)
self.default_camera.setPosHpr(Vec3(-75, 0, 2200), Vec3(0, -90, 0))
self.setCamera(0)
self.controller = Controller(self, mode)
self.taskMgr.add(self.updateCameraModules, "Update Camera Modules", 80)
self.globalClock.setFrameTime(0.0)
self.width = WIDTH
self.height = HEIGHT
props = WindowProperties()
props.setTitle('Virtual Vision Simulator')
base.win.requestProperties(props)
def __init__(self, World):
#just comment out the two lines below
#self.appRunner = None#added this to overide the login
self.playerList = []
self.World = World
self.WhichScreen = "";
self.lastSelectedFriend = None
# variable to save game selected DD or RR
self.selectedGame = None
#self.taskMgr = World.taskMgr#added this to overide the login
props = WindowProperties()
props.setTitle( 'Main Menu' )
props.setFixedSize(True)
props.setSize(1400,740)
props.setOrigin(-2,-2)
base.win.requestProperties( props )
self.selectedCar = 0
self.screenBtns = []
self.globalChat = []
self.privateChat = {}
self.chatOffset = 0
self.car = None
self.onReturnMatch = self.createMatchMaking
self.createSocialization()
self.World.queueConnection.setHandler(self.handleQueueNotification)
self.World.globalChatConnection.setHandler(self.handleChatNotification)
self.World.friendConnection.setHandlers(self.handleFriendNotification,self.handleFriendListNotification)
#self.World.privateChatConnection.setHandler(self.handlePrivateChatNotification)
self.navi()
self.accept('enter', self.sendMessage)
def __init__(self, scene_file, pedestrian_file, dir, mode):
ShowBase.__init__(self)
self.globalClock = ClockObject.getGlobalClock()
self.globalClock.setMode(ClockObject.MSlave)
self.directory = dir
self.model = Model(dir)
self.loadScene(scene_file)
self.loadPedestrians(pedestrian_file)
self.cam_label = OST("Top Down", pos=(0, 0.95), fg=(1,1,1,1),
scale=0.05, mayChange=True)
self.time_label = OST("Time: 0.0", pos=(-1.3, 0.95), fg=(1,1,1,1),
scale=0.06, mayChange=True, align=TextNode.ALeft)
self.accept("arrow_right", self.changeCamera, [1])
self.accept("arrow_left", self.changeCamera, [-1])
self.accept("escape", self.exit)
self.accept("aspectRatioChanged", self.setAspectRatio)
self.accept("window-event", self.windowChanged)
#base.disableMouse()
lens = OrthographicLens()
lens.setFilmSize(1550, 1000)
self.display_region = base.win.makeDisplayRegion()
self.default_camera = render.attachNewNode(Camera("top down"))
self.default_camera.node().setLens(lens)
self.default_camera.setPosHpr(Vec3( -75, 0, 2200), Vec3(0, -90, 0))
self.setCamera(0)
self.controller = Controller(self, mode)
self.taskMgr.add(self.updateCameraModules, "Update Camera Modules", 80)
self.globalClock.setFrameTime(0.0)
self.width = WIDTH
self.height = HEIGHT
props = WindowProperties( )
props.setTitle( 'Virtual Vision Simulator' )
base.win.requestProperties( props )
def configWorld(self):
"""Set general settings.
Probably run only once."""
# Set window title
props = WindowProperties()
props.setTitle("Equilibra7d")
self.win.requestProperties(props)
# Enable per-pixel lighting
self.render.setShaderAuto()
# Enable FPS meter
self.setFrameRateMeter(True)
# Fix frame rate
FPS = 60
globalClock = ClockObject.getGlobalClock()
globalClock.setMode(ClockObject.MLimited)
globalClock.setFrameRate(FPS)
def __init__(self, sound=1, server='', galaxy='', empire='', password='', shipBattle=None, glow=1):
self.shutdownFlag = Event()
props = WindowProperties()
props.setTitle('%s (Game = %s)' % (windowtitle, galaxy))
base.win.requestProperties(props)
Application.__init__(self, server=server, galaxy=galaxy, empire=empire, password=password, shipBattle=shipBattle, glow=glow)
self.pandapath = Filename.fromOsSpecific(self.path).getFullpath()
self.imagePath = self.pandapath + '/images/'
self.soundPath = self.pandapath + '/sounds/'
self.modelPath = self.pandapath + '/models/'
self.sound = sound
self.finalcard = None
self.glowCamera = None
self.glowOn = True
if glow:
self.setupGlowFilter()
self.gameLoopInterval = Func(self.gameLoop)
self.gameLoopInterval.loop()
self.createSounds()
self.playMusic()
def configWorld(self):
"""Set general settings.
Probably run only once."""
# Set window title
props = WindowProperties()
props.setTitle("Equilibra7d")
self.win.requestProperties(props)
# Enable per-pixel lighting
self.render.setShaderAuto()
# Enable FPS meter
self.setFrameRateMeter(True)
# Fix frame rate
FPS = 60
globalClock = ClockObject.getGlobalClock()
globalClock.setMode(ClockObject.MLimited)
globalClock.setFrameRate(FPS)
def __init__(self, media_file):
# Tell Panda3D to use OpenAL, not FMOD
loadPrcFileData("", AUDIO_LIBRARY)
self.media_file = media_file
self.get_video()
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
props = WindowProperties()
props.setTitle(MEDIA_TITLE + media_file)
props.setIconFilename(MEDIA_ICON)
self.win.requestProperties(props)
self.display_text()
self.tex = None
self.load_texture()
self.set_fullscreen()
self.sound = None
self.synchronize_sound()
self.set_keys_acceptions()
self.sound.play()
def __init__(self):
ShowBase.__init__(self)
self.title = "Monkeys"
self.setFrameRateMeter(True)
# Disable the camera trackball controls.
self.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
props.setTitle("Stay Away From The Monkeys")
props.setMouseMode(WindowProperties.M_relative)
self.win.requestProperties(props)
# set scene
self.scene = self.loader.loadModel("models/skyTest.egg")
self.scene.reparentTo(self.render)
m = 37
self.scene.setScale(m, m, m)
self.scene.setPos(0, 0, -5)
# set camera
self.camera.setPos(0, 0, 1)
self.camera.setHpr(0, 0, 0)
self.cameraSpeed = (0, 0, 0)
self.maxSpeed = 0.09
self.lastKeyPressed = ""
self.blockList = []
self.mobMax = 0
self.player = Player(self.camera)
self.loadModel()
self.createBars()
self.die = False
self.paused = True
self.helpScreen()
self.accept("p", self.flipPause)
self.accept("h", self.helpFlip)
self.accept("escape", sys.exit)
self.taskMgr.add(self.update, "updateAll")
def __init__(self):
ShowBase.__init__(self)
self.title = "Monkeys"
self.setFrameRateMeter(True)
# Disable the camera trackball controls.
self.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
props.setTitle("Stay Away From The Monkeys")
props.setMouseMode(WindowProperties.M_relative)
self.win.requestProperties(props)
# set scene
self.scene = self.loader.loadModel("models/skyTest.egg")
self.scene.reparentTo(self.render)
m = 37
self.scene.setScale(m, m, m)
self.scene.setPos(0, 0, -5)
# set camera
self.camera.setPos(0, 0, 1)
self.camera.setHpr(0, 0, 0)
self.cameraSpeed = (0, 0, 0)
self.maxSpeed = 0.09
self.lastKeyPressed = ""
self.blockList = []
self.mobMax = 0
self.player = Player(self.camera)
self.loadModel()
self.createBars()
self.die = False
self.paused = True
self.helpScreen()
self.accept("p",self.flipPause)
self.accept("h",self.helpFlip)
self.accept("escape",sys.exit)
self.taskMgr.add(self.update, "updateAll")
self.ypos -= math.sin(math.radians(angleForMovement))
self.xpos -= math.cos(math.radians(angleForMovement))
#Moving RIGHT
if self.keys["d"] == True:
angleForMovement = self.angleH
#Make sure angleForMovement is 0 instead of 360, as cosine doesn't work
#with 0
if angleForMovement == 360:
angleForMovement = 0
self.ypos += math.sin(math.radians(angleForMovement))
self.xpos += math.cos(math.radians(angleForMovement))
return Task.cont
app = MyApp()
props = WindowProperties()
props.setTitle("Caleb's Game")
app.win.requestProperties(props)
app.run()
class World(DirectObject):
def __init__(self):
self.last_mousex = 0
self.last_mousey = 0
self.zone = None
self.zone_reload_name = None
self.winprops = WindowProperties( )
# simple console output
self.consoleNode = NodePath(PandaNode("console_root"))
self.consoleNode.reparentTo(aspect2d)
self.console_num_lines = 24
self.console_cur_line = -1
self.console_lines = []
for i in range(0, self.console_num_lines):
self.console_lines.append(OnscreenText(text='', style=1, fg=(1,1,1,1),
pos=(-1.3, .4-i*.05), align=TextNode.ALeft, scale = .035, parent = self.consoleNode))
# Configuration
self.consoleOut('zonewalk v.%s loading configuration' % VERSION)
self.configurator = Configurator(self)
cfg = self.configurator.config
resaveRes = False
if 'xres' in cfg:
self.xres = int(cfg['xres'])
else:
self.xres = 1024
resaveRes = True
if 'yres' in cfg:
self.yres = int(cfg['yres'])
else:
self.yres = 768
resaveRes = True
if resaveRes:
self.saveDefaultRes()
self.xres_half = self.xres / 2
self.yres_half = self.yres / 2
self.mouse_accum = MouseAccume( lambda: (self.xres_half,self.yres_half))
self.eyeHeight = 7.0
self.rSpeed = 80
self.flyMode = 1
# application window setup
base.win.setClearColor(Vec4(0,0,0,1))
self.winprops.setTitle( 'zonewalk')
self.winprops.setSize(self.xres, self.yres)
base.win.requestProperties( self.winprops )
base.disableMouse()
# network test stuff
self.login_client = None
if 'testnet' in cfg:
if cfg['testnet'] == '1':
self.doLogin()
# Post the instructions
self.title = addTitle('zonewalk v.' + VERSION)
self.inst0 = addInstructions(0.95, "[FLYMODE][1]")
self.inst1 = addInstructions(-0.95, "Camera control with WSAD/mouselook. Press K for hotkey list, ESC to exit.")
self.inst2 = addInstructions(0.9, "Loc:")
self.inst3 = addInstructions(0.85, "Hdg:")
self.error_inst = addInstructions(0, '')
self.kh = []
self.campos = Point3(155.6, 41.2, 4.93)
base.camera.setPos(self.campos)
# Accept the application control keys: currently just esc to exit navgen
self.accept("escape", self.exitGame)
self.accept("window-event", self.resizeGame)
# Create some lighting
ambient_level = .6
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(ambient_level, ambient_level, ambient_level, 1.0))
render.setLight(render.attachNewNode(ambientLight))
direct_level = 0.8
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0.0, 0.0, -1.0))
directionalLight.setColor(Vec4(direct_level, direct_level, direct_level, 1))
directionalLight.setSpecularColor(Vec4(direct_level, direct_level, direct_level, 1))
render.setLight(render.attachNewNode(directionalLight))
# create a point light that will follow our view point (the camera for now)
# attenuation is set so that this point light has a torch like effect
self.plight = PointLight('plight')
self.plight.setColor(VBase4(0.8, 0.8, 0.8, 1.0))
self.plight.setAttenuation(Point3(0.0, 0.0, 0.0002))
self.plnp = base.camera.attachNewNode(self.plight)
self.plnp.setPos(0, 0, 0)
render.setLight(self.plnp)
self.cam_light = 1
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0, "cam-left":0, \
"cam-right":0, "mouse3":0, "flymode":1 }
# setup FOG
self.fog_colour = (0.8,0.8,0.8,1.0)
self.linfog = Fog("A linear-mode Fog node")
self.linfog.setColor(self.fog_colour)
self.linfog.setLinearRange(700, 980) # onset, opaque distances as params
# linfog.setLinearFallback(45,160,320)
base.camera.attachNewNode(self.linfog)
render.setFog(self.linfog)
self.fog = 1
# camera control
self.campos = Point3(0, 0, 0)
self.camHeading = 0.0
self.camPitch = 0.0
base.camLens.setFov(65.0)
base.camLens.setFar(1200)
self.cam_speed = 0 # index into self.camp_speeds
self.cam_speeds = [40.0, 80.0, 160.0, 320.0, 640.0]
# Collision Detection for "WALKMODE"
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. The ray will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0.0, 0.0, 0.0)
self.camGroundRay.setDirection(0,0,-1) # straight down
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
# attach the col node to the camCollider dummy node
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
# self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
# self.cTrav.showCollisions(render)
# Add the spinCameraTask procedure to the task manager.
# taskMgr.add(self.spinCameraTask, "SpinCameraTask")
taskMgr.add(self.camTask, "camTask")
self.toggleControls(1)
# need to step the task manager once to make our fake console work
taskMgr.step()
# CONSOLE ---------------------------------------------------------------------
def consoleScroll(self):
for i in range(0, self.console_num_lines-1):
self.console_lines[i].setText(self.console_lines[i+1].getText())
def consoleOut(self, text):
print text # output to stdout/log too
if self.console_cur_line == self.console_num_lines-1:
self.consoleScroll()
elif self.console_cur_line < self.console_num_lines-1:
self.console_cur_line += 1
self.console_lines[self.console_cur_line].setText(text)
taskMgr.step()
def consoleOn(self):
self.consoleNode.show()
def consoleOff(self):
self.consoleNode.hide()
# User controls -----------------------------------------------------------
def toggleControls(self, on):
cfg = self.configurator.config
if on == 1:
self.accept("escape", self.exitGame)
self.accept("1", self.setSpeed, ["speed", 0])
self.accept("2", self.setSpeed, ["speed", 1])
self.accept("3", self.setSpeed, ["speed", 2])
self.accept("4", self.setSpeed, ["speed", 3])
self.accept("5", self.setSpeed, ["speed", 4])
self.accept("alt-f", self.fogToggle)
self.accept(cfg['control_lighting'], self.camLightToggle)
self.accept(cfg['control_help'], self.displayKeyHelp)
self.accept(cfg['control_flymode'], self.toggleFlymode)
self.accept(cfg['control_reload-zone'], self.reloadZone)
# Deactivate this for now
#self.accept("z", self.saveDefaultZone)
self.accept(cfg['control_cam-left'], self.setKey, ["cam-left",1])
self.accept(cfg['control_cam-right'], self.setKey, ["cam-right",1])
self.accept(cfg['control_forward'], self.setKey, ["forward",1])
# Mouse1 should be for clicking on objects
#self.accept("mouse1", self.setKey, ["forward",1])
self.accept("mouse3", self.setKey, ["mouse3",1])
self.accept(cfg['control_backward'], self.setKey, ["backward",1])
self.accept("k-up", self.hideKeyHelp)
self.accept(cfg['control_cam-left']+"-up", self.setKey, ["cam-left",0])
self.accept(cfg['control_cam-right']+"-up", self.setKey, ["cam-right",0])
self.accept(cfg['control_forward']+"-up", self.setKey, ["forward",0])
# Mouse1 should be for clicking on objects
#self.accept("mouse1-up", self.setKey, ["forward",0])
self.accept("mouse3-up", self.setKey, ["mouse3",0])
self.accept(cfg['control_backward']+"-up", self.setKey, ["backward",0])
else:
messenger.clear()
def setSpeed(self, key, value):
self.cam_speed = value
self.setFlymodeText()
def fogToggle(self):
if self.fog == 1:
render.clearFog()
base.camLens.setFar(100000)
self.fog = 0
else:
render.setFog(self.linfog)
base.camLens.setFar(1200)
self.fog = 1
def camLightToggle(self):
if self.cam_light == 0:
render.setLight(self.plnp)
self.cam_light = 1
else:
render.clearLight(self.plnp)
self.cam_light = 0
def displayKeyHelp(self):
self.kh = []
msg = 'HOTKEYS:'
pos = 0.75
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = '------------------'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'W: camera fwd, S: camera bck, A: rotate view left, D: rotate view right'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = '1-5: set camera movement speed'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'F: toggle Flymode/Walkmode'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'L: load a zone'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'ALT-F: toggle FOG and FAR plane on/off'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'T: toggle additional camera "torch" light on/off'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'Z: set currently loaded zone as new startup default'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'ESC: exit zonewalk'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
def hideKeyHelp(self):
for n in self.kh:
n.removeNode()
def setFlymodeText(self):
zname = ''
if self.zone:
zname = self.zone.name
if self.flyMode == 0:
self.inst0.setText("[WALKMODE][%i] %s" % (self.cam_speed+1, zname))
else:
self.inst0.setText("[FLYMODE][%i] %s " % (self.cam_speed+1, zname))
def toggleFlymode(self):
zname = ''
if self.zone:
zname = self.zone.name
if self.flyMode == 0:
self.flyMode = 1
else:
self.flyMode = 0
self.setFlymodeText()
# Define a procedure to move the camera.
def spinCameraTask(self, task):
angleDegrees = task.time * 6.0
angleRadians = angleDegrees * (pi / 180.0)
base.camera.setPos(20 * sin(angleRadians), -20.0 * cos(angleRadians), 3)
base.camera.setHpr(angleDegrees, 0, 0)
return task.cont
def camTask(self, task):
# query the mouse
mouse_dx = 0
mouse_dy = 0
# if we have a mouse and the right button is depressed
if base.mouseWatcherNode.hasMouse():
if self.keyMap["mouse3"] != 0:
self.mouse_accum.update()
else:
self.mouse_accum.reset()
mouse_dx = self.mouse_accum.dx
mouse_dy = self.mouse_accum.dy
self.rXSpeed = fabs(self.mouse_accum.dx) * (self.cam_speed+1) * max(5 * 1000/self.xres,3)
self.rYSpeed = fabs(self.mouse_accum.dy) * (self.cam_speed+1) * max(3 * 1000/self.yres,1)
if (self.keyMap["cam-left"]!=0 or mouse_dx < 0):
if self.rSpeed < 160:
self.rSpeed += 80 * globalClock.getDt()
if mouse_dx != 0:
self.camHeading += self.rXSpeed * globalClock.getDt()
else:
self.camHeading += self.rSpeed * globalClock.getDt()
if self.camHeading > 360.0:
self.camHeading = self.camHeading - 360.0
elif (self.keyMap["cam-right"]!=0 or mouse_dx > 0):
if self.rSpeed < 160:
self.rSpeed += 80 * globalClock.getDt()
if mouse_dx != 0:
self.camHeading -= self.rXSpeed * globalClock.getDt()
else:
self.camHeading -= self.rSpeed * globalClock.getDt()
if self.camHeading < 0.0:
self.camHeading = self.camHeading + 360.0
else:
self.rSpeed = 80
if mouse_dy > 0:
self.camPitch += self.rYSpeed * globalClock.getDt()
elif mouse_dy < 0:
self.camPitch -= self.rYSpeed * globalClock.getDt()
# set camera heading and pitch
base.camera.setHpr(self.camHeading, self.camPitch, 0)
# viewer position (camera) movement control
v = render.getRelativeVector(base.camera, Vec3.forward())
if not self.flyMode:
v.setZ(0.0)
move_speed = self.cam_speeds[self.cam_speed]
if self.keyMap["forward"] == 1:
self.campos += v * move_speed * globalClock.getDt()
if self.keyMap["backward"] == 1:
self.campos -= v * move_speed * globalClock.getDt()
# actually move the camera
lastPos = base.camera.getPos()
base.camera.setPos(self.campos)
# self.plnp.setPos(self.campos) # move the point light with the viewer position
# WALKMODE: simple collision detection
# we simply check a ray from slightly below the "eye point" straight down
# for geometry collisions and if there are any we detect the point of collision
# and adjust the camera's Z accordingly
if self.flyMode == 0:
# move the camera to where it would be if it made the move
# the colliderNode moves with it
# base.camera.setPos(self.campos)
# check for collissons
self.cTrav.traverse(render)
entries = []
for i in range(self.camGroundHandler.getNumEntries()):
entry = self.camGroundHandler.getEntry(i)
entries.append(entry)
# print 'collision'
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries) > 0): # and (entries[0].getIntoNode().getName() == "terrain"):
# print len(entries)
self.campos.setZ(entries[0].getSurfacePoint(render).getZ()+self.eyeHeight)
else:
self.campos = lastPos
base.camera.setPos(self.campos)
#if (base.camera.getZ() < self.player.getZ() + 2.0):
# base.camera.setZ(self.player.getZ() + 2.0)
# update loc and hpr display
pos = base.camera.getPos()
hpr = base.camera.getHpr()
self.inst2.setText('Loc: %.2f, %.2f, %.2f' % (pos.getX(), pos.getY(), pos.getZ()))
self.inst3.setText('Hdg: %.2f, %.2f, %.2f' % (hpr.getX(), hpr.getY(), hpr.getZ()))
return task.cont
def exitGame(self):
sys.exit(0)
def resizeGame(self,win):
props = base.win.getProperties()
self.xres = props.getXSize()
self.yres = props.getYSize()
self.xres_half = self.xres / 2
self.yres_half = self.yres / 2
self.saveDefaultRes()
#Records the state of the arrow keys
# this is used for camera control
def setKey(self, key, value):
self.keyMap[key] = value
# -------------------------------------------------------------------------
# this is the mythical MAIN LOOP :)
def update(self):
if self.zone_reload_name != None:
self.doReload(self.zone_reload_name)
self.zone_reload_name = None
if self.zone != None:
self.zone.update()
taskMgr.step()
if self.login_client != None:
self.login_client.update()
# ZONE loading ------------------------------------------------------------
# general zone loader driver
# removes existing zone (if any) and load the new one
def loadZone(self, name, path):
if path[len(path)-1] != '/':
path += '/'
if self.zone:
self.zone.rootNode.removeNode()
self.zone = Zone(self, name, path)
error = self.zone.load()
if error == 0:
self.consoleOff()
self.setFlymodeText()
base.setBackgroundColor(self.fog_colour)
def saveDefaultRes(self):
cfg = self.configurator.config
cfg['xres'] = str(self.xres)
cfg['yres'] = str(self.yres)
#self.configurator.saveConfig()
# initial world load after bootup
def load(self):
cfg = self.configurator.config
if self.login_client != None:
return
zone_name = cfg['default_zone']
basepath = cfg['basepath']
self.loadZone(zone_name, basepath)
# config save user interfacce
def saveDefaultZone(self):
if self.zone:
cfg = self.configurator.config
cfg['default_zone'] = self.zone.name
#self.configurator.saveConfig()
# zone reload user interface
# this gets called from our update loop when it detects that zone_reload_name has been set
# we do this in this convoluted fashion in order to keep the main loop taskMgr updates ticking
# because otherwise our status console output at various stages during the zone load would not
# be displayed. Yes, this is hacky.
def doReload(self, name):
cfg = self.configurator.config
basepath = cfg['basepath']
self.loadZone(name, basepath)
# form dialog callback
# this gets called from the form when the user has entered a something
# (hopefully a correct zone short name)
def reloadZoneDialogCB(self, name):
self.frmDialog.end()
self.zone_reload_name = name
self.toggleControls(1)
# this is called when the user presses "l"
# it disables normal controls and fires up our query form dialog
def reloadZone(self):
base.setBackgroundColor((0,0,0))
self.toggleControls(0)
self.consoleOn()
self.frmDialog = FileDialog(
"Please enter the shortname of the zone you wish to load:",
"Examples: qrg, blackburrow, freportn, crushbone etc.",
self.reloadZoneDialogCB)
self.frmDialog.activate() # relies on the main update loop to run
###############################
# EXPERIMENTAL
def doLogin(self):
self.login_client = UDPClientStream('127.0.0.1', 5998)
#####################################
# Custom methods
#####################################
# What happens when a user clicks on a model
def onModelClick():
# Code adapted freely from http://www.panda3d.org/forums/viewtopic.php?t=12717
global picker, selected_model
namedNode, thePoint, rawNode = picker.pick()
if namedNode:
if "_mesh" not in namedNode.getName(): # rough test to avoid printing infos on global zone mesh (ie: "freporte_mesh")
name = namedNode.getName()
p = namedNode.getParent()
pos = p.getPos()
selected_model = namedNode
print namedNode.getName()
print "Collision Point: ", thePoint
namedNode.ls()
else:
print "Clicked location point (y, x, z):", thePoint
#selected_model.setPos(thePoint.getX(), thePoint.getY(), thePoint.getZ())
m.setPos(thePoint.getX(), thePoint.getY(), thePoint.getZ())
print "Moved !"
# Handles populating the zone with spawn data from the EQEmu DB
# also makes each spawner model pickable
def PopulateSpawns(self, cursor, numrows):
spawn_coords = list()
globals.model_list = list()
for x in range(0, numrows):
row = cursor.fetchone()
point = Point3(long(row["Spawn2Y"]), long(row["Spawn2X"]), long(row["Spawn2Z"]))
if point not in spawn_coords:
s = loader.loadModel("models/cube.egg")
s.reparentTo(render)
s.setPos(row["Spawn2Y"], row["Spawn2X"], row["Spawn2Z"])
min,macks= s.getTightBounds()
radius = max([macks.getY() - min.getY(), macks.getX() - min.getX()])/2
cs = CollisionSphere(row["Spawn2X"], row["Spawn2Y"], row["Spawn2Z"], radius)
csNode = s.attachNewNode(CollisionNode("modelCollide"))
csNode.node().addSolid(cs)
s.setTag("name", row["name"])
picker.makePickable(s)
globals.model_list.append(s)
spawn_coords.append(point)
# Establishes a connection to the EQEmu database
def ConnectToDatabase(self):
configurator = Configurator(world)
cfg = configurator.config
conn = MySQLdb.Connection(
host=cfg['host'],
user=cfg['user'],
passwd=cfg['password'],
db=cfg['db'])
return conn
# Queries the Database in order to get spawn data
# (this should be refactored at some point)
def GetDbSpawnData(self, connection):
cursor = connection.cursor(MySQLdb.cursors.DictCursor)
query = """SELECT nt.name, s2.zone, s2.x as Spawn2X, s2.y as Spawn2Y, s2.z as Spawn2Z, sg.name as spawngroup_name,sg.id as Spawngroup_id, sg.min_x as Spawngroup_minX, sg.max_x as Spawngroup_maxX, sg.min_y as Spawngroup_minY, sg.max_y as Spawngroup_maxY, sg.dist as Spawngroup_dist, sg.mindelay as Spawngroup_mindelay,
sg.delay as Spawngroup_delay FROM spawn2 s2
JOIN spawngroup sg ON sg.id = s2.spawngroupid
JOIN spawnentry se
ON se.spawngroupid = sg.id
JOIN npc_types nt
ON nt.id = se.npcid
WHERE s2.zone = 'freporte'"""
cursor.execute(query)
return cursor
# Initializes the camera position upon startup
def InitCameraPosition(self):
world.campos = Point3(-155.6, 41.2, 4.9 + world.eyeHeight)
world.camHeading = 270.0
base.camera.setPos(world.campos)
def GetCamera(self):
return base.camera
def __init__(self):
ShowBase.__init__(self)
winProps = WindowProperties()
winProps.setTitle("Triangle and SimpleCircle Unittest")
# base.win.requestProperties(winProps) (same as below e.g. self == base)
self.win.requestProperties(winProps)
# 1) create GeomVertexData
frmt = GeomVertexFormat.getV3n3cp()
vdata = GeomVertexData('triangle_developer', frmt, Geom.UHDynamic)
# 2) create Writers/Rewriters (must all be created before any readers and readers are one-pass-temporary)
vertex = GeomVertexRewriter(vdata, 'vertex')
normal = GeomVertexRewriter(vdata, 'normal')
color = GeomVertexRewriter(vdata, 'color')
zUp = Vec3(0, 0, 1)
wt = Vec4(1.0, 1.0, 1.0, 1.0)
gr = Vec4(0.5, 0.5, 0.5, 1.0)
# 3) write each column on the vertex data object (for speed, have a different writer for each column)
def addPoint(x, y, z):
vertex.addData3f(x, y, z)
normal.addData3f(zUp)
color.addData4f(wt)
addPoint(0.0, 0.0, 0.0)
addPoint(5.0, 0.0, 0.0)
addPoint(0.0, 5.0, 0.0)
addPoint(15.0, 15.0, 0.0)
# 4) create a primitive and add the vertices via index (not truely associated with the actual vertex table, yet)
tris = GeomTriangles(Geom.UHDynamic)
t1 = Triangle(0, 1, 2, vdata, tris, vertex)
t2 = Triangle(2, 1, 3, vdata, tris, vertex)
c1 = t1.getCircumcircle()
t1AsEnum = t1.asPointsEnum()
r0 = (t1AsEnum.point0 - c1.center).length()
r1 = (t1AsEnum.point1 - c1.center).length()
r2 = (t1AsEnum.point2 - c1.center).length()
assert abs(r0 - r2) < utilities.EPSILON and abs(r0 - r1) < utilities.EPSILON
t2AsEnum = t2.asPointsEnum()
c2 = t2.getCircumcircle()
r0 = (t2AsEnum.point0 - c2.center).length()
r1 = (t2AsEnum.point1 - c2.center).length()
r2 = (t2AsEnum.point2 - c2.center).length()
assert abs(r0 - r2) < utilities.EPSILON and abs(r0 - r1) < utilities.EPSILON
assert t1.getAngleDeg0() == 90.0
assert t1.getAngleDeg1() == t1.getAngleDeg2()
oldInd0 = t1.pointIndex0
oldInd1 = t1.pointIndex1
oldInd2 = t1.pointIndex2
t1.pointIndex0 = t1.pointIndex1
t1.pointIndex1 = oldInd0
assert t1.pointIndex0 == oldInd1
assert t1.pointIndex1 == oldInd0
assert t1.pointIndex0 != t1.pointIndex1
t1.reverse()
assert t1.pointIndex1 == oldInd2
# 5.1) (adding to scene) create a Geom and add primitives of like base-type i.e. triangles and triangle strips
geom = Geom(vdata)
geom.addPrimitive(tris)
# 5.2) create a GeomNode to hold the Geom(s) and add the Geom(s)
gn = GeomNode('gnode')
gn.addGeom(geom)
# 5.3) attache the node to the scene
gnNodePath = render.attachNewNode(gn)
# setup a wire frame
wireNP = render.attachNewNode('wire')
wireNP.setPos(0.0, 0.0, .1)
wireNP.setColor(0.1, 0.1, 0.1, 1)
wireNP.setRenderMode(RenderModeAttrib.MWireframe, .5, 0)
gnNodePath.instanceTo(wireNP)
# test and draw intersections and circles
pt1 = Point3(0.0, 5.0, 0.0)
pt2 = Point3(1.0, 5.0, 0.0)
intersection = t2.getIntersectionsWithCircumcircle(pt1, pt2)
circle = t2.getCircumcircle()
cuts = 128
border = circle.getBorder(cuts, closed=True)
assert len(border) == cuts or (len(border) == cuts + 1 and border[0] == border[len(border) - 1])
n = len(border)
xMid = yMid = 0
for p in border:
xMid += p.x
yMid += p.y
mid = Point3(xMid / n, yMid / n, border[0].z)
assert mid.almostEqual(circle.center, 0.06)
assert t2.isCcw()
assert t1.containsPoint(c1.center) != t1.containsPoint(c1.center, includeEdges=False)
circleSegs = LineSegs("circleLines")
circleSegs.setColor(1.0, 0.0, 0.0, 1.0)
for p in border:
circleSegs.drawTo(*p)
circleNode = circleSegs.create(False)
circleNP = render.attachNewNode(circleNode)
circleNP.setZ(-5)
originSpot = LineSegs("intersection")
originSpot.setColor(1.0, 0.0, 0.0, 1.0)
originSpot.setThickness(10)
for p in intersection:
originSpot.drawTo(p)
spotNode = originSpot.create(False)
spotNP = render.attachNewNode(spotNode)
circleNP.setZ(-0.75)
# fix the camera rot/pos
PHF.PanditorDisableMouseFunc()
camera.setPos(0.0, 0.0, 50.0)
camera.lookAt(c2.center)
PHF.PanditorEnableMouseFunc()
class World(DirectObject):
cfg = None
def __init__(self):
self.last_mousex = 0
self.last_mousey = 0
self.zone = None
self.zone_reload_name = None
self.winprops = WindowProperties( )
# simple console output
self.consoleNode = NodePath(PandaNode("console_root"))
self.consoleNode.reparentTo(aspect2d)
self.console_num_lines = 24
self.console_cur_line = -1
self.console_lines = []
for i in range(0, self.console_num_lines):
self.console_lines.append(OnscreenText(text='', style=1, fg=(1,1,1,1),
pos=(-1.3, .4-i*.05), align=TextNode.ALeft, scale = .035, parent = self.consoleNode))
# Configuration
self.consoleOut('World Forge v.%s loading configuration' % VERSION)
self.configurator = Configurator(self)
cfg = self.configurator.config
resaveRes = False
if 'xres' in cfg:
self.xres = int(cfg['xres'])
else:
self.xres = 1024
resaveRes = True
if 'yres' in cfg:
self.yres = int(cfg['yres'])
else:
self.yres = 768
resaveRes = True
if resaveRes:
self.saveDefaultRes()
self.xres_half = self.xres / 2
self.yres_half = self.yres / 2
self.mouse_accum = MouseAccume( lambda: (self.xres_half,self.yres_half))
self.eyeHeight = 7.0
self.rSpeed = 80
self.flyMode = 1
# application window setup
base.win.setClearColor(Vec4(0,0,0,1))
self.winprops.setTitle( 'World Forge')
self.winprops.setSize(self.xres, self.yres)
base.win.requestProperties( self.winprops )
base.disableMouse()
# Post the instructions
self.title = addTitle('World Forge v.' + VERSION)
self.inst0 = addInstructions(0.95, "[FLYMODE][1]")
self.inst1 = addInstructions(-0.95, "Camera control with WSAD/mouselook. Press K for hotkey list, ESC to exit.")
self.inst2 = addInstructions(0.9, "Loc:")
self.inst3 = addInstructions(0.85, "Hdg:")
self.error_inst = addInstructions(0, '')
self.kh = []
self.campos = Point3(155.6, 41.2, 4.93)
base.camera.setPos(self.campos)
# Accept the application control keys: currently just esc to exit navgen
self.accept("escape", self.exitGame)
self.accept("window-event", self.resizeGame)
# Create some lighting
ambient_level = .6
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(ambient_level, ambient_level, ambient_level, 1.0))
render.setLight(render.attachNewNode(ambientLight))
direct_level = 0.8
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0.0, 0.0, -1.0))
directionalLight.setColor(Vec4(direct_level, direct_level, direct_level, 1))
directionalLight.setSpecularColor(Vec4(direct_level, direct_level, direct_level, 1))
render.setLight(render.attachNewNode(directionalLight))
# create a point light that will follow our view point (the camera for now)
# attenuation is set so that this point light has a torch like effect
self.plight = PointLight('plight')
self.plight.setColor(VBase4(0.8, 0.8, 0.8, 1.0))
self.plight.setAttenuation(Point3(0.0, 0.0, 0.0002))
self.plnp = base.camera.attachNewNode(self.plight)
self.plnp.setPos(0, 0, 0)
render.setLight(self.plnp)
self.cam_light = 1
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0, "cam-left":0, \
"cam-right":0, "mouse3":0, "flymode":1 }
# setup FOG
self.fog_colour = (0.8,0.8,0.8,1.0)
self.linfog = Fog("A linear-mode Fog node")
self.linfog.setColor(self.fog_colour)
self.linfog.setLinearRange(700, 980) # onset, opaque distances as params
# linfog.setLinearFallback(45,160,320)
base.camera.attachNewNode(self.linfog)
render.setFog(self.linfog)
self.fog = 1
# camera control
self.campos = Point3(0, 0, 0)
self.camHeading = 0.0
self.camPitch = 0.0
base.camLens.setFov(65.0)
base.camLens.setFar(1200)
self.cam_speed = 0 # index into self.camp_speeds
self.cam_speeds = [40.0, 80.0, 160.0, 320.0, 640.0]
# Collision Detection for "WALKMODE"
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. The ray will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0.0, 0.0, 0.0)
self.camGroundRay.setDirection(0,0,-1) # straight down
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
# attach the col node to the camCollider dummy node
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
# self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
# self.cTrav.showCollisions(render)
# Add the spinCameraTask procedure to the task manager.
# taskMgr.add(self.spinCameraTask, "SpinCameraTask")
globals.hasClickedSpawn = False;
globals.hasClickedGrid = False;
taskMgr.add(self.camTask, "camTask")
self.toggleControls(1)
# need to step the task manager once to make our fake console work
taskMgr.step()
# CONSOLE ---------------------------------------------------------------------
def consoleScroll(self):
for i in range(0, self.console_num_lines-1):
self.console_lines[i].setText(self.console_lines[i+1].getText())
def consoleOut(self, text):
print text # output to stdout/log too
if self.console_cur_line == self.console_num_lines-1:
self.consoleScroll()
elif self.console_cur_line < self.console_num_lines-1:
self.console_cur_line += 1
self.console_lines[self.console_cur_line].setText(text)
taskMgr.step()
def consoleOn(self):
self.consoleNode.show()
def consoleOff(self):
self.consoleNode.hide()
# User controls -----------------------------------------------------------
def toggleControls(self, on):
cfg = self.configurator.config
if on == 1:
self.accept("escape", self.exitGame)
self.accept("1", self.setSpeed, ["speed", 0])
self.accept("2", self.setSpeed, ["speed", 1])
self.accept("3", self.setSpeed, ["speed", 2])
self.accept("4", self.setSpeed, ["speed", 3])
self.accept("5", self.setSpeed, ["speed", 4])
self.accept("alt-f", self.fogToggle)
self.accept(cfg['control_lighting'], self.camLightToggle)
self.accept(cfg['control_help'], self.displayKeyHelp)
self.accept(cfg['control_flymode'], self.toggleFlymode)
self.accept(cfg['control_reload-zone'], self.reloadZone)
self.accept(cfg['control_cam-left'], self.setKey, ["cam-left",1])
self.accept(cfg['control_cam-right'], self.setKey, ["cam-right",1])
self.accept(cfg['control_forward'], self.setKey, ["forward",1])
self.accept("mouse3", self.setKey, ["mouse3",1])
self.accept(cfg['control_backward'], self.setKey, ["backward",1])
self.accept("k-up", self.hideKeyHelp)
self.accept(cfg['control_cam-left']+"-up", self.setKey, ["cam-left",0])
self.accept(cfg['control_cam-right']+"-up", self.setKey, ["cam-right",0])
self.accept(cfg['control_forward']+"-up", self.setKey, ["forward",0])
self.accept("mouse3-up", self.setKey, ["mouse3",0])
self.accept(cfg['control_backward']+"-up", self.setKey, ["backward",0])
self.accept(cfg['toggle_edit-mode'], self.toggleEditMode)
self.accept(cfg['toggle_insert-mode'], self.toggleInsertMode)
self.accept(cfg['toggle_explore-mode'], self.toggleExploreMode)
self.accept(cfg['toggle_grid-mode'], self.toggleGridMode)
# Accept both single-presses and long presses for rotating models
self.accept(cfg['rotate-right'] + "-repeat", self.rotateModelRight)
self.accept(cfg['rotate-left'] + "-repeat", self.rotateModelLeft)
self.accept(cfg['rotate-right'], self.rotateModelRight)
self.accept(cfg['rotate-left'], self.rotateModelLeft)
self.accept(cfg['clear-selection'], self.clearSelection)
else:
messenger.clear()
def rotateModelRight(self):
if globals.editMode == True:
if globals.selectedSpawn:
cfg = self.configurator.config
globals.selectedSpawn.model.setH(globals.selectedSpawn.model.getH() + int(cfg['rotation-amount']))
# Really not sure about that...
if globals.selectedSpawn.model.getH() > 360:
globals.selectedSpawn.model.setH(0)
print globals.selectedSpawn.model.getH()
globals.selectedSpawn.setheadingfromworld(globals.selectedSpawn.model.getH())
globals.spawndialog.m_spawnEntryHeadingTextCtrl.SetValue(str(globals.selectedSpawn.spawnentry_heading))
if globals.config['autosave_edit-mode'] == 'True':
globals.database.UpdateSpawn(globals.selectedSpawn)
print globals.selectedSpawn.spawnentry_heading
def rotateModelLeft(self):
if globals.editMode == True:
if globals.selectedSpawn:
cfg = self.configurator.config
globals.selectedSpawn.model.setH(globals.selectedSpawn.model.getH() - int(cfg['rotation-amount']))
# Really not sure about that either...
if globals.selectedSpawn.model.getH() < -360:
globals.selectedSpawn.model.setH(0)
print globals.selectedSpawn.model.getH()
globals.selectedSpawn.setheadingfromworld(globals.selectedSpawn.model.getH())
globals.spawndialog.m_spawnEntryHeadingTextCtrl.SetValue(str(globals.selectedSpawn.spawnentry_heading))
if globals.config['autosave_edit-mode'] == 'True':
globals.database.UpdateSpawn(globals.selectedSpawn)
print globals.selectedSpawn.spawnentry_heading
def clearSelection(self, eraseNpcId = True):
globals.selectedspawn = None
globals.selectedgrid = None
globals.picker.lastSelectedObject = None
if self.inst6:
self.inst6.destroy()
self.inst6 = addInstructions(0.7, "Current selection: None")
npcid = globals.spawndialog.m_spawnEntryNpcIdTextCtrl.Value
globals.spawndialog.Reset()
# f*****g hacky shit man
if eraseNpcId == False:
globals.spawndialog.m_spawnEntryNpcIdTextCtrl.SetValue(npcid)
gridmanager = GridpointManager()
gridmanager.ResetGridList()
print "Cleared all selections !"
def toggleDefaultMode(self):
globals.editMode = False
globals.insertMode = False
globals.exploreMode = True
globals.gridMode = False
print "STARTUP Explore mode ACTIVATED"
print "STARTUP Grid mode DEACTIVATED"
self.inst4 = addInstructions(0.8, "Explore mode ON")
self.inst5 = addInstructions(0.75, "Grid mode OFF")
self.inst6 = addInstructions(0.7, "Current selection: None")
def toggleEditMode(self):
globals.editMode = True
globals.insertMode = False
globals.exploreMode = False
print "Edit mode ACTIVATED"
if self.inst4:
self.inst4.destroy()
self.inst4 = addInstructions(0.8, "Edit mode ON")
def toggleInsertMode(self):
globals.editMode = False
globals.insertMode = True
globals.exploreMode = False
print "Insert mode ACTIVATED"
if self.inst4:
self.inst4.destroy()
self.inst4 = addInstructions(0.8, "Insert mode ON")
def toggleExploreMode(self):
globals.editMode = False
globals.insertMode = False
globals.exploreMode = True
print "Explore mode ACTIVATED"
if self.inst4:
self.inst4.destroy()
self.inst4 = addInstructions(0.8, "Explore mode ON")
def toggleGridMode(self):
if globals.gridMode == False:
globals.gridMode = True
print "Grid mode ACTIVATED"
if self.inst5:
self.inst5.destroy()
self.inst5 = addInstructions(0.75, "Grid mode ON")
else:
globals.gridMode = False
print "Grid mode DEACTIVATED"
if self.inst5:
self.inst5.destroy()
self.inst5 = addInstructions(0.75, "Grid mode OFF")
def setSpeed(self, key, value):
self.cam_speed = value
self.setFlymodeText()
def fogToggle(self):
if self.fog == 1:
render.clearFog()
base.camLens.setFar(100000)
self.fog = 0
else:
render.setFog(self.linfog)
base.camLens.setFar(1200)
self.fog = 1
def camLightToggle(self):
if self.cam_light == 0:
render.setLight(self.plnp)
self.cam_light = 1
else:
render.clearLight(self.plnp)
self.cam_light = 0
def displayKeyHelp(self):
self.kh = []
msg = 'HOTKEYS:'
pos = 0.75
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = '------------------'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'W: camera fwd, S: camera bck, A: rotate view left, D: rotate view right'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = '1-5: set camera movement speed'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'F: toggle Flymode/Walkmode'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'L: load a zone'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'ALT-F: toggle FOG and FAR plane on/off'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'T: toggle additional camera "torch" light on/off'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'Z: set currently loaded zone as new startup default'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
msg = 'ESC: exit World Forge'
pos -= 0.05
self.kh.append(OnscreenText(text=msg, style=1, fg=(1,1,1,1),
pos=(-0.5, pos), align=TextNode.ALeft, scale = .04))
def hideKeyHelp(self):
for n in self.kh:
n.removeNode()
def setFlymodeText(self):
zname = ''
if self.zone:
zname = self.zone.name
if self.flyMode == 0:
self.inst0.setText("[WALKMODE][%i] %s" % (self.cam_speed+1, zname))
else:
self.inst0.setText("[FLYMODE][%i] %s " % (self.cam_speed+1, zname))
def toggleFlymode(self):
zname = ''
if self.zone:
zname = self.zone.name
if self.flyMode == 0:
self.flyMode = 1
else:
self.flyMode = 0
self.setFlymodeText()
# Define a procedure to move the camera.
def spinCameraTask(self, task):
angleDegrees = task.time * 6.0
angleRadians = angleDegrees * (pi / 180.0)
base.camera.setPos(20 * sin(angleRadians), -20.0 * cos(angleRadians), 3)
base.camera.setHpr(angleDegrees, 0, 0)
return task.cont
def camTask(self, task):
if globals.hasClickedSpawn:
base.camera.setPos(globals.selectedSpawnPoint3D)
self.campos = globals.selectedSpawnPoint3D
globals.hasClickedSpawn = False
elif globals.hasClickedGrid:
base.camera.setPos(globals.selectedGridPoint3D)
self.campos = globals.selectedGridPoint3D
globals.hasClickedGrid = False
else:
# query the mouse
mouse_dx = 0
mouse_dy = 0
# if we have a mouse and the right button is depressed
if base.mouseWatcherNode.hasMouse():
if self.keyMap["mouse3"] != 0:
self.mouse_accum.update()
else:
self.mouse_accum.reset()
mouse_dx = self.mouse_accum.dx
mouse_dy = self.mouse_accum.dy
self.rXSpeed = fabs(self.mouse_accum.dx) * (self.cam_speed+1) * max(5 * 1000/self.xres,3)
self.rYSpeed = fabs(self.mouse_accum.dy) * (self.cam_speed+1) * max(3 * 1000/self.yres,1)
if (self.keyMap["cam-left"]!=0 or mouse_dx < 0):
if self.rSpeed < 160:
self.rSpeed += 80 * globalClock.getDt()
if mouse_dx != 0:
self.camHeading += self.rXSpeed * globalClock.getDt()
else:
self.camHeading += self.rSpeed * globalClock.getDt()
if self.camHeading > 360.0:
self.camHeading = self.camHeading - 360.0
elif (self.keyMap["cam-right"]!=0 or mouse_dx > 0):
if self.rSpeed < 160:
self.rSpeed += 80 * globalClock.getDt()
if mouse_dx != 0:
self.camHeading -= self.rXSpeed * globalClock.getDt()
else:
self.camHeading -= self.rSpeed * globalClock.getDt()
if self.camHeading < 0.0:
self.camHeading = self.camHeading + 360.0
else:
self.rSpeed = 80
if mouse_dy > 0:
self.camPitch += self.rYSpeed * globalClock.getDt()
elif mouse_dy < 0:
self.camPitch -= self.rYSpeed * globalClock.getDt()
# set camera heading and pitch
base.camera.setHpr(self.camHeading, self.camPitch, 0)
# viewer position (camera) movement control
v = render.getRelativeVector(base.camera, Vec3.forward())
if not self.flyMode:
v.setZ(0.0)
move_speed = self.cam_speeds[self.cam_speed]
if self.keyMap["forward"] == 1:
self.campos += v * move_speed * globalClock.getDt()
if self.keyMap["backward"] == 1:
self.campos -= v * move_speed * globalClock.getDt()
# actually move the camera
lastPos = base.camera.getPos()
base.camera.setPos(self.campos)
# self.plnp.setPos(self.campos) # move the point light with the viewer position
# WALKMODE: simple collision detection
# we simply check a ray from slightly below the "eye point" straight down
# for geometry collisions and if there are any we detect the point of collision
# and adjust the camera's Z accordingly
if self.flyMode == 0:
# move the camera to where it would be if it made the move
# the colliderNode moves with it
# base.camera.setPos(self.campos)
# check for collissons
self.cTrav.traverse(render)
entries = []
for i in range(self.camGroundHandler.getNumEntries()):
entry = self.camGroundHandler.getEntry(i)
entries.append(entry)
# print 'collision'
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries) > 0): # and (entries[0].getIntoNode().getName() == "terrain"):
# print len(entries)
self.campos.setZ(entries[0].getSurfacePoint(render).getZ()+self.eyeHeight)
else:
self.campos = lastPos
base.camera.setPos(self.campos)
#if (base.camera.getZ() < self.player.getZ() + 2.0):
# base.camera.setZ(self.player.getZ() + 2.0)
# update loc and hpr display
pos = base.camera.getPos()
hpr = base.camera.getHpr()
self.inst2.setText('Loc: %.2f, %.2f, %.2f' % (pos.getX(), pos.getY(), pos.getZ()))
self.inst3.setText('Hdg: %.2f, %.2f, %.2f' % (hpr.getX(), hpr.getY(), hpr.getZ()))
return task.cont
def exitGame(self):
globals.database.conn.close()
print "DB connection closed !"
sys.exit(0)
def resizeGame(self,win):
props = base.win.getProperties()
self.xres = props.getXSize()
self.yres = props.getYSize()
self.xres_half = self.xres / 2
self.yres_half = self.yres / 2
self.saveDefaultRes()
#Records the state of the arrow keys
# this is used for camera control
def setKey(self, key, value):
self.keyMap[key] = value
# -------------------------------------------------------------------------
# this is the mythical MAIN LOOP :)
def update(self):
if self.zone_reload_name != None:
self.doReload(self.zone_reload_name)
self.zone_reload_name = None
if self.zone != None:
self.zone.update()
taskMgr.step()
# ZONE loading ------------------------------------------------------------
# general zone loader driver
# removes existing zone (if any) and load the new one
def loadZone(self, name, path):
if path[len(path)-1] != '/':
path += '/'
if self.zone:
self.zone.rootNode.removeNode()
self.zone = Zone(self, name, path)
error = self.zone.load()
if error == 0:
self.consoleOff()
self.setFlymodeText()
base.setBackgroundColor(self.fog_colour)
def saveDefaultRes(self):
cfg = self.configurator.config
cfg['xres'] = str(self.xres)
cfg['yres'] = str(self.yres)
# initial world load after bootup
def load(self):
cfg = self.configurator.config
zone_name = cfg['default_zone']
globals.currentZone = zone_name
basepath = cfg['basepath']
self.loadZone(zone_name, basepath)
# zone reload user interface
# this gets called from our update loop when it detects that zone_reload_name has been set
# we do this in this convoluted fashion in order to keep the main loop taskMgr updates ticking
# because otherwise our status console output at various stages during the zone load would not
# be displayed. Yes, this is hacky.
def doReload(self, name):
cfg = self.configurator.config
basepath = cfg['basepath']
self.loadZone(name, basepath)
# form dialog callback
# this gets called from the form when the user has entered a something
# (hopefully a correct zone short name)
def reloadZoneDialogCB(self, name):
self.frmDialog.end()
self.zone_reload_name = name
self.toggleControls(1)
# this is called when the user presses "l"
# it disables normal controls and fires up our query form dialog
def reloadZone(self):
base.setBackgroundColor((0,0,0))
self.toggleControls(0)
self.consoleOn()
self.frmDialog = FileDialog(
"Please enter the shortname of the zone you wish to load:",
"Examples: qrg, blackburrow, freportn, crushbone etc.",
self.reloadZoneDialogCB)
self.frmDialog.activate() # relies on the main update loop to run
#####################################
# Custom methods
#####################################
# Handles populating the zone with spawn data from the EQEmu DB
# also makes each spawner model pickable
def PopulateSpawns(self, cursor, numrows):
spawn_coords = list()
globals.spawn_list = list()
cfg = self.configurator.config
for x in range(0, numrows):
row = cursor.fetchone()
point = Point3(long(row["Spawn2Y"]), long(row["Spawn2X"]), long(row["Spawn2Z"]))
if cfg['ignore_duplicate_spawns'] == 'True':
if point not in spawn_coords:
self.PlaceSpawnPointOn3dMap(row)
spawn_coords.append(point)
else:
self.PlaceSpawnPointOn3dMap(row)
def PlaceSpawnPointOn3dMap(self, row):
spawn = Spawn()
self.InitSpawnData(spawn, row)
spawn.model = loader.loadModel(spawn.modelname)
spawn.initmodel()
spawn.model.reparentTo(render)
spawn.initheadingfromdb(row["Spawn2Heading"])
spawn.placeintoworld(row["Spawn2Y"], row["Spawn2X"], row["Spawn2Z"])
min, macks = spawn.model.getTightBounds()
radius = max([macks.getY() - min.getY(), macks.getX() - min.getX()]) / 2
cs = CollisionSphere(row["Spawn2X"], row["Spawn2Y"], row["Spawn2Z"], radius)
csNode = spawn.model.attachNewNode(CollisionNode("modelCollide"))
csNode.node().addSolid(cs)
# TODO: ADD MORE TAGS??
spawn.model.setTag("name", row["NpcName"])
spawn.model.setTag("spawngroup_name", row["spawngroup_name"])
spawn.model.setTag("spawn2id", str(row["Spawn2Id"]))
spawn.model.setTag("type", "spawn")
globals.picker.makePickable(spawn.model)
globals.spawn_list.append(spawn)
# Initializes a spawn object with database values
def InitSpawnData(self, spawn, row):
spawn.spawngroup_id = row["Spawngroup_id"]
spawn.spawngroup_name = row["spawngroup_name"]
spawn.spawngroup_minx = row["Spawngroup_minX"]
spawn.spawngroup_maxx= row["Spawngroup_maxX"]
spawn.spawngroup_miny = row["Spawngroup_minY"]
spawn.spawngroup_maxy = row["Spawngroup_maxY"]
spawn.spawngroup_dist = row["Spawngroup_dist"]
spawn.spawngroup_mindelay = row["Spawngroup_mindelay"]
spawn.spawngroup_delay = row["Spawngroup_delay"]
spawn.spawngroup_despawn = row["Spawngroup_despawntimer"]
spawn.spawngroup_despawntimer = row["Spawngroup_despawntimer"]
spawn.spawngroup_spawnlimit = row["Spawngroup_spawnlimit"]
spawn.spawnentry_id = row["Spawn2Id"]
spawn.spawnentry_npcid = row["NpcId"]
spawn.spawnentry_npcname = row["NpcName"]
spawn.spawnentry_chance = row["Spawnentry_chance"]
spawn.spawnentry_x = row["Spawn2X"]
spawn.spawnentry_y = row["Spawn2Y"]
spawn.spawnentry_z = row["Spawn2Z"]
spawn.spawnentry_heading = row["Spawn2Heading"]
spawn.spawnentry_respawn = row["Spawn2Respawn"]
spawn.spawnentry_variance = row["Spawn2Variance"]
spawn.spawnentry_pathgrid = row["Spawn2Grid"]
spawn.spawnentry_condition = row["Spawn2Condition"]
spawn.spawnentry_condvalue = row["Spawn2CondValue"]
spawn.spawnentry_version = row["Spawn2Version"]
spawn.spawnentry_enabled = row["Spawn2Enabled"]
spawn.spawnentry_animation = row["Spawn2Animation"]
spawn.spawnentry_zone = row["Spawn2Zone"]
spawn.spawnentry_originalx = row["Spawn2X"]
spawn.spawnentry_originaly = row["Spawn2Y"]
spawn.spawnentry_originalz = row["Spawn2Z"]
spawn.spawnentry_originalheading = row["Spawn2Heading"]
# Initializes the camera position upon startup
def InitCameraPosition(self):
world.campos = Point3(-155.6, 41.2, 4.9 + world.eyeHeight)
world.camHeading = 270.0
base.camera.setPos(world.campos)
def GetCamera(self):
return base.camera
from ColObjBase import *
import mathPaths as mp
from direct.task import Task
from pandac.PandaModules import WindowProperties
props = WindowProperties()
props.setTitle('By Rizwan AR')
class Universe(InvCollideObj):
def __init__(self, modelPath, parentNode, nodeName, texPath, posVec,
scaleVec):
base.win.requestProperties(props)
mySound = base.loader.loadSfx("bgm.mp3")
mySound.play()
super(Universe, self).__init__(modelPath, parentNode, nodeName, 0, 0,
0, 0.9)
self.modelNode.setPos(posVec)
self.modelNode.setScale(scaleVec)
tex = loader.loadTexture(texPath)
self.modelNode.setTexture(tex, 1)
class Planet(SphereCollideObj):
def __init__(self, modelPath, parentNode, nodeName, texPath, posVec,
scaleVec):
super(Planet, self).__init__(modelPath, parentNode, nodeName, 0, 0, 0,
1)
self.modelNode.setPos(posVec)
self.modelNode.setScale(scaleVec)
tex = loader.loadTexture(texPath)
self.modelNode.setTexture(tex, 1)
def __init__(self):
self.d_objects = {}
self.client = None
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
#base.win.setWidth(800)
props = WindowProperties( )
props.setTitle( 'Panda3D/Node.js Networking Experiment' )
base.win.requestProperties( props )
# Post the instructions
self.title = addTitle("Roaming Ralph goes Networking")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
self.inst8 = addInstructions(0.55, "Current connection lag:")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
# PlayerStartPos = self.environ.find("**/start_point").getPos()
# print "start pos:", PlayerStartPos
self.player = None
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# ----------------------------------------------------------------------
# new: create DynObject to "host" a Ralph model for our player avatar
# Accept the control keys for movement and rotation
self.accept("escape", self.exitGame)
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
# taskMgr.add(self.moveCamera,"CameraMoveTask")
taskMgr.add(self.moveObjects,"ObjectsMoveTask")
# Game state variables
self.isMoving = False
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.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)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
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 __init__(self):
ShowBase.__init__(self)
# enable physics engine
self.enableParticles()
# take care of cursor shit
self.resetCursor()
# set up loading screen
self.loadingText = OnscreenText("Loading...",
1,
fg=(1, 1, 1, 1),
pos=(0, 0),
align=TextNode.ACenter,
scale=.07,
mayChange=1)
self.graphicsEngine.renderFrame(
) #render a frame otherwise the screen will remain black
self.graphicsEngine.renderFrame() #idem dito
self.graphicsEngine.renderFrame(
) #you need to do this because you didn't yet call run()
self.graphicsEngine.renderFrame(
) #run() automatically renders the frames for you
# get menu background music playing
self.loadingText.setText('Loading models/audio/sfx/menu_music.ogg')
self.graphicsEngine.renderFrame(
) #render a frame otherwise the screen will remain black
self.graphicsEngine.renderFrame() #idem dito
self.graphicsEngine.renderFrame(
) #you need to do this because you didn't yet call run()
self.graphicsEngine.renderFrame(
) #run() automatically renders the frames for you
menuMusic = self.loader.loadSfx("models/audio/sfx/menu_music.ogg")
menuMusic.setLoop(True)
menuMusic.play()
# set title window
props = WindowProperties()
props.setTitle('Tokoyo Ghoul')
self.win.requestProperties(props)
# Load the environment model.
self.loadingText.setText('Loading models/environment.egg.pz')
self.setBackgroundColor((0, 1, 1, .5))
self.graphicsEngine.renderFrame(
) #render a frame otherwise the screen will remain black
self.graphicsEngine.renderFrame() #idem dito
self.graphicsEngine.renderFrame(
) #you need to do this because you didn't yet call run()
self.graphicsEngine.renderFrame(
) #run() automatically renders the frames for you
self.scene = self.loader.loadModel("models/output.bam")
# Reparent the model to render.
self.scene.reparentTo(self.render)
# Apply scale and position transforms on the model.
self.scene.setScale(0.15, 0.15, 0.15)
self.scene.setPos(0, 0, 0)
# Add the spinCameraTask procedure to the task manager.
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# add fog and such
#myFog = Fog("titlefog")
#myFog.setColor((1,0,0,0.1))
#myFog.setExpDensity(0.3)
#self.render.setFog(myFog)
# Load and transform the didicus actor.
#self.pandaActor = Actor("models/camera",
#{"walk": "models/panda-walk4"})
self.loadingText.setText('Loading models/african.x')
self.graphicsEngine.renderFrame(
) #render a frame otherwise the screen will remain black
self.graphicsEngine.renderFrame() #idem dito
self.graphicsEngine.renderFrame(
) #you need to do this because you didn't yet call run()
self.graphicsEngine.renderFrame(
) #run() automatically renders the frames for you
self.pandaActor = Actor("models/camera")
self.pandaActor.setPos(10, -10, 5)
self.pandaActor.setScale(0.5, 0.5, 0.5)
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(13,
Point3(-10, -10, 5),
startPos=Point3(
0, 0, 5))
pandaPosInterval2 = self.pandaActor.posInterval(13,
Point3(0, 0, 5),
startPos=Point3(
-10, -10, 5))
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()
# Make the menu options
# Create a frame
self.startgamebutton = DirectButton(pos=(1, 0, -0.6),
text=("Play"),
scale=.1,
command=self.startGame)
self.exitbutton = DirectButton(pos=(1, 0, -0.74),
text=("Exit"),
scale=.1,
command=self.close)
# load the title image
self.loadingText.setText('Loading images/title.png')
self.graphicsEngine.renderFrame(
) #render a frame otherwise the screen will remain black
self.graphicsEngine.renderFrame() #idem dito
self.graphicsEngine.renderFrame(
) #you need to do this because you didn't yet call run()
self.graphicsEngine.renderFrame(
) #run() automatically renders the frames for you
# clean up loading screen
self.loadingText.cleanup()
def __init__(self):
ShowBase.__init__(self)
winProps = WindowProperties()
winProps.setTitle("Triangle and SimpleCircle Unittest")
# base.win.requestProperties(winProps) (same as below e.g. self == base)
self.win.requestProperties(winProps)
zUp = Vec3(0.0, 0.0, 1.0)
wt = Vec4(1.0, 1.0, 1.0, 1.0)
def addToVertex(x, y, z):
normal.addData3f(zUp)
color.addData4f(wt)
# BLOG post about these bullet points then delete them
# 1) create GeomVertexData (inside the triangulator's constructor)
frmt = GeomVertexFormat.getV3n3cp()
triangulator = ConstrainedDelaunayTriangulator(vertexFormat = frmt, onVertexCreationCallback = addToVertex)
vdata = triangulator.getGeomVertexData()
# 2) create Writers/Rewriters (must all be created before any readers and readers are one-pass-temporary)
normal = GeomVertexRewriter(vdata, 'normal') # DOC 'vertex' is the only prohibited column for the user to use
color = GeomVertexRewriter(vdata, 'color')
# 3) write each column on the vertex data object (for speed, have a different writer for each column)
# DOC 1.DT) create triangulator
# DOC 2.DT) add vertices (before calling triangulate)
# ############# NOT ANGLE OPTIMAL BELOW #####################
# triangulator.addVertexToPolygon(5.0, 0.0, 0.0)
# triangulator.addVertexToPolygon(0.0, 0.0, 0.0)
# triangulator.addVertexToPolygon(1.5, 2.5, 0.0)
# triangulator.addVertexToPolygon(0.0, 5.0, 0.0)
# triangulator.addVertexToPolygon(5.0, 5.0, 0.0)
# ############# NOT ANGLE OPTIMAL ABOVE #####################
triangulator.addVertexToPolygon(5.0, 0.0, 0.0)
triangulator.addVertexToPolygon(6.5, 6.5, 0.0)
# triangulator.addVertexToPolygon(1.5, 2.5, 0.0)
triangulator.addVertexToPolygon(0.0, 0.0, 0.0)
triangulator.addVertexToPolygon(0.0, 5.0, 0.0)
triangulator.addVertexToPolygon(5.0, 5.0, 0.0)
# DOC 3.DT) add hole vertices (before calling triangulate)
# DOC 4.DT) call triangulate
triangulator.triangulate(makeDelaunay=True)
# ######################## REMOVE ###################################
# ######################## REMOVE ###################################
assert triangulator.isTriangulated()
adjLst = triangulator.getAdjacencyList()
foundInvalidReference = []
foundMissingReference = [] # so I can explicitly state all index references are correct
for t in adjLst:
# check that references with no neighbor haven't missed an edge
noneEdges = []
if t._neighbor0 is None:
noneEdges.append(t.edgeIndices0)
elif t._neighbor1 is None:
noneEdges.append(t.edgeIndices1)
elif t._neighbor2 is None:
noneEdges.append(t.edgeIndices2)
for tri_ in adjLst:
for edge_ in noneEdges:
# the edge that should hold the reference is on t. The one that should get referenced is on tri_
missedCount = 0
if edge_[0] in tri_.edgeIndices0 and edge_[1] in tri_.edgeIndices0 and tri_ != t:
missedCount += 1
if edge_[0] in tri_.edgeIndices1 and edge_[1] in tri_.edgeIndices1 and tri_ != t:
missedCount += 1
if edge_[0] in tri_.edgeIndices2 and edge_[1] in tri_.edgeIndices2 and tri_ != t:
missedCount += 1
if missedCount == 1:
foundMissingReference.extend((t, tri_))
notify.warning(
"!MISSED REFERENCE TO NEIGHBOR\nreferrer: {} ptIndices: {} neighbors: {}\n".format(
t.index, t.getPointIndices(), t.getNeighbors(),
) + "missed: {} ptIndices: {} neighbors: {}".format(
tri_.index, tri_.getPointIndices(), tri_.getNeighbors(),
))
elif missedCount > 1:
foundMissingReference.extend((t, tri_))
notify.warning(
"!EXTRANEOUS & MISSED SHARED EDGES\nreferrer: {} ptIndices: {} neighbors: {}\n".format(
t.index, t.getPointIndices(), t.getNeighbors(),
) + "missed: {} ptIndices: {} neighbors: {}".format(
tri_.index, tri_.getPointIndices(), tri_.getNeighbors(),
))
# check that neighbor relations point to correct triangles
for n in t.getNeighbors(includeEmpties=False):
neighbor = adjLst[n]
otherInds = neighbor.getPointIndices()
if neighbor.index == t._neighbor0:
edge = t.edgeIndices0
elif neighbor.index == t._neighbor1:
edge = t.edgeIndices1
elif neighbor.index == t._neighbor2:
edge = t.edgeIndices2
if edge[0] not in otherInds and edge[1] not in otherInds:
foundInvalidReference.extend((t, neighbor))
notify.warning(
"!INVALID REFERENCE TO NEIGHBOR\nreferrer: {} indices: {} neighbors: {}".format(
t.index, t.getPointIndices(), t.getNeighbors(),
) + "\nreferee: {} indices: {} neighbors: {}".format(
neighbor.index, neighbor.getPointIndices(), neighbor.getNeighbors()
))
if not foundMissingReference:
notify.warning("No error missing reference in neighbors.")
else:
notify.warning("!!!ERROR missing reference in neighbor references.")
if not foundInvalidReference:
notify.warning("No error found in neighbors that were referenced.")
else:
notify.warning("!!!ERROR found in neighbors that were referenced.")
foundPointInsideCircle = False
trianglesWithInvalidPoint = set()
for t in adjLst:
circle_ = t.getCircumcircle()
# cycle through triangles checking each point against each circle.center
for e in adjLst:
p0, p1, p2 = e.getPoints()
if circle_.radius - (p0 - circle_.center).length() > EPSILON:
foundPointInsideCircle = True
notify.warning(
"!point in circumcircle point {0} circle {1}\ntriangle1: {2}\ntriangle2: {3}".format(
p0, circle_, t, e
))
trianglesWithInvalidPoint |= set((t.index, ))
if circle_.radius - (p1 - circle_.center).length() > EPSILON:
foundPointInsideCircle = True
notify.warning(
"!point in circumcircle point {0} circle {1}\ntriangle1: {2}\ntriangle2: {3}".format(
p1, circle_, t, e
))
trianglesWithInvalidPoint |= set((t.index, ))
if circle_.radius - (p2 - circle_.center).length() > EPSILON:
foundPointInsideCircle = True
notify.warning(
"!point in circumcircle point {0} circle {1}\ntriangle1: {2}\ntriangle2: {3}".format(
p2, circle_, t, e
))
trianglesWithInvalidPoint |= set((t.index, ))
if not foundPointInsideCircle:
notify.warning("No point found inside circumcircle.")
else:
notify.warning("!!!ERROR found point inside circumcircle. Triangles: {}".format(trianglesWithInvalidPoint))
# TODO test edges that reference no neighbor
# triangles = triangulator.getGeomTriangles()
# print "Triangulated:"
# for tri in triangleList:
# print "\t{0}".format(tri)
# 4) create a primitive and add the vertices via index (not truly associated with the actual vertex table, yet)
# tris = GeomTriangles(Geom.UHDynamic)
# t1 = Triangle(0, 1, 2, vdata, tris, vertex)
# t2 = Triangle(2, 1, 3, vdata, tris, vertex)
# c1 = t1.getCircumcircle()
# t1AsEnum = t1.asPointsEnum()
# r0 = (t1AsEnum.point0 - c1.center).length()
# r1 = (t1AsEnum.point1 - c1.center).length()
# r2 = (t1AsEnum.point2 - c1.center).length()
# assert abs(r0 - r2) < utilities.EPSILON and abs(r0 - r1) < utilities.EPSILON
# t2AsEnum = t2.asPointsEnum()
# c2 = t2.getCircumcircle()
# r0 = (t2AsEnum.point0 - c2.center).length()
# r1 = (t2AsEnum.point1 - c2.center).length()
# r2 = (t2AsEnum.point2 - c2.center).length()
# assert abs(r0 - r2) < utilities.EPSILON and abs(r0 - r1) < utilities.EPSILON
# assert t1.getAngleDeg0() == 90.0
# assert t1.getAngleDeg1() == t1.getAngleDeg2()
#
# oldInd0 = t1.pointIndex0
# oldInd1 = t1.pointIndex1
# oldInd2 = t1.pointIndex2
# t1.pointIndex0 = t1.pointIndex1
# t1.pointIndex1 = oldInd0
# assert t1.pointIndex0 == oldInd1
# assert t1.pointIndex1 == oldInd0
# assert t1.pointIndex0 != t1.pointIndex1
# t1.reverse()
# assert t1.pointIndex1 == oldInd2
#
gn = triangulator.getGeomNode('triangles')
gnNodePath = render.attachNewNode(gn)
# setup a wire frame
wireNP = render.attachNewNode('wire')
wireNP.setPos(0.0, 0.0, .1)
wireNP.setColor(0.1, 0.1, 0.1, 1)
wireNP.setRenderMode(RenderModeAttrib.MWireframe, .5, 0)
gnNodePath.instanceTo(wireNP)
#
# # test and draw intersections and circles
# pt1 = Point3(0.0, 5.0, 0.0)
# pt2 = Point3(1.0, 5.0, 0.0)
# intersection = t2.getIntersectionsWithCircumcircle(pt1, pt2)
# circle = t2.getCircumcircle()
# cuts = 128
# border = circle.getBorder(cuts, closed=True)
# assert len(border) == cuts or (len(border) == cuts + 1 and border[0] == border[len(border) - 1])
# n = len(border)
# xMid = yMid = 0
# for p in border:
# xMid += p.x
# yMid += p.y
# mid = Point3(xMid / n, yMid / n, border[0].z)
# assert mid.almostEqual(circle.center, 0.06)
# assert t2.isLeftWinding()
# assert t1.containsPoint(c1.center) != t1.containsPoint(c1.center, includeEdges=False)
#
# circleSegs = LineSegs("circleLines")
# circleSegs.setColor(1.0, 0.0, 0.0, 1.0)
# for p in border:
# circleSegs.drawTo(*p)
# circleNode = circleSegs.create(False)
# circleNP = render.attachNewNode(circleNode)
# circleNP.setZ(-5)
#
# originSpot = LineSegs("intersection")
# originSpot.setColor(1.0, 0.0, 0.0, 1.0)
# originSpot.setThickness(10)
# for p in intersection:
# originSpot.drawTo(p)
# spotNode = originSpot.create(False)
# spotNP = render.attachNewNode(spotNode)
# circleNP.setZ(-0.75)
# fix the camera rot/pos
PHF.PanditorDisableMouseFunc()
camera.setPos(0.0, 0.0, 50.0)
camera.lookAt(Point3(0.0)) # 2.5, 2.5, 0.0))
PHF.PanditorEnableMouseFunc()
# print "isLeftWinding()", triangulator.isLeftWinding()
# TODO port the triangle-indices node func drawTriangleIndices(...)
indsNp = ConstrainedDelaunayTriangulator.drawTriangleIndices(triangulator.getTriangleList())
indsNp.setPos(0.0, 0.0, 0.3)
def __init__(self, shown, t0, initTime, leafDroop, lankiness, plant_health):
loadPrcFileData('', 'win-size 1024 768')
loadPrcFileData("", "window-type none")
ShowBase.__init__(self)
if shown:
self.openMainWindow(type = "onscreen")
props = WindowProperties()
props.setTitle('TerraBot Simulator')
self.win.requestProperties(props)
else:
self.openMainWindow(type = "offscreen")
base.disableMouse() # Allow manual positioning of the camera
#camera.setPosHpr(-20, 0, -3, -90, 12, 0) # Under
camera.setPosHpr(-20, 0, 7, -90, -12, 0) # Normal
#camera.setPosHpr(0, 0, 30, 0, -90, 0) #TOP
self.pic = False
self.loc = None
self.shown = shown
self.start_time = t0;
atexit.register(self.userExit)
self.BASE_TEXT = '''
Pump: OFF
Fans: OFF
LEDs: 255
'''
self.BASE_TEXT2 = \
'''
Time : {:s}
Light level: 0
Temperature : 20 C
Soil moisture : 0
Humidity : 50%
Volume : 3000 ml
Speedup : 1x
'''.format(clock_time(t0 + initTime))
self.lastTime = initTime
self.droop = leafDroop
self.lankiness = lankiness
self.plant_health = plant_health
#self.accept('escape', self.userExit)
self.accept('r', self.resetCam)
self.loadModels()
self.setupLights()
self.setupText()
self.setupText2()
self.setupSensorCam()
self.setTankWater(0)
self.setBackgroundColor(.8, .8, .8, 1)
self.keys = {}
for key in ['arrow_left', 'arrow_right', 'arrow_up', 'arrow_down',
'a', 'd', 'w', 's']:
self.keys[key] = 0
self.accept(key, self.push_key, [key, 1])
self.accept('shift-%s' % key, self.push_key, [key, 1])
self.accept('%s-up' % key, self.push_key, [key, 0])
self.fanonSound = loader.loadSfx('sounds/fanon.wav')
self.pumponSound = loader.loadSfx('sounds/pumpon.wav')
self.fanonSound.setLoop(True)
self.pumponSound.setLoop(True)
#SetupCamera
self.heading = -90.0
self.pitch = -12.0
self.camera.setPos(-20, 0, 7)
self.picNextFrame = False
self.taskMgr.add(self.update, 'main loop')
def __init__(self):
""" Initializes the Simulator object """
props = WindowProperties( )
props.setTitle( 'IsisWorld v0.3' )
base.win.requestProperties( props )
# initialize GUI components
self.title = OnscreenText(text="IsisWorld",
style=1, fg=(0,1,1,1), font = self.font,
pos=(0.85,0.95,1), scale = .07)
self.escapeEventText = self.genLabelText("ESC: quit", 0)
self.instuctText_3 = self.genLabelText("a,s: Rotate world camera", 1)
self.pauseEventText = self.genLabelText("p: (un)pause; SPACE advances simulator one time step.",2)
self.instuctText_1 = self.genLabelText("up,down,left,right: to control Ralph's direction", 3)
self.instuctText_2 = self.genLabelText("h,j,k,l: to control Ralph's head orientation", 4)
self.objectText = self.genLabelText("o: display objects in Ralph's visual field", 5)
self.teacher_utterances = [] # last message typed
# main dialogue box
def disable_keys(x):
# print "disabling"
x.command_box.enterText("")
x.command_box.suppressKeys=True
x.command_box["frameColor"]=(0.631, 0.219, 0.247,1)
def enable_keys(x):
# print "enabling"
x.command_box["frameColor"]=(0.631, 0.219, 0.247,.25)
x.command_box.suppressKeys=False
def accept_message(message,x):
x.teacher_utterances.append(message)
x.command_box.enterText("")
#text_fg=((.094,0.137,0.0039,1),
self.command_box = DirectEntry(pos=(-1.2,-0.95,-0.95), text_fg=(0.282, 0.725, 0.850,1), frameColor=(0.631, 0.219, 0.247,0.25), suppressKeys=1, initialText="enter text and hit return", enableEdit=0,scale=0.07, focus=0, focusInCommand=disable_keys, focusOutCommand=enable_keys, focusInExtraArgs=[self], focusOutExtraArgs=[self], command=accept_message, extraArgs=[self], entryFont=self.font, width=15, numLines=1)
#base.win.setColor(0.5,0.8,0.8)
base.win.setClearColor(Vec4(0,0,0,1))
self.initialize_simulator_relax_thread_task()
# setup terrain
self.env = loader.loadModel("models/world/world")
self.env.reparentTo(render)
self.env.setPos(0,0,0)
self.env.setCollideMask(BitMask32.bit(1))
self.env.setColor(0.5,0.8,0.8)
render.showBounds()
#self.goal_sleep = Bar(100,1)
#self.goal_sleep.reparentTo(render)
dlight = DirectionalLight('dlight')
dlight.setColor(VBase4(0.6, 0.6, 0.6, 1))
dlnp = render.attachNewNode(dlight)
dlnp.setHpr(-60, -60, 0)
render.setLight(dlnp)
alight = AmbientLight('alight')
alight.setColor(VBase4(1.0, 1.0, 1.0, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
self.agent = Character(self, "models/ralph/ralph", {"walk":"models/ralph/ralph-walk", "run": "models/ralph/ralph-run"}, VBase3(6, 2, 0), .2)
self.agent.control__say("Hi, I'm Ralph. Please build me.")
### Set up displays and cameras ###
self.camera = FloatingCamera(self.agent.actor)
# set up picture in picture
dr = base.camNode.getDisplayRegion(0)
aspect_ratio = 16.0 / 9.0
window = dr.getWindow()
pip_size = 0.40 # percentage of width of screen
dr_pip = window.makeDisplayRegion(1-pip_size,1,0,(1.0 / aspect_ratio) * float(dr.getPixelWidth())/float(dr.getPixelHeight()) * pip_size)
dr_pip.setCamera(self.agent.fov)
dr_pip.setSort(dr.getSort())
dr_pip.setClearColor(VBase4(0, 0, 0, 1))
dr_pip.setClearColorActive(True)
dr_pip.setClearDepthActive(True)
#self.agent.fov.node().getLens().setAspectRatio(aspect_ratio)
dr_pip.setActive(1)
## SET UP I/O ##
base.disableMouse()
# Accept some keys to move the camera.
self.accept("a-up", self.camera.setControl, ["right", 0])
self.accept("a", self.camera.setControl, ["right", 1])
self.accept("s-up", self.camera.setControl, ["left", 0])
self.accept("s", self.camera.setControl, ["left", 1])
# control keys to move the character
self.accept("arrow_left", self.agent.control__turn_left__start, [])
self.accept("arrow_left-up", self.agent.control__turn_left__stop, [])
self.accept("arrow_right", self.agent.control__turn_right__start, [])
self.accept("arrow_right-up", self.agent.control__turn_right__stop, [])
self.accept("arrow_up", self.agent.control__move_forward__start, [])
self.accept("arrow_up-up", self.agent.control__move_forward__stop, [])
self.accept("arrow_down", self.agent.control__move_backward__start, [])
self.accept("arrow_down-up", self.agent.control__move_backward__stop, [])
# head movement controls (vi direction map)
self.accept("k", self.agent.control__look_up__start, [])
self.accept("k-up", self.agent.control__look_up__stop, [])
self.accept("j", self.agent.control__look_down__start, [])
self.accept("j-up", self.agent.control__look_down__stop, [])
self.accept("h", self.agent.control__look_left__start, [])
self.accept("h-up", self.agent.control__look_left__stop, [])
self.accept("l", self.agent.control__look_right__start, [])
self.accept("l-up", self.agent.control__look_right__stop, [])
# key input
self.accept("escape", self.user_requests_quit)
self.accept("space", self.step_simulation, [.1]) # argument is amount of second to advance
self.accept("o", self.print_objects) # displays objects in field of view
self.accept("p", self.toggle_paused)
self.accept("r", self.reset_simulation)
taskMgr.add(self.move,"moveTask") # Note: deriving classes DO NOT need
# xmlrpc server command handler
xmlrpc_command_handler = Command_Handler(self)
# xmlrpc server
self.server_object = HomeSim_XMLRPC_Server()
self.server = self.server_object.server
self.server.register_function(xmlrpc_command_handler.command_handler,'do')
self.server_thread = Thread(group=None, target=self.server.serve_forever, name='xmlrpc')
self.server_thread.start()
self.reset_simulation()
class graphica :
elements = None #drawing elements
map_zoom = 1
map_pos = (0, 0)
width = 0
height = 0
title_update_time = 0.5
p3d = None #Panda Engine
flat = None #floor of the world
screen = None #screen surface
def __init__(self, params, pipe, dir):
self.game_directory = dir
self.game_pipe = pipe
self.gs_window = ConfigVariableString('win-size')
self.gs_window.setValue(str(params.get('width', 800)) +' '+str(params.get('height', 600)))
self.gs_multi = ConfigVariableBool('framebuffer-multisample')
self.gs_multi.setValue(params.get('multisample', 1))
self.gs_sync = ConfigVariableBool('sync-video', str(params.get('sync', 1)))
self.gs_sync.setValue(params.get('sync', 1))
loadPrcFileData('', 'win-size '+ str(params.get('width', 800)) +' '+str(params.get('height', 600)))
loadPrcFileData('', 'win-fixed-size 1')
loadPrcFileData('', 'text-default-font data/HanZi.ttf')
loadPrcFileData('', 'multisamples ' + str(params.get('samples', 0)))
#loadPrcFileData('', 'fullscreen 1')
#loadPrcFileData('', 'textures-power-2 pad')
#loadPrcFileData('', 'notify-level spam')
#loadPrcFileData('', 'default-directnotify-level spam')
#loadPrcFileData('', 'notify-output I:\\Users\\User\\My Documents\\Aptana Studio 3 Workspace\\sg\\out2.txt')
#nout = MultiplexStream()
#Notify.ptr().setOstreamPtr(nout, 0)
#nout.addFile(Filename("out.txt"))
'''for i in xrange(ConfigVariableManager.getGlobalPtr().getNumVariables()):
if ConfigVariableManager.getGlobalPtr().isVariableUsed(i) :
name = ConfigVariableManager.getGlobalPtr().getVariableName(i)
v = ConfigVariable(name)
'''
self.p3d = ShowBase.ShowBase()
self.p3d.buttonThrowers[0].node().setButtonDownEvent('buttonDown')
self.p3d.buttonThrowers[0].node().setButtonRepeatEvent('buttonRep')
self.p3d.buttonThrowers[0].node().setButtonUpEvent('buttonUp')
self.p3d.accept('buttonDown', self.keyboard, [0,])
self.p3d.accept('buttonRep', self.keyboard, [2,])
self.p3d.accept('buttonUp', self.keyboard, [1,])
self.p3d.disableMouse() #Disable default mouse-based camera control
self.screen = render2d.attachNewNode("Screen Coord Node")
self.screen.setBin("fixed", 100)
self.flat = render.attachNewNode("2d Objects in 3d world")
self.flat.setBin('background', 0)
self.flat.setDepthTest(False)
self.flat.setDepthWrite(False)
render.setAntialias(AntialiasAttrib.MAuto)
self.props = WindowProperties(self.p3d.win.getProperties())
#Screen size
self.width = params['width']
self.height = params['height']
self.aratio = float(self.width)/self.height #aspect ratio
self.p3d.camera.setZ(1000)
self.p3d.camera.lookAt(0,0,0)
self.p3d.camLens.setFov(80)
#self.props.setSize(size[0],size[1])
self.screen.setScale(2.0/self.width,1,2.0/self.height)
self.dt = 0.0
self.fps = 0
self.title_last_update_time = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0))
self.elements = {}
#self.MModel = self.create_model_xt((0,0,0), 'models\\chinesegfx_city_1_1.x', 'models\\houses_chinesegfx.tga', (3,3))[1]
#self.MModel.reparentTo(hidden)
#sys.stdout.flush()
#self.p3d.taskMgr.run()
#self.myShader = Shader.load(Shader.SLGLSL, "modules\\myvertexshader.glsl", "modules\\myfragmentshader.glsl")
#self.plane2.setShader(self.myShader)
self.mouse_pos = (0, 0)
self.mouse_on_map_pos = (0, 0)
self.p3d.accept('wheel_up',self.zoom_in)
self.p3d.accept('wheel_down',self.zoom_out)
self.p3d.accept('mouse1',self.mouse_click_left)
self.p3d.accept('mouse3',self.mouse_click_right)
self.parents = {}
self.gui_surface = aspect2d.attachNewNode("GUI Node")
self.gui_surface.setScale(2.0/self.height,1,2.0/self.height)
self.gui_surface.setBin("fixed", 50)
self.map_node = self.add_node('map_node', 'background', 0, self.flat)
self.paths_node = self.add_node('paths_node', 'background', 3, self.flat)
self.paths_all_node = self.add_node('paths_all_node', 'background', 3, self.flat)
self.map_mode_node = self.add_node('map_mode_node', 'background', 1, self.map_node)
self.selecties_node = self.add_node('selecties_node', 'background', 2, self.map_node)
self.parents['render'] = render
self.parents['gui_surface'] = self.gui_surface
self.elements['city_map_model'] = self.create_model_xt(fname = 'models\\chinesegfx_city_1_1.x', texname = 'models\\houses_chinesegfx.tga', size = (3, 3), name = 'city_map_model')
self.minimap = Minimap(self.width, self.height, self)
def add_node(self, name, mode1, mode2, parent = None):
node = None
if parent == None :
node = render.attachNewNode(name)
else :
node = parent.attachNewNode(name)
if (mode1 <> None) and (mode2 <> None ): node.setBin(mode1, mode2)
self.parents[name] = node
self.elements[name] = node
return node
def get_parent(self, p):
if p in self.parents :
return self.parents[p]
elif p in self.elements :
return self.elements[p]
else :
return render
def gr_loop(self):
self.mouse_control()
self.frame()
def Start(self):
print 'Starting graphic loop'
sys.stdout.flush()
while(1):
#считывает отправленные данные
start_time = globalClock.getRealTime()
try:
while self.game_pipe.poll(False) and ((globalClock.getRealTime() - start_time) < 0.5) :
m = self.game_pipe.recv()
try:
if m[0] == 'setitem' :
if m[1]['key'] == 'pos' : self.elements[m[1]['name']].setPos(m[1]['value'])
elif m[1]['key'] == 'image' :
self.elements[m[1]['name']]['image'] = textures.get(m[1]['value'], None)
elif m[1]['key'] == 'scale' : self.elements[m[1]['name']].setScale(m[1]['value'])
else : self.elements[m[1]['name']][m[1]['key']] = m[1]['value']
elif m[0] == 'set_map_pos' : self.set_map_pos(m[1][0], m[1][1])
elif m[0] == 'set_map_zoom' : self.set_map_zoom(m[1])
elif m[0] == 'draw_image2d' : self.draw_image2d(**m[1])
elif m[0] == 'draw_image' : self.draw_image(**m[1])
elif m[0] == 'draw_line' :
self.draw_line(**m[1])
#continue
elif m[0] == 'draw_line2d' :
self.draw_line2d(**m[1])
elif m[0] == 'draw_circle' : self.draw_circle(**m[1])
elif m[0] == 'draw_triangles' : self.draw_triangles(**m[1])
elif m[0] == 'delete_el_mask' : self.delete_el_mask(m[1])
elif m[0] == 'delete_el' : self.delete_el(m[1])
elif m[0] == 'gui_hide' :
self.elements[m[1]].hide()
elif m[0] == 'gui_show' :
self.elements[m[1]].show()
elif m[0] == 'gui_removeAndDestroyAllItems' :
self.elements[m[1]].removeAndDestroyAllItems()
elif m[0] == 'reparentTo' :
self.elements[m[1]].reparentTo( self.elements[m[2]] )
elif m[0] == 'setTexture' :
self.elements[m[1]].setTexture(textures[m[2]])
elif m[0] == 'setPos' :
self.elements[m[1]].setPos(m[2][0], m[2][1], m[2][2])
elif m[0] == 'setHpr' :
self.elements[m[1]].setHpr(m[2][0], m[2][1], m[2][2])
elif m[0] == 'instanceTo' :
self.elements[m[2]] = render.attachNewNode('Placeholder')
self.elements[m[1]].instanceTo(self.elements[m[2]])
elif m[0] == 'resetFrameSize' :
self.elements[m[1]].resetFrameSize()
elif m[0] == 'setTransparency' :
self.elements[m[1]].setTransparency(TransparencyAttrib.MAlpha)
elif m[0] == 'RemoveGuiElement' :
try:
self.elements[m[1]].destroy()
except:
self.elements[m[1]].removeNode()
elif m[0] == 'removeNode' :
self.elements[m[1]].removeNode()
elif m[0] == 'removeAllChildren' :
self.elements[m[1]].node().removeAllChildren()
elif m[0] == 'gui_addItem' :
self.elements[m[1]].addItem(self.elements[m[2]])
elif m[0] == 'DirectLabel' :
params = dict(m[1])
params['parent'] = self.get_parent(params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectLabel(**params)
elif m[0] == 'DirectButton' :
params = dict(m[1])
params['parent'] = self.get_parent(params.get('parent', 'render') )
params['command'] = self.GUI_pressed
params['extraArgs'] = (m[2]['name'],)
self.elements[m[2]['name']] = DirectButton(**params)
elif m[0] == 'DirectFrame' :
params = dict(m[1])
params['parent'] = self.get_parent( params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectFrame(**params)
elif m[0] == 'DirectScrolledList' :
params = dict(m[1])
params['parent'] = self.get_parent( params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectScrolledList(**params)
elif m[0] == 'DirectCheckButton' :
params = dict(m[1])
params['parent'] = self.get_parent( params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectCheckButton(**params)
elif m[0] == 'DirectWaitBar' :
params = dict(m[1])
params['parent'] = self.get_parent( params.get('parent', 'render') )
self.elements[m[2]['name']] = DirectWaitBar(**params)
elif m[0] == 'create_actor_egg' :
self.create_actor_egg(**m[1])
elif m[0] == 'anim_loop' :
if len(m) == 3 :
m = list(m)
m.append({})
self.elements[m[1]].loop(m[2], **m[3])
elif m[0] == 'image_data_new' :
t = PNMImage()
#print 'RECV', m[2]
sys.stdout.flush()
if t.read(StringStream(m[2])) :
pass
else :
raise ValueError()
sys.stdout.flush()
tex = Texture()
tex.load(t)
textures[m[1]] = tex
elif m[0] == 'create_minimap' :
im = PNMImage()
self.elements['phyz'].getTexture().store(im)
self.minimap.create_minimap(im, m[1], m[2])
self.draw_image2d(pos = (self.width/2 - 200, -self.height/2), texname = 'minimap_tex', name = 'minimap_image', parent = 'gui_surface' )
else :
print 'Unknown command:', m
sys.stdout.flush()
#print m
#sys.stdout.flush()
except:
print m
print 'error1', sys.exc_info()
sys.stdout.flush()
except:
print 'error2', sys.exc_info()
sys.stdout.flush()
try:
self.gr_loop()
except Exception:
print 'error3', sys.exc_info()
sys.stdout.flush()
try:
pass
#if not(self.game_queue.full()):
# self.game_queue.put(('mouse_pos', self.mouse_pos))
# self.game_queue.put(('mouse_on_map_pos', self.mouse_on_map_pos))
#else :
# print 'game full'
# sys.stdout.flush()
except:
print 'error4', sys.exc_info()
sys.stdout.flush()
sys.stdout.flush()
#time.sleep(0.01)
def GUI_pressed(self, name):
self.game_pipe.send(('gui_pressed',name))
def mouse_control(self):
if self.p3d.mouseWatcherNode.hasMouse():
mp = (self.p3d.mouseWatcherNode.getMouse()[0], 0, self.p3d.mouseWatcherNode.getMouse()[1])
self.mouse_pos[0] = self.screen.getRelativePoint(render2d, mp)[0]
self.mouse_pos[1] = self.screen.getRelativePoint(render2d, mp)[2]
self.ttt = globalClock.getRealTime()
mpos = self.p3d.mouseWatcherNode.getMouse()
tmp = self.scr_to_map(mpos)
self.mouse_on_map_pos[0] = tmp[0]
self.mouse_on_map_pos[1] = tmp[1]
X_ = self.p3d.camera.getX()
Y_ = self.p3d.camera.getY()
C = 0.5*self.dt
if self.mouse_pos[0] < self.width * -0.47 :
X_ -= self.p3d.camera.getZ()*C
self.minimap.update_pos()
if self.mouse_pos[0] > self.width * 0.47 :
X_ += self.p3d.camera.getZ()*C
self.minimap.update_pos()
if self.mouse_pos[1] < self.height * -0.47 :
Y_ -= self.p3d.camera.getZ()*C
self.minimap.update_pos()
if self.mouse_pos[1] > self.height * 0.47 :
Y_ += self.p3d.camera.getZ()*C
self.minimap.update_pos()
self.p3d.camera.setX( X_ )
self.p3d.camera.setY( Y_ )
def mouse_click_left(self):
self.game_pipe.send(('mouse_click_left',))
def mouse_click_right(self):
self.game_pipe.send(('mouse_click_right',))
def frame(self):
self.p3d.taskMgr.step()
self.dt = globalClock.getDt()
if globalClock.getRealTime() - self.title_last_update_time > self.title_update_time :
self.props = WindowProperties(self.p3d.win.getProperties())
self.title_last_update_time = globalClock.getRealTime()
self.fps = globalClock.getAverageFrameRate()
title = str(self.fps) + str(self.mouse_pos[:]) + str(self.mouse_on_map_pos[:])
self.props.setTitle(title)
self.p3d.win.requestProperties(self.props)
def draw_line(self, **kwargs):
ps = kwargs.get('points',[])
name = ''
if 'name' in kwargs.keys() :
name = kwargs['name']
if self.check_name(name) :
#print 'draw_line name duplicated', name
return None
else :
name = self.generate_name()
ls = LineSegs()
if 'width' in kwargs.keys() : ls.setThickness( kwargs['width'] )
if 'color' in kwargs.keys() : ls.setColor( (kwargs['color'][0], kwargs['color'][1], kwargs['color'][2], kwargs['color'][3]) )
for i in ps :
ls.drawTo(i[0], i[1], i[2])
node = ls.create()
np = NodePath(node)
if 'parent' in kwargs.keys() and kwargs['parent'] <> None :
self.get_parent(kwargs['parent']).attachNewNode(np.node())
else :
render.attachNewNode(np.node())
self.elements[ name ] = np
return name, np
def draw_line2d(self, **kwargs):
ps = None
if 'points' in kwargs.keys():
ps = kwargs['points']
else :
return None
name = ''
if 'name' in kwargs.keys() :
name = kwargs['name']
if self.check_name(name) :
#print 'draw_line name duplicated', name
return None
else :
name = self.generate_name()
ls = LineSegs()
if 'width' in kwargs.keys() : ls.setThickness( kwargs['width'] )
if 'color' in kwargs.keys() : ls.setColor( Vec4(kwargs['color'][0], kwargs['color'][1], kwargs['color'][2], kwargs['color'][3]) )
for i in ps :
ls.drawTo(i[0], 0, i[1])
node = ls.create()
np = NodePath(node)
if 'parent' in kwargs.keys() and kwargs['parent'] <> None :
self.get_parent(kwargs['parent']).attachNewNode(np.node())
else :
self.screen.attachNewNode(np.node())
self.elements[ name ] = np
return name, np
def draw_circle(self, **kw):#x, color, r, width, name, prec = 10, parent = None, hpr = None):
x = kw.get('pos',(0,0,0))
color = kw.get('color',(0,0,0,255))
r = kw.get('radius',5)
width = kw.get('width',1)
prec = kw.get('prec', 10)
parent = self.get_parent(kw.get('parent', None))
hpr = kw.get('hpr', None)
name = kw.get('name', self.generate_name())
if self.check_name(name) :
#print 'draw_circle name duplicated', name
return None
ls = LineSegs()
ls.setThickness( width )
ls.setColor( Vec4(float(color[0])/256,float(color[1])/256,float(color[2])/256,float(color[3])/256) )
for i in xrange(prec) :
angle = math.pi*i*2/prec
ls.drawTo(x[0] + math.sin(angle) * r, x[1] + math.cos(angle) * r,0)
ls.drawTo(x[0] + math.sin(math.pi*i*2/1) * r, x[1] + math.cos(math.pi*i*2/1) * r, 0)
node = ls.create()
np = NodePath(node)
if color[3] <> 255 : np.setTransparency(TransparencyAttrib.MAlpha)
if hpr <> None : np.setHpr(hpr[0],hpr[1],hpr[2])
if parent == None :
self.flat.attachNewNode(np.node())
else :
parent.attachNewNode(np.node())
self.elements[name] = np
def draw_circle2d(self, x, color, r, width, name, prec = 10, parent = None):
ls = LineSegs()
ls.setThickness( width )
ls.setColor( Vec4(float(color[0])/256,float(color[1])/256,float(color[2])/256,float(color[3])/256) )
for i in xrange(prec) :
angle = math.pi*i*2/prec
ls.drawTo(x[0] + math.sin(angle) * r, 0, x[1] + math.cos(angle) * r)
ls.drawTo(x[0] + math.sin(math.pi*i*2/1) * r, 0, x[1] + math.cos(math.pi*i*2/1) * r)
node = ls.create()
np = NodePath(node)
if parent == None :
self.screen.attachNewNode(np.node())
else :
parent.attachNewNode(np.node())
self.elements[name] = np
def draw_text(self,msg,x,rgba,size,font = 'HanZi.ttf', surface = None):
pass
def draw_image(self,pos = (0,0,0), fname = '', name = None, scale = (1,1), size = None, parent = None, image = None, **kw):
if name == None :
name = self.generate_name()
tex = Texture()
texname = kw.get('texname', None)
if texname <> None :
if texname in textures.keys() :
tex.load(textures[texname])
else :
tex = loader.loadTexture(texname)
else : return None, None
xframe = tex.getXSize()
if tex.getOrigFileXSize() <> 0 : xframe = tex.getOrigFileXSize()
yframe = tex.getYSize()
if tex.getOrigFileYSize() <> 0 : yframe = tex.getOrigFileYSize()
if size <> None :
scale = (float(scale[0]) * size[0]/tex.getOrigFileXSize(), float(scale[1]) * size[1]/tex.getOrigFileYSize() )
cm = CardMaker('card')
cm.setFrame(0,xframe*scale[0],0,yframe*scale[1])
card = None
if parent == None :
card = render.attachNewNode(cm.generate())
else :
card = self.get_parent(parent).attachNewNode(cm.generate())
card.setTexture(tex)
card.setPos(pos[0],pos[1],pos[2])
card.setHpr(0,-90,0)
self.elements[name] = card
return name, card
def draw_polygon(self,ps,color,name):
color = ( float(color[0])/255, float(color[1])/255, float(color[2])/255, float(color[3])/255)
vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
#cwriter = GeomVertexWriter(vdata, 'color')
trig = Triangulator()
for i in ps :
vi = trig.addVertex(i[0], i[1])
vwriter.addData3f(i[0], i[2], i[1])
#cwriter.addData4f(color[0], color[1], color[2], color[3])
trig.addPolygonVertex(vi)
trig.triangulate()
prim = GeomTriangles(Geom.UHStatic)
for i in range(trig.getNumTriangles()):
prim.addVertices(trig.getTriangleV0(i),
trig.getTriangleV1(i),
trig.getTriangleV2(i))
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
np.reparentTo(render)
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
def draw_tristrips(self, ps, color, name, parent = None):
vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
for i in ps :
vwriter.addData3f(i[0], i[1], i[0])
prim = GeomTristrips(Geom.UHStatic)
for i in range(len(ps)) :
prim.addVertex(i)
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
if parent == None :
render.attachNewNode(np.node())
else :
parent.attachNewNode(np.node())
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
def draw_triangles(self, points = None, color = None, name = None, parent = None):
vdata = GeomVertexData('trig', GeomVertexFormat.getV3c4(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
cwriter = GeomVertexWriter(vdata, 'color')
for i in points :
vwriter.addData3f(i[0], i[1], i[2])
cwriter.addData4f(color[0], color[1], color[2], color[3])
geom = Geom(vdata)
prim = GeomTriangles(Geom.UHStatic)
for i in range(len(points)) :
prim.addVertex(i)
prim.closePrimitive()
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
if parent == None :
render.attachNewNode(np.node())
else :
self.get_parent(parent).attachNewNode(np.node())
np.setTransparency(TransparencyAttrib.MAlpha)
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
return np
def draw_trianglefan(self, ps, color, name, parent = None):
vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
for i in ps :
vwriter.addData3f(i[0], i[1], i[2])
prim = GeomTrifans(Geom.UHStatic)
for i in range(len(ps)) :
prim.addVertex(i)
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
if parent == None :
render.attachNewNode(np.node())
else :
parent.attachNewNode(np.node())
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
def draw_polygon2d(self,ps,color,name):
vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
trig = Triangulator()
for i in ps :
vi = trig.addVertex(i[0], i[1])
vwriter.addData3f(i[0], 0, i[1])
trig.addPolygonVertex(vi)
trig.triangulate()
prim = GeomTriangles(Geom.UHStatic)
for i in range(trig.getNumTriangles()):
prim.addVertices(trig.getTriangleV0(i),
trig.getTriangleV1(i),
trig.getTriangleV2(i))
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
geomNode = GeomNode('trig')
geomNode.addGeom(geom)
np = NodePath(geomNode)
np.reparentTo(self.screen)
#fill=self.screen.attachNewNode(geomNode)
#fill.analyze()
self.elements[name] = np
def draw_image2d(self, **kw):
'''
tex = loader.loadTexture(texname)
vdata = GeomVertexData('trig', GeomVertexFormat.getV3t2(), Geom.UHStatic)
vwriter = GeomVertexWriter(vdata, 'vertex')
twriter = GeomVertexWriter(vdata, 'texcoord')
vwriter.addData3f(i[0], 0, i[1])
vwriter.addData3f(i[0], 0, i[1])
twriter.addData2f(0, 0)
twriter.addData2f(0, 1)
twriter.addData2f(1, 1)
twriter.addData2f(1, 0)
geom = Geom(vdata)
tris = GeomTristrips(Geom.UHStatic)
tris.addVertex(0)
tris.addVertex(1)
tris.addVertex(3)
tris.addVertex(2)
tris.closePrimitive()
geom.addPrimitive(tris)
node = GeomNode(name)
node.addGeom(geom)
np = self.screen.attachNewNode(node)
np.setTexture(tex)
np.getTexture().setMinfilter(Texture.FTLinearMipmapLinear)
self.elements[name] = node
'''
pos = kw.get('pos', (0, 0))
size = kw.get('size', None)
texname = kw.get('texname', None)
scaleX = kw.get('scaleX', 1)
scaleY = kw.get('scaleY', 1)
parent = self.get_parent( kw.get('parent', 'gui_surface') )
name = kw.get('name', self.generate_name())
tex = Texture()
if texname <> None :
if texname in textures.keys() :
tex = textures[texname]
else :
tex = loader.loadTexture(texname)
cm = CardMaker('card')
xframe = tex.getXSize()
if tex.getOrigFileXSize() <> 0 : xframe = tex.getOrigFileXSize()
yframe = tex.getYSize()
if tex.getOrigFileYSize() <> 0 : yframe = tex.getOrigFileYSize()
if size == None :
size = (tex.getXSize(), tex.getYSize())
cm.setFrame(0,size[0]*scaleX,0,size[1]*scaleY)
card = None
if parent == None :
card = self.screen.attachNewNode(cm.generate())
else :
card = parent.attachNewNode(cm.generate())
if texname <> None :
card.setTexture(tex)
card.setDepthTest(False)
card.setPos(pos[0],0,pos[1])
#card.setHpr(0,-90,0)
self.elements[name] = card
return card
def create_image2d(self, **kwargs):
pos = kwargs.get('pos', (0, 0))
size = kwargs.get('size', None)
texname = kwargs.get('texname', None)
UVmap = kwargs.get('UVmap', 0)
name = kwargs.get('name', self.generate_name())
rotate = 0
for i in kwargs.keys() :
if i == 'rotate' : rotate = kwargs['rotate']
cm = CardMaker('card')
tex = None
if texname <> None :
tex = loader.loadTexture(texname)
if size == None and texname <> None :
size = (tex.getOrigFileXSize(), tex.getOrigFileYSize())
cm.setFrame(-float(size[0])/2,float(size[0])/2,-float(size[1])/2,float(size[1])/2)
if tex <> None and UVmap :
fU, fV = 1, 1
if UVmap == 3 or UVmap == 1: fU = float(size[0])/tex.getOrigFileXSize()
if UVmap == 3 or UVmap == 2: fV = float(size[1])/tex.getOrigFileYSize()
cm.setUvRange((0, 0),(fU, fV))
card = NodePath(cm.generate())
if texname <> None :
card.setTexture(tex)
card.setDepthTest(False)
card.setPos(pos[0]+float(size[0])/2,0,pos[1]+float(size[1])/2)
card.setHpr(0,0,rotate)
card.setTransparency(TransparencyAttrib.MAlpha)
return card
def create_model_xt(self, **kw):#pos, model, texture, size, name = None):
pos = kw.get('pos', (0, 0, 0))
model = kw.get('fname', None)
texture = kw.get('texname', None)
size = kw.get('size', (1, 1))
name = kw.get('name', self.generate_name())
if self.check_name(name) :
#print 'create_model_xt name duplicated', name
return None
model = self.game_directory + Filename.fromOsSpecific('\\' + model).getFullpath()
a = loader.loadModel(model)
texture = self.game_directory + Filename.fromOsSpecific('\\' + texture).getFullpath()
a.setTexture(loader.loadTexture(texture))
a.reparentTo(render)
cmin, cmax = a.getTightBounds()
smax = 0
sx = size[0]/(cmax[0] - cmin[0])
sy = size[1]/(cmax[1] - cmin[1])
if sx > sy : smax = sx
else : smax = sy
a.setScale(smax)
shiftx = ( (cmax[0] + cmin[0])/2 ) * smax
shifty = ( (cmax[1] + cmin[1])/2 ) * smax
a.setPos(pos[0] - shiftx,pos[1] - shifty,pos[2])
#m.flattenLight()
#a.analyze()
if name == None : name = self.generate_name()
self.elements[name] = a
return a
def create_model_egg(self, pos, model, texture, size, name = None):
model = self.game_directory + Filename.fromOsSpecific('\\' + model).getFullpath()
a = loader.loadModel(model)
a.reparentTo(render)
cmin, cmax = a.getTightBounds()
smax = 0
sx = size[0]/(cmax[0] - cmin[0])
sy = size[1]/(cmax[1] - cmin[1])
if sx > sy : smax = sx
else : smax = sy
a.setScale(smax)
shiftx = ( (cmax[0] + cmin[0])/2 ) * smax
shifty = ( (cmax[1] + cmin[1])/2 ) * smax
a.setPos(pos[0] - shiftx,pos[1] - shifty,pos[2])
#m.flattenLight()
#a.analyze()
if name == None : name = self.generate_name()
self.elements[name] = a
print '!!!'
return name
def create_actor_egg(self, **kw):
model = self.game_directory + Filename.fromOsSpecific('\\' + kw['model']).getFullpath()
m = loader.loadModel(model)
a = Actor(m, kw['anims'])
a.reparentTo(render)
cmin, cmax = a.getTightBounds()
smax = 0
size = kw['size']
sx = size[0]/(cmax[0] - cmin[0])
sy = size[1]/(cmax[1] - cmin[1])
if sx > sy : smax = sx
else : smax = sy
a.setScale(smax)
shiftx = ( (cmax[0] + cmin[0])/2 ) * smax
shifty = ( (cmax[1] + cmin[1])/2 ) * smax
pos = kw['pos']
a.setPos(pos[0] - shiftx,pos[1] - shifty,pos[2])
#m.flattenLight()
#a.analyze()
name = kw.get('name', None)
if name == None : name = self.generate_name()
self.elements[name] = a
return name
def map_to_scr(self, a):
#print 'mts', self.map_pos, a, [ (a[0] - self.map_pos[0])*self.map_zoom, (a[1] - self.map_pos[1])*self.map_zoom ], self.width, self.height
return [ (a[0] - self.map_pos[0])*self.map_zoom, (a[1] - self.map_pos[1])*self.map_zoom ]
def scr_to_map(self, a):
#a is (-1,-1) to (1,1)
pos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
self.p3d.camLens.extrude(a, nearPoint, farPoint)
self.plane.intersectsLine(pos3d,
render.getRelativePoint(self.p3d.camera, nearPoint),
render.getRelativePoint(self.p3d.camera, farPoint))
return pos3d[0],pos3d[1]
def set_map_pos(self, posx, posy):
self.p3d.camera.setX(posx)
self.p3d.camera.setY(posy)
#self.gr.p3d.camera.lookAt(250,0,550)
self.map_pos = (posx, posy)
def set_map_zoom(self, zoom):
self.p3d.camera.setZ( zoom )
def zoom_in(self):
self.p3d.camera.setZ( self.p3d.camera.getZ()*0.9 )
self.minimap.update_pos(True)
if self.p3d.camera.getZ() < 200 :
self.paths_all_node.show()
def zoom_out(self):
self.p3d.camera.setZ( self.p3d.camera.getZ()*1.1 )
self.minimap.update_pos(True)
if self.p3d.camera.getZ() > 200 :
self.paths_all_node.hide()
def generate_name(self):
name = str(RANDINT(0,9))
while name in self.elements.keys() :
name += str(RANDINT(0,9))
return name
def delete_el(self, name):
if name in self.elements.keys() :
self.elements[name].removeNode()
self.elements.pop(name)
def delete_el_mask(self,mask):
for i in self.elements.keys() :
if mask in i :
self.delete_el(i)
def get_num_nodes_rec(self, a):
x = 0
l = len(a.getChildren())
if l == 0 :
return 1
else :
for c in a.getChildren() :
x += self.get_num_nodes_rec(c)
return x
def get_num_nodes(self):
a = self.get_num_nodes_rec(render)
b = self.get_num_nodes_rec(render2d)
c = self.get_num_nodes_rec(aspect2d)
print 'render', a, 'render2d', b, 'aspect2d', c
def check_name(self, name):
if name in self.elements.keys() : return True
else : return False
def keyboard(self, st, keyname):
if st == 0 : self.game_pipe.send(('key_down', keyname))
elif st == 1 : self.game_pipe.send(('key_up', keyname))
elif st == 2 : self.game_pipe.send(('key_rep', keyname))
def __init__(self):
ShowBase.__init__(self)
props = WindowProperties()
props.setTitle("Gesture Maze")
base.win.requestProperties(props)
self.tital = OnscreenText(text="Gesture Maze Control",
parent=base.a2dTopLeft,
align=TextNode.ALeft,
pos=(0.05, -0.08),
fg=(1, 1, 1, 1),
scale=0.06,
shadow=(0, 0, 0, 0.5))
self.accept("escape", sys.exit)
camera_num = 0
self.gesture_controler = gesture_control.GestureControler(0)
self.disableMouse()
camera.setPosHpr(0, 0, 25, 0, -90, 0)
self.maze = loader.loadModel("models/%s" % settings.maze_id)
self.maze.reparentTo(render)
self.walls = self.maze.find("**/wall_collide")
self.walls.node().setIntoCollideMask(BitMask32.bit(0))
# self.walls.show()
self.loseTriggers = []
for i in range(6):
trigger = self.maze.find("**/hole_collide" + str(i))
trigger.node().setIntoCollideMask(BitMask32.bit(0))
trigger.node().setName("loseTriggers")
self.loseTriggers.append(trigger)
# trigger.show()
self.mazeGround = self.maze.find("**/ground_collide")
self.mazeGround.node().setIntoCollideMask(BitMask32.bit(1))
self.ballRoot = render.attachNewNode("ballRoot")
self.ball = loader.loadModel("models/ball")
self.ball.reparentTo(self.ballRoot)
self.ballSphere = self.ball.find("**/ball")
self.ballSphere.node().setFromCollideMask(BitMask32.bit(0))
self.ballSphere.node().setIntoCollideMask(BitMask32.allOff())
self.ballGroundRay = CollisionRay()
self.ballGroundRay.setOrigin(0, 0, 10)
self.ballGroundRay.setDirection(0, 0, -1)
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)
# self.ballGroundColNp.show()
self.cTrav = CollisionTraverser()
self.cHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ballSphere, self.cHandler)
self.cTrav.addCollider(self.ballGroundColNp, self.cHandler)
# self.cTrav.showCollisions(render)
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(LVector3(0, 0, -1))
directionalLight.setColor((0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
self.ballRoot.setLight(render.attachNewNode(ambientLight))
self.ballRoot.setLight(render.attachNewNode(directionalLight))
m = Material()
m.setSpecular((1, 1, 1, 1))
m.setShininess(96)
self.ball.setMaterial(m, 1)
self.start()
class World(DirectObject):
def __init__(self):
self.last_mousex = 0
self.last_mousey = 0
self.zone = None
self.zone_reload_name = None
self.winprops = WindowProperties()
# simple console output
self.consoleNode = NodePath(PandaNode("console_root"))
self.consoleNode.reparentTo(aspect2d)
self.console_num_lines = 24
self.console_cur_line = -1
self.console_lines = []
for i in range(0, self.console_num_lines):
self.console_lines.append(
OnscreenText(
text="",
style=1,
fg=(1, 1, 1, 1),
pos=(-1.3, 0.4 - i * 0.05),
align=TextNode.ALeft,
scale=0.035,
parent=self.consoleNode,
)
)
# Configuration
self.consoleOut("zonewalk v.%s loading configuration" % VERSION)
self.configurator = Configurator(self)
cfg = self.configurator.config
resaveRes = False
if "xres" in cfg:
self.xres = int(cfg["xres"])
else:
self.xres = 1024
resaveRes = True
if "yres" in cfg:
self.yres = int(cfg["yres"])
else:
self.yres = 768
resaveRes = True
if resaveRes:
self.saveDefaultRes()
self.xres_half = self.xres / 2
self.yres_half = self.yres / 2
self.mouse_accum = MouseAccume(lambda: (self.xres_half, self.yres_half))
self.eyeHeight = 7.0
self.rSpeed = 80
self.flyMode = 1
# application window setup
base.win.setClearColor(Vec4(0, 0, 0, 1))
self.winprops.setTitle("zonewalk")
self.winprops.setSize(self.xres, self.yres)
base.win.requestProperties(self.winprops)
base.disableMouse()
# network test stuff
self.login_client = None
if "testnet" in cfg:
if cfg["testnet"] == "1":
self.doLogin()
# Post the instructions
self.title = addTitle("zonewalk v." + VERSION)
self.inst0 = addInstructions(0.95, "[FLYMODE][1]")
self.inst1 = addInstructions(-0.95, "Camera control with WSAD/mouselook. Press K for hotkey list, ESC to exit.")
self.inst2 = addInstructions(0.9, "Loc:")
self.inst3 = addInstructions(0.85, "Hdg:")
self.error_inst = addInstructions(0, "")
self.kh = []
self.campos = Point3(155.6, 41.2, 4.93)
base.camera.setPos(self.campos)
# Accept the application control keys: currently just esc to exit navgen
self.accept("escape", self.exitGame)
self.accept("window-event", self.resizeGame)
# Create some lighting
ambient_level = 0.6
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(ambient_level, ambient_level, ambient_level, 1.0))
render.setLight(render.attachNewNode(ambientLight))
direct_level = 0.8
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0.0, 0.0, -1.0))
directionalLight.setColor(Vec4(direct_level, direct_level, direct_level, 1))
directionalLight.setSpecularColor(Vec4(direct_level, direct_level, direct_level, 1))
render.setLight(render.attachNewNode(directionalLight))
# create a point light that will follow our view point (the camera for now)
# attenuation is set so that this point light has a torch like effect
self.plight = PointLight("plight")
self.plight.setColor(VBase4(0.8, 0.8, 0.8, 1.0))
self.plight.setAttenuation(Point3(0.0, 0.0, 0.0002))
self.plnp = base.camera.attachNewNode(self.plight)
self.plnp.setPos(0, 0, 0)
render.setLight(self.plnp)
self.cam_light = 1
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
"mouse3": 0,
"flymode": 1,
}
# setup FOG
self.fog_colour = (0.8, 0.8, 0.8, 1.0)
self.linfog = Fog("A linear-mode Fog node")
self.linfog.setColor(self.fog_colour)
self.linfog.setLinearRange(700, 980) # onset, opaque distances as params
# linfog.setLinearFallback(45,160,320)
base.camera.attachNewNode(self.linfog)
render.setFog(self.linfog)
self.fog = 1
# camera control
self.campos = Point3(0, 0, 0)
self.camHeading = 0.0
self.camPitch = 0.0
base.camLens.setFov(65.0)
base.camLens.setFar(1200)
self.cam_speed = 0 # index into self.camp_speeds
self.cam_speeds = [40.0, 80.0, 160.0, 320.0, 640.0]
# Collision Detection for "WALKMODE"
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. The ray will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0.0, 0.0, 0.0)
self.camGroundRay.setDirection(0, 0, -1) # straight down
self.camGroundCol = CollisionNode("camRay")
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
# attach the col node to the camCollider dummy node
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
# self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
# self.cTrav.showCollisions(render)
# Add the spinCameraTask procedure to the task manager.
# taskMgr.add(self.spinCameraTask, "SpinCameraTask")
taskMgr.add(self.camTask, "camTask")
self.toggleControls(1)
# need to step the task manager once to make our fake console work
taskMgr.step()
# CONSOLE ---------------------------------------------------------------------
def consoleScroll(self):
for i in range(0, self.console_num_lines - 1):
self.console_lines[i].setText(self.console_lines[i + 1].getText())
def consoleOut(self, text):
print text # output to stdout/log too
if self.console_cur_line == self.console_num_lines - 1:
self.consoleScroll()
elif self.console_cur_line < self.console_num_lines - 1:
self.console_cur_line += 1
self.console_lines[self.console_cur_line].setText(text)
taskMgr.step()
def consoleOn(self):
self.consoleNode.show()
def consoleOff(self):
self.consoleNode.hide()
# User controls -----------------------------------------------------------
def toggleControls(self, on):
if on == 1:
self.accept("escape", self.exitGame)
self.accept("1", self.setSpeed, ["speed", 0])
self.accept("2", self.setSpeed, ["speed", 1])
self.accept("3", self.setSpeed, ["speed", 2])
self.accept("4", self.setSpeed, ["speed", 3])
self.accept("5", self.setSpeed, ["speed", 4])
self.accept("alt-f", self.fogToggle)
self.accept("t", self.camLightToggle)
self.accept("k", self.displayKeyHelp)
self.accept("f", self.toggleFlymode)
self.accept("l", self.reloadZone)
self.accept("z", self.saveDefaultZone)
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("d", self.setKey, ["cam-right", 1])
self.accept("w", self.setKey, ["forward", 1])
self.accept("mouse1", self.setKey, ["forward", 1])
self.accept("mouse3", self.setKey, ["mouse3", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("k-up", self.hideKeyHelp)
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("d-up", self.setKey, ["cam-right", 0])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("mouse1-up", self.setKey, ["forward", 0])
self.accept("mouse3-up", self.setKey, ["mouse3", 0])
self.accept("s-up", self.setKey, ["backward", 0])
else:
messenger.clear()
def setSpeed(self, key, value):
self.cam_speed = value
self.setFlymodeText()
def fogToggle(self):
if self.fog == 1:
render.clearFog()
base.camLens.setFar(100000)
self.fog = 0
else:
render.setFog(self.linfog)
base.camLens.setFar(1200)
self.fog = 1
def camLightToggle(self):
if self.cam_light == 0:
render.setLight(self.plnp)
self.cam_light = 1
else:
render.clearLight(self.plnp)
self.cam_light = 0
def displayKeyHelp(self):
self.kh = []
msg = "HOTKEYS:"
pos = 0.75
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "------------------"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "W: camera fwd, S: camera bck, A: rotate view left, D: rotate view right"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "1-5: set camera movement speed"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "F: toggle Flymode/Walkmode"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "L: load a zone"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "ALT-F: toggle FOG and FAR plane on/off"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = 'T: toggle additional camera "torch" light on/off'
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "Z: set currently loaded zone as new startup default"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "ESC: exit zonewalk"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
def hideKeyHelp(self):
for n in self.kh:
n.removeNode()
def setFlymodeText(self):
zname = ""
if self.zone:
zname = self.zone.name
if self.flyMode == 0:
self.inst0.setText("[WALKMODE][%i] %s" % (self.cam_speed + 1, zname))
else:
self.inst0.setText("[FLYMODE][%i] %s " % (self.cam_speed + 1, zname))
def toggleFlymode(self):
zname = ""
if self.zone:
zname = self.zone.name
if self.flyMode == 0:
self.flyMode = 1
else:
self.flyMode = 0
self.setFlymodeText()
# Define a procedure to move the camera.
def spinCameraTask(self, task):
angleDegrees = task.time * 6.0
angleRadians = angleDegrees * (pi / 180.0)
base.camera.setPos(20 * sin(angleRadians), -20.0 * cos(angleRadians), 3)
base.camera.setHpr(angleDegrees, 0, 0)
return task.cont
def camTask(self, task):
# query the mouse
mouse_dx = 0
mouse_dy = 0
# if we have a mouse and the right button is depressed
if base.mouseWatcherNode.hasMouse():
if self.keyMap["mouse3"] != 0:
self.mouse_accum.update()
else:
self.mouse_accum.reset()
mouse_dx = self.mouse_accum.dx
mouse_dy = self.mouse_accum.dy
self.rXSpeed = fabs(self.mouse_accum.dx) * (self.cam_speed + 1) * max(5 * 1000 / self.xres, 3)
self.rYSpeed = fabs(self.mouse_accum.dy) * (self.cam_speed + 1) * max(3 * 1000 / self.yres, 1)
if self.keyMap["cam-left"] != 0 or mouse_dx < 0:
if self.rSpeed < 160:
self.rSpeed += 80 * globalClock.getDt()
if mouse_dx != 0:
self.camHeading += self.rXSpeed * globalClock.getDt()
else:
self.camHeading += self.rSpeed * globalClock.getDt()
if self.camHeading > 360.0:
self.camHeading = self.camHeading - 360.0
elif self.keyMap["cam-right"] != 0 or mouse_dx > 0:
if self.rSpeed < 160:
self.rSpeed += 80 * globalClock.getDt()
if mouse_dx != 0:
self.camHeading -= self.rXSpeed * globalClock.getDt()
else:
self.camHeading -= self.rSpeed * globalClock.getDt()
if self.camHeading < 0.0:
self.camHeading = self.camHeading + 360.0
else:
self.rSpeed = 80
if mouse_dy > 0:
self.camPitch += self.rYSpeed * globalClock.getDt()
elif mouse_dy < 0:
self.camPitch -= self.rYSpeed * globalClock.getDt()
# set camera heading and pitch
base.camera.setHpr(self.camHeading, self.camPitch, 0)
# viewer position (camera) movement control
v = render.getRelativeVector(base.camera, Vec3.forward())
if not self.flyMode:
v.setZ(0.0)
move_speed = self.cam_speeds[self.cam_speed]
if self.keyMap["forward"] == 1:
self.campos += v * move_speed * globalClock.getDt()
if self.keyMap["backward"] == 1:
self.campos -= v * move_speed * globalClock.getDt()
# actually move the camera
lastPos = base.camera.getPos()
base.camera.setPos(self.campos)
# self.plnp.setPos(self.campos) # move the point light with the viewer position
# WALKMODE: simple collision detection
# we simply check a ray from slightly below the "eye point" straight down
# for geometry collisions and if there are any we detect the point of collision
# and adjust the camera's Z accordingly
if self.flyMode == 0:
# move the camera to where it would be if it made the move
# the colliderNode moves with it
# base.camera.setPos(self.campos)
# check for collissons
self.cTrav.traverse(render)
entries = []
for i in range(self.camGroundHandler.getNumEntries()):
entry = self.camGroundHandler.getEntry(i)
entries.append(entry)
# print 'collision'
entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ()))
if len(entries) > 0: # and (entries[0].getIntoNode().getName() == "terrain"):
# print len(entries)
self.campos.setZ(entries[0].getSurfacePoint(render).getZ() + self.eyeHeight)
else:
self.campos = lastPos
base.camera.setPos(self.campos)
# if (base.camera.getZ() < self.player.getZ() + 2.0):
# base.camera.setZ(self.player.getZ() + 2.0)
# update loc and hpr display
pos = base.camera.getPos()
hpr = base.camera.getHpr()
self.inst2.setText("Loc: %.2f, %.2f, %.2f" % (pos.getX(), pos.getY(), pos.getZ()))
self.inst3.setText("Hdg: %.2f, %.2f, %.2f" % (hpr.getX(), hpr.getY(), hpr.getZ()))
return task.cont
def exitGame(self):
sys.exit(0)
def resizeGame(self, win):
props = base.win.getProperties()
self.xres = props.getXSize()
self.yres = props.getYSize()
self.xres_half = self.xres / 2
self.yres_half = self.yres / 2
self.saveDefaultRes()
# Records the state of the arrow keys
# this is used for camera control
def setKey(self, key, value):
self.keyMap[key] = value
# -------------------------------------------------------------------------
# this is the mythical MAIN LOOP :)
def update(self):
if self.zone_reload_name != None:
self.doReload(self.zone_reload_name)
self.zone_reload_name = None
if self.zone != None:
self.zone.update()
taskMgr.step()
if self.login_client != None:
self.login_client.update()
# ZONE loading ------------------------------------------------------------
# general zone loader driver
# removes existing zone (if any) and load the new one
def loadZone(self, name, path):
if path[len(path) - 1] != "/":
path += "/"
if self.zone:
self.zone.rootNode.removeNode()
self.zone = Zone(self, name, path)
error = self.zone.load()
if error == 0:
self.consoleOff()
self.setFlymodeText()
base.setBackgroundColor(self.fog_colour)
def saveDefaultRes(self):
cfg = self.configurator.config
cfg["xres"] = str(self.xres)
cfg["yres"] = str(self.yres)
self.configurator.saveConfig()
# initial world load after bootup
def load(self):
cfg = self.configurator.config
if self.login_client != None:
return
zone_name = cfg["default_zone"]
basepath = cfg["basepath"]
self.loadZone(zone_name, basepath)
# config save user interfacce
def saveDefaultZone(self):
if self.zone:
cfg = self.configurator.config
cfg["default_zone"] = self.zone.name
self.configurator.saveConfig()
# zone reload user interface
# this gets called from our update loop when it detects that zone_reload_name has been set
# we do this in this convoluted fashion in order to keep the main loop taskMgr updates ticking
# because otherwise our status console output at various stages during the zone load would not
# be displayed. Yes, this is hacky.
def doReload(self, name):
cfg = self.configurator.config
basepath = cfg["basepath"]
self.loadZone(name, basepath)
# form dialog callback
# this gets called from the form when the user has entered a something
# (hopefully a correct zone short name)
def reloadZoneDialogCB(self, name):
self.frmDialog.end()
self.zone_reload_name = name
self.toggleControls(1)
# this is called when the user presses "l"
# it disables normal controls and fires up our query form dialog
def reloadZone(self):
base.setBackgroundColor((0, 0, 0))
self.toggleControls(0)
self.consoleOn()
self.frmDialog = FileDialog(
"Please enter the shortname of the zone you wish to load:",
"Examples: qrg, blackburrow, freportn, crushbone etc.",
self.reloadZoneDialogCB,
)
self.frmDialog.activate() # relies on the main update loop to run
###############################
# EXPERIMENTAL
def doLogin(self):
self.login_client = UDPClientStream("127.0.0.1", 5998)
def setWindowName(self, name):
props = WindowProperties()
props.setTitle(name)
base.win.requestProperties(props)
def __init__(self):
self.d_objects = {}
self.client = None
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0
}
base.win.setClearColor(Vec4(0, 0, 0, 1))
#base.win.setWidth(800)
props = WindowProperties()
props.setTitle('Panda3D/Node.js Networking Experiment')
base.win.requestProperties(props)
# Post the instructions
self.title = addTitle("Roaming Ralph goes Networking")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
self.inst8 = addInstructions(0.55, "Current connection lag:")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
# PlayerStartPos = self.environ.find("**/start_point").getPos()
# print "start pos:", PlayerStartPos
self.player = None
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# ----------------------------------------------------------------------
# new: create DynObject to "host" a Ralph model for our player avatar
# Accept the control keys for movement and rotation
self.accept("escape", self.exitGame)
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("s", self.setKey, ["cam-right", 1])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("s-up", self.setKey, ["cam-right", 0])
# taskMgr.add(self.moveCamera,"CameraMoveTask")
taskMgr.add(self.moveObjects, "ObjectsMoveTask")
# Game state variables
self.isMoving = False
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.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)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
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 __init__(self):
ShowBase.__init__(self)
########## Window configuration #########
wp = WindowProperties()
wp.setSize(1024, 860)
wp.setTitle("")
wp.setOrigin(-2, -2)
self.win.requestProperties(wp)
self.win.movePointer(0, wp.getXSize() / 2, wp.getYSize() / 2)
print wp.getXSize() / 2, wp.getYSize() / 2
########## Gameplay settings #########
self.gameMode = {"display": PLAY, "play": TERRAIN}
self.level = 1.5
self.mode_initialized = False
######### Camera #########
self.disableMouse()
self.mainCamera = Camera(self.camera)
self.mainCamera.camObject.setHpr(0, 0, 0)
self.loadLevel()
######### Events #########
self.taskMgr.add(self.gameLoop, "gameLoop", priority=35)
self.keys = {"w": 0, "s": 0, "a": 0, "d": 0, "space": 0, "escape": 0}
self.accept("w", self.setKey, ["w", 1])
self.accept("w-up", self.setKey, ["w", 0])
self.accept("s", self.setKey, ["s", 1])
self.accept("s-up", self.setKey, ["s", 0])
self.accept("a", self.setKey, ["a", 1])
self.accept("a-up", self.setKey, ["a", 0])
self.accept("d", self.setKey, ["d", 1])
self.accept("d-up", self.setKey, ["d", 0])
self.accept("space", self.setKey, ["space", 1])
self.accept("space-up", self.setKey, ["space", 0])
self.accept("escape", self.setKey, ["escape", 1])
self.accept("escape-up", self.setKey, ["escape", 0])
self.accept("wheel_up", self.zoomCamera, [-1])
self.accept("wheel_down", self.zoomCamera, [1])
self.accept("window-event", self.handleWindowEvent)
######### GUI #########
#self.fonts = {"failure" : loader.loadFont('myfont.ttf')}
self.guiElements = []
self._GCLK = None
self._FT = None
def __init__(self, scene_file, pedestrian_file, dir, mode):
ShowBase.__init__(self)
self.globalClock = ClockObject.getGlobalClock()
self.globalClock.setMode(ClockObject.MSlave)
self.directory = dir
self.model = Model(dir)
self.loadScene(scene_file)
self.loadPedestrians(pedestrian_file)
#self.cam_label = OST("Top Down", pos=(0, 0.95), fg=(1,1,1,1),
# scale=0.05, mayChange=True)
#self.time_label = OST("Time: 0.0", pos=(-1.3, 0.95), fg=(1,1,1,1),
# scale=0.06, mayChange=True, align=TextNode.ALeft)
#self.accept("arrow_right", self.changeCamera, [1])
#self.accept("arrow_left", self.changeCamera, [-1])
self.accept("escape", self.exit)
self.accept("aspectRatioChanged", self.setAspectRatio)
self.accept("window-event", self.windowChanged)
new_window_fbp = FrameBufferProperties.getDefault()
new_window_properties = WindowProperties.getDefault()
self.new_window = base.graphicsEngine.makeOutput(
base.pipe, 'Top Down View Window', 0, new_window_fbp,
new_window_properties, GraphicsPipe.BFRequireWindow)
self.new_window_display_region = self.new_window.makeDisplayRegion()
#base.disableMouse()
lens = OrthographicLens()
lens.setFilmSize(1500, 1500)
lens.setNearFar(-5000, 5000)
self.default_camera = render.attachNewNode(Camera("top down"))
self.default_camera.node().setLens(lens)
#self.default_camera.setPosHpr(Vec3( -75, 0, 2200), Vec3(0, -90, 0))
self.default_camera.setPosHpr(Vec3(-75, 0, 0), Vec3(0, -90, 0))
#self.new_window = base.openWindow()
self.display_regions = []
self.display_regions.append(self.new_window_display_region)
self.display_regions.append(
base.win.makeDisplayRegion(0, 0.32, 0.52, 1))
self.display_regions.append(
base.win.makeDisplayRegion(0.34, 0.66, 0.52, 1))
self.display_regions.append(
base.win.makeDisplayRegion(0.68, 1, 0.52, 1))
self.display_regions.append(
base.win.makeDisplayRegion(0, 0.32, 0, 0.48))
self.display_regions.append(
base.win.makeDisplayRegion(0.34, 0.66, 0, 0.48))
self.display_regions.append(
base.win.makeDisplayRegion(0.68, 1, 0, 0.48))
self.display_regions[0].setCamera(self.default_camera)
self.border_regions = []
self.border_regions.append(
base.win.makeDisplayRegion(0.32, 0.34, 0.52, 1))
self.border_regions.append(
base.win.makeDisplayRegion(0.66, 0.68, 0.52, 1))
self.border_regions.append(base.win.makeDisplayRegion(
0, 1, 0.48, 0.52))
self.border_regions.append(
base.win.makeDisplayRegion(0.32, 0.34, 0, 0.48))
self.border_regions.append(
base.win.makeDisplayRegion(0.66, 0.68, 0, 0.48))
for i in range(0, len(self.border_regions)):
border_region = self.border_regions[i]
border_region.setClearColor(VBase4(0, 0, 0, 1))
border_region.setClearColorActive(True)
border_region.setClearDepthActive(True)
#self.setCamera(0)
self.controller = Controller(self, mode)
self.taskMgr.add(self.updateCameraModules, "Update Camera Modules", 80)
self.globalClock.setFrameTime(0.0)
self.width = WIDTH
self.height = HEIGHT
props = WindowProperties()
props.setTitle('Virtual Vision Simulator')
base.win.requestProperties(props)
"""new_window_2d_display_region = self.new_window.makeDisplayRegion()
new_window_2d_display_region.setSort(20)
new_window_camera_2d = NodePath(Camera('2d camera of new window'))
lens_2d = OrthographicLens()
lens_2d.setFilmSize(2, 2)
lens_2d.setNearFar(-1000, 1000)
new_window_camera_2d.node().setLens(lens_2d)
new_window_render_2d = NodePath('render2d of new window')
new_window_render_2d.setDepthTest(False)
new_window_render_2d.setDepthWrite(False)
new_window_camera_2d.reparentTo(new_window_render_2d)
new_window_2d_display_region.setCamera(new_window_camera_2d)"""
"""aspectRatio = base.getAspectRatio()
self.new_window_aspect2d = new_window_render_2d.attachNewNode(PGTop('Aspect2d of new window'))
self.new_window_aspect2d.setScale(1.0 / aspectRatio, 1.0, 1.0)"""
render.analyze()
def setWindowTitle(title): wp = WindowProperties() wp.setTitle(title) base.win.requestProperties(wp)
def __init__(self, scene_file, pedestrian_file, dir, mode):
ShowBase.__init__(self)
self.globalClock = ClockObject.getGlobalClock()
self.globalClock.setMode(ClockObject.MSlave)
self.directory = dir
self.model = Model(dir)
self.loadScene(scene_file)
self.loadPedestrians(pedestrian_file)
#self.cam_label = OST("Top Down", pos=(0, 0.95), fg=(1,1,1,1),
# scale=0.05, mayChange=True)
#self.time_label = OST("Time: 0.0", pos=(-1.3, 0.95), fg=(1,1,1,1),
# scale=0.06, mayChange=True, align=TextNode.ALeft)
#self.accept("arrow_right", self.changeCamera, [1])
#self.accept("arrow_left", self.changeCamera, [-1])
self.accept("escape", self.exit)
self.accept("aspectRatioChanged", self.setAspectRatio)
self.accept("window-event", self.windowChanged)
new_window_fbp = FrameBufferProperties.getDefault()
new_window_properties = WindowProperties.getDefault()
self.new_window = base.graphicsEngine.makeOutput(base.pipe, 'Top Down View Window', 0, new_window_fbp, new_window_properties, GraphicsPipe.BFRequireWindow)
self.new_window_display_region = self.new_window.makeDisplayRegion()
#base.disableMouse()
lens = OrthographicLens()
lens.setFilmSize(1500, 1500)
lens.setNearFar(-5000, 5000)
self.default_camera = render.attachNewNode(Camera("top down"))
self.default_camera.node().setLens(lens)
#self.default_camera.setPosHpr(Vec3( -75, 0, 2200), Vec3(0, -90, 0))
self.default_camera.setPosHpr(Vec3(-75, 0, 0), Vec3(0, -90, 0))
#self.new_window = base.openWindow()
self.display_regions = []
self.display_regions.append(self.new_window_display_region)
self.display_regions.append(base.win.makeDisplayRegion(0, 0.32, 0.52, 1))
self.display_regions.append(base.win.makeDisplayRegion(0.34, 0.66, 0.52, 1))
self.display_regions.append(base.win.makeDisplayRegion(0.68, 1, 0.52, 1))
self.display_regions.append(base.win.makeDisplayRegion(0, 0.32, 0, 0.48))
self.display_regions.append(base.win.makeDisplayRegion(0.34, 0.66, 0, 0.48))
self.display_regions.append(base.win.makeDisplayRegion(0.68, 1, 0, 0.48))
self.display_regions[0].setCamera(self.default_camera)
self.border_regions = []
self.border_regions.append(base.win.makeDisplayRegion(0.32, 0.34, 0.52, 1))
self.border_regions.append(base.win.makeDisplayRegion(0.66, 0.68, 0.52, 1))
self.border_regions.append(base.win.makeDisplayRegion(0, 1, 0.48, 0.52))
self.border_regions.append(base.win.makeDisplayRegion(0.32, 0.34, 0, 0.48))
self.border_regions.append(base.win.makeDisplayRegion(0.66, 0.68, 0, 0.48))
for i in range(0, len(self.border_regions)):
border_region = self.border_regions[i]
border_region.setClearColor(VBase4(0, 0, 0, 1))
border_region.setClearColorActive(True)
border_region.setClearDepthActive(True)
#self.setCamera(0)
self.controller = Controller(self, mode)
self.taskMgr.add(self.updateCameraModules, "Update Camera Modules", 80)
self.globalClock.setFrameTime(0.0)
self.width = WIDTH
self.height = HEIGHT
props = WindowProperties( )
props.setTitle( 'Virtual Vision Simulator' )
base.win.requestProperties( props )
"""new_window_2d_display_region = self.new_window.makeDisplayRegion()
new_window_2d_display_region.setSort(20)
new_window_camera_2d = NodePath(Camera('2d camera of new window'))
lens_2d = OrthographicLens()
lens_2d.setFilmSize(2, 2)
lens_2d.setNearFar(-1000, 1000)
new_window_camera_2d.node().setLens(lens_2d)
new_window_render_2d = NodePath('render2d of new window')
new_window_render_2d.setDepthTest(False)
new_window_render_2d.setDepthWrite(False)
new_window_camera_2d.reparentTo(new_window_render_2d)
new_window_2d_display_region.setCamera(new_window_camera_2d)"""
"""aspectRatio = base.getAspectRatio()
self.new_window_aspect2d = new_window_render_2d.attachNewNode(PGTop('Aspect2d of new window'))
self.new_window_aspect2d.setScale(1.0 / aspectRatio, 1.0, 1.0)"""
render.analyze()
def openMainWindow(self, *args, **kw):
ShowBase.ShowBase.openMainWindow(self, *args, **kw)
if self.windowTitle is not None:
wp = WindowProperties()
wp.setTitle(self.windowTitle)
self.win.requestProperties(wp)
class Game(ShowBase, object):
"""What should be done here:
Nothing that doesnt have to be.
If something can have its own class, it should.
Things that are here that shouldnt be:
Setting up physics
Setting up the world
Menus
GUI
World/level things
Things that are here that should be:
Setting properties
Main update loop
Initalizing things (worlds, physics) Via other classes
Remember to ask yourself this "Does a X have a Y?"
So does a game have physics? No, a game has a world,
and a world has physics.
An entity is a panda node.
"""
forceFPS = True
fsmState = True
bulletDict = {}
playerList = {}
grav_ghost_NP = 0
def __init__(self):
#self.gui = loadGui()
#init_pause_state(self.menu)
init_pause_state()
test = World()
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9))
self.world.setDebugNode(debugNP.node())
#Add a gravity region
self.add_gravity_region(
(100, 100, 100),
(100, -400, 0),
(0, 0, 1000))
taskMgr.add(self.update_bullet, 'update_bullet')
self.bulletList = self.loadBulletList()
base.disableMouse()
self.loadLevel()
self.initClasses()
self.setCamera()
self.addWinProps()
#TODO: Fix the healthbars
#self.gui.healthBar("Player1")
#self.gui.healthBar("AI1")
#self.gui.healthBar("AI2")
#self.gui.healthBar("AI3")
self.loadStation()
self.addlight()
self.createControls()
taskMgr.add(self.updateMenus, 'MenuUpdater')
print("Instance of game class running.")
self.simmpoleXP()
self.flipsXP()
def update_bullet(self, task):
dt = globalClock.getDt()
self.world.doPhysics(dt)
return task.cont
def add_gravity_region(self, size, pos, gravity):
"""Makes a bullet ghost, when a object enters
its gravity is changed to match the arguments passed
"""
shape = BulletBoxShape(Vec3(size))
grav_ghost = BulletGhostNode('Ghost')
grav_ghost.addShape(shape)
grav_ghost_NP = render.attachNewNode(grav_ghost)
grav_ghost_NP.setPos(pos)
grav_ghost_NP.setCollideMask(BitMask32(0x0f))
self.world.attachGhost(grav_ghost)
def check_gravity_region(task):
"""Check what bullet nodes are inside
and apply gravity to them.
"""
ghost = grav_ghost_NP.node()
print ghost.getNumOverlappingNodes()
for node in ghost.getOverlappingNodes():
print node
#TODO: Make this only apply when in the region
#EX: Gravity is set to X inside, set back to normal when out
node.setGravity(Vec3(gravity))
return task.cont
#Add the region checker task
taskMgr.add(check_gravity_region, "check_gravity_region")
def simmpoleXP(self):
for i in range(101):
if i < 6:
xpToLvl = ((i) * ((i * i) / 2) * 256)
else:
xpToLvl = (i) * ((i * i) / 2) * 128
print("SimmPole: Level " + str(i) + ":" + str(xpToLvl))
#print(str(xpToLvl)+", ")
def flipsXP(self):
for i in range(101):
xpToLvl = (i) * ((i * i) / 2) * 100
print("Flips: Level " + str(i) + ":" + str(xpToLvl))
#print(str(xpToLvl)+", ")
def loadBulletList(self):
self.bulletDict[0] = ("_normalBullet")
self.bulletDict[1] = ("_normalMissile")
return self.bulletDict
def sortedBulletDictValues(self):
items = self.bulletDict.items()
items.sort()
return [value for key, value in items]
def initClasses(self):
'''Makes some instances of some classes'''
self.playerList["Player1"] = Player(
self.world,
"Player1",
False,
False,
None,
50) # Makes the main ship, using the base.camera.
self.playerList["AI1"] = Player(
self.world,
"AI1",
True,
True,
self.playerList["Player1"].getShip(),
10) # Makes an AI ship, using no camera.
self.playerList["AI2"] = Player(
self.world,
"AI2",
True,
True,
self.playerList["Player1"].getShip(),
10)
self.playerList["AI3"] = Player(
self.world,
"AI3",
True,
True,
self.playerList["Player1"].getShip(),
10)
self.gameSettings = GameSettings()
def createPlayer(self):
'''To be implemented.
Players (and ships) could be in an array,
and the array could be in a function to assign new players
(and ships). This would allow direct access to class instances,
giving more control to the program.
Example:
playerArray = []
def createPlayer(self, playerArray, args, args1):
player = Player(args, args1)
playerArray.append(player)
'''
def addWinProps(self):
#Hides the cursor and sets the window title
self.props = WindowProperties()
self.props.setCursorHidden(True)
self.props.setTitle('Space Fighter')
base.win.requestProperties(self.props)
base.setFrameRateMeter(True)
FPS = 60
self.globalClock = ClockObject.getGlobalClock()
if self.forceFPS:
self.globalClock.setMode(ClockObject.MForced)
else:
self.globalClock.setMode(ClockObject.MLimited)
self.globalClock.setFrameRate(FPS)
self.globalTime = self.globalClock.getRealTime()
render.setAntialias(AntialiasAttrib.MMultisample)
def exit(self):
sys.exit()
def pause(self):
'''Runs functions when escape is pressed'''
PauseState.pause_ssm()
def debugOn(self):
self.playerList["Player1"].ship.ForwardSpeed = self.playerList["Player1"].ship.MaxSpeed
base.acceptOnce("lshift", self.debugOff) # Leave debug mode "lshift"
self.playerList["Player1"].score += 1
print "Debug mode on :)"
def debugOff(self):
base.acceptOnce("lshift", self.debugOn) # Enter debug mode on "lshift"
print "Debug mode off :("
def addlight(self):
sptLight = Spotlight("spot")
sptLens = PerspectiveLens()
sptLens.setFar(1000)
sptLens.setFov(90)
sptLight.setLens(sptLens)
sptLight.setColor(Vec4(1.2, 1.2, 1.0, .2))
sptLight.setShadowCaster(True, 4096, 4096)
sptNode = render.attachNewNode(sptLight)
sptNode.setPos(0, 0, 1000)
sptNode.setHpr(0,-90,0)
sptNode.lookAt(self.level)
render.setLight(sptNode)
dirLight = DirectionalLight("dlight")
dirLight.setSpecularColor(VBase4(0.249, 0.235, 0.207, 1))
dirLight.setDirection(Vec3(102, 100, -60))
dirLight.setShadowCaster(True, 2048, 2048)
dirLight.getLens().setFilmSize(4096, 4096)
dirLight.showFrustum()
dLight = render.attachNewNode(dirLight)
#render.setLight(dLight)
alight = AmbientLight('alight')
alight.setColor(VBase4(.149, .145, .135, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
render.setShaderAuto()
def loadStation(self):
#Loads and sets up a station
self.Station = loader.loadModel('models/station.x')
self.Station.reparentTo(render)
self.Station.setPos(0, 0, 0)
#collisions.pickerCollision(self.Station)
def loadLevel(self):
'''Loads and sets up a level'''
shape = BulletBoxShape(Vec3(200, 200, 200))
node = BulletRigidBodyNode('Box')
node.addShape(shape)
np = render.attachNewNode(node)
np.setPos(0, 0, -400)
self.world.attachRigidBody(node)
lvlmat = Material()
lvlmat.setDiffuse(VBase4(0.166, 0.151, 0.119, 1))
self.level = loader.loadModel('models/level.x')
self.level.reparentTo(np)
self.level.setPos(0, 0, -00)
self.level.setScale(200)
self.level.setMaterial(lvlmat, 1)
self.level.setColor(0,1,1,1)
'''
lvlmat = Material()
lvlmat.setDiffuse(VBase4(0.166, 0.151, 0.119, 1))
self.level = loader.loadModel('models/level.x')
self.level.reparentTo(render)
self.level.setPos(0, 0, -750)
self.level.setScale(200)
self.level.setMaterial(lvlmat, 1)'''
#self.level.setR(50)
#self.level.setTwoSided(True)
#self.level.place()
#cm = CardMaker("plane")
#cm.setFrame(-1000, 1000, -1000, 1000)
#self.level = render.attachNewNode(cm.generate())
#self.level.setP(270)
#self.level.setPos(0,0,-10)
#self.level.setTwoSided(True)
def setCamera(self):
'''Loads and sets up cameras'''
frontCam = Camera("frontCamera")
frontCamera = render.attachNewNode(frontCam)
frontCamera.setName("FrontCamera")
frontCamera.setPos(0, 5, 0)
frontCamera.setHpr(0, 0, 0)
#dr = base.camNode.getDisplayRegion(0)
#dr.setActive(0) # Or leave it (dr.setActive(1))
#window = dr.getWindow()
#dr1 = window.makeDisplayRegion(0, 1, 0.5, 1)
#dr1.setSort(dr.getSort())
#dr2 = window.makeDisplayRegion(0.5, 1, 0, 1)
#dr2.setSort(dr.getSort())
#dr1.setCamera(frontCamera)
#dr2.setCamera(base.camera)
def updateMenus(self, task):
#Updates the menu with recent data.
#self.menu.updateOptionsMenu()
return task.cont
def createControls(self):
#Sets up the controls
base.accept("escape", self.pause) # Exit game on "escape"
base.acceptOnce("lshift", self.debugOn) # Enter debug mode on "lshift"
