def setLightColor(color):
light.setColor(
Vec4(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0,
color[3] / 255.0))
# Update color chip button
pButton['bg'] = getTkColorString(color)
def __init__(self):
ShowBase.__init__(self)
engine.tq_graphics_basics.init_engine(render, aspect2d, loader)
base.setFrameRateMeter(True)
engine.tq_graphics_basics.tq_render.setAntialias(AntialiasAttrib.MAuto)
shade_of_gray = 0.2
base.setBackgroundColor(shade_of_gray, shade_of_gray, shade_of_gray)
cg = cameras.Orbiter.OrbiterOrtho(base.cam, r_init=1.)
cs = CoordinateSystemP3dPlain()
cs.attach_to_render()
# # -----------
# lens = OrthographicLens()
# far = 1.
# near = -1.
# lens.setNearFar(near, far)
# x_filmsize = 2 * 1.
# y_filmsize = x_filmsize * 9./16. * 2
# # x_filmsize = 2 * 1.
# # y_filmsize = 2 * 1.
# # x_filmsize = 1.
# # y_filmsize = 1.
# lens.setFilmSize(x_filmsize, y_filmsize)
# base.cam.node().setLens(lens)
# print("proj mat (1): ")
# print(base.cam.node().getLens().getProjectionMat())
# print(base.cam.node().getLens().getFilmSize())
# # -----------
# -----------
lens = MatrixLens()
# lens.setNearFar(-500., 500.)
# x_filmsize = 2 * 1.
# y_filmsize = x_filmsize * 9./16.
# lens.setFilmSize(x_filmsize, y_filmsize)
far = 100.
near = -100.
x_filmsize = 2 * 1.5
y_filmsize = x_filmsize * 9./16.
right = x_filmsize/2.
left = -right
up = y_filmsize/2.
bottom = -up
proj_mat = math_utils.get_ortho_projection_matrix(right, left, up, bottom, near, far)
lens.setUserMat(math_utils.to_forrowvecs(proj_mat))
# lens.setUserMat(np.flatten(proj_mat))
base.cam.node().setLens(lens)
print("proj mat (2): ")
print(base.cam.node().getLens().getProjectionMat())
print(base.cam.node().getLens().getFilmSize())
# -----------
# base.cam.setLens()
# cs = CoordinateSystem(cg)
# cs.attach_to_render()
# base.accept("d", lambda: exec("import ipdb; ipdb.set_trace()"))
# dep = DraggableEdgePlayer("/home/chris/Desktop/playbacktest2.wav", cg, taskMgr)
# f2d3 = Frame2d(camera_gear=cg, attach_to_space="render", update_labels_orientation=True)
# # f2d3.set_figsize(0.8, 0.5)
# sffr = StreamFramesFromRecorder(f2d3)
# plot_audio_file_profile(cg)
a = Vector()
a.setTipPoint(Vec3(0., 0., 1.)*0.2)
a.setTailPoint(Vec3(0., 0., 0.))
a.reparentTo_p3d(render)
a.setColor(Vec4(0., 1., 1., 1.), 1)
# cg.set_view_to_xz_plane()
# df = DraggableFrame(cg)
# df.setPos(Vec3(0., 0., 0.6))
# df.attach_to_render()
# df = DraggableFrame(cg)
# df.setPos(Vec3(0., 0., 0.6))
# df.attach_to_render()
# df = DraggableFrame(cg, height=0.2, width=0.7)
# df.setPos(Vec3(-0.8, 0., 0.7))
# df.setColor(Vec4(0., 1., 0., 1.), 1)
# df.attach_to_render()
# quad = Quad(height=0.5, width=0.7, thickness=5.)
# quad.setColor(Vec4(0., 1., 0., 1.), 1)
# quad.reparentTo_p3d(render)
# line = Line1dSolid(thickness=5.)
# line.setColor(1.0, 1.0, 0., 1.)
# line.setTailPoint(Vec3(0.25, 0., 0.))
# line.setTipPoint(Vec3(0.75, 0., 0.))
# line.reparentTo_p3d(render)
# line.setColor(Vec4(0., 1., 1., 1.), 1)
# line.setPos(Vec3(-0.8, 0., 0.7))
# df = DraggableResizableFrame(cg, height=0.2, width=0.7)
# df.attach_to_render()
# df.setPos(Vec3(0.1, 0., 0.))
# df.setColor(Vec4(0., 1., 1., 1.), 1)
# self.vecp0 = Vector()
# # self.vecp0.setTipPoint(Vec3(-1., 0., 1.))
# self.vecp0.setTipPoint(Vec3(0., 0., 0.))
# self.vecp0.setTailPoint(Vec3(0., 0., 0.))
# self.vecp0.reparentTo(engine.tq_graphics_basics.tq_render)
# self.vecp0.setColor(Vec4(0., 0., 0., 1.), 1)
# -------------
# slp = primitives.SegmentedLinePrimitive(color=get_color("yellow"), thickness=2)
# slp.extendCoords([np.array([0., 0., 0.]), np.array([1., 1., 1.]), np.array([1., 0., 0.])])
# slp.attach_to_render()
# slp.extendCoords([np.array([1., 1., 0.])])
# slp.attach_to_render()
# -------------
gn = GroupNode()
gn.attach_to_render()
slp = primitives.SegmentedLinePrimitive(color=get_color("yellow"), thickness=2)
slp.extendCoords([np.array([0., 0., 0.]), np.array([1., 1., 1.]), np.array([1., 0., 0.])])
slp.reparentTo(gn)
slp.extendCoords([np.array([1., 1., 0.])])
slp.reparentTo(gn)
def render_hints(self):
""" render various on-hover things:
- cursors
- time labels """
get_hover_points_success, ray_direction, ray_aufpunkt, edge_p1, edge_p2, c1, c2 = (
self.get_hover_points())
if get_hover_points_success is True:
if math_utils.isPointBetweenTwoPoints(edge_p1, edge_p2, c1):
self.shortest_distance_line.setTipPoint(math_utils.np_to_p3d_Vec3(c1))
self.shortest_distance_line.setTailPoint(math_utils.np_to_p3d_Vec3(c2))
self.shortest_distance_line.show()
# -- set the time label
# ---- set the position of the label to the position of the mouse cursor,
# but a bit higher
self.time_label.textNodePath.show()
self.time_label.setPos(*(ray_aufpunkt + ray_direction * 1.))
a = self.get_a_param(c2)
t = a * self.edge_graphics.get_duration_func()
self.time_label.setText("t = {0:.2f}, a = {1:.2f}".format(t, a))
self.time_label.update()
self.time_label.textNodePath.setScale(0.04)
# -- color edges
# on hover, change the color to be
# darker than otherwise
primary_color = self.edge_graphics.get_primary_color()
darkening_factor = 0.5
new_rgb_v3 = np.array([
primary_color[0],
primary_color[1],
primary_color[2]]) * darkening_factor
new_color = Vec4(new_rgb_v3[0], new_rgb_v3[1], new_rgb_v3[2], 1.)
# when hovered-over
self.edge_graphics.set_primary_color(new_color,
change_logical_primary_color=False)
else:
self.shortest_distance_line.setColor(Vec4(1., 1., 1., 1.), 1) # when not hovered-over
self.edge_graphics.set_primary_color(self.edge_graphics.get_primary_color())
self.shortest_distance_line.hide()
self.time_label.textNodePath.hide()
# -- color point
# ---- find closest point,
# within a certain radius
d_min_point = None
closestpoint = None
playerline_limiting_positions = [self.edge_graphics.get_inset_v1(),
self.edge_graphics.get_inset_v2()]
for pos in playerline_limiting_positions:
d = np.linalg.norm(
math_utils.p3d_to_np(pos)
- math_utils.p3d_to_np(ray_aufpunkt))
if d_min_point is not None:
if d < d_min_point:
d_min_point = d
closestpoint = pos
else:
d_min_point = d
closestpoint = pos
Zones.FunnyFarm: 2,
Zones.DonaldsDreamland: 2,
Zones.OutdoorZone: 2,
Zones.BossbotHQ: 2,
Zones.SellbotHQ: 43,
Zones.CashbotHQ: 2,
Zones.LawbotHQ: 2,
Zones.GolfZone: 2,
Zones.PartyHood: 2
}
# Amount of building floors required to achieve a particular star above a toon's head
TrophyStarLevels = (10, 20, 30, 50, 75, 100)
# Colors of building stars
TrophyStarColors = (
Vec4(0.9, 0.6, 0.2, 1), # Bronze Static
Vec4(0.9, 0.6, 0.2, 1), # Bronze Spinning
Vec4(0.8, 0.8, 0.8, 1), # Silver Static
Vec4(0.8, 0.8, 0.8, 1), # Silver Spinning
Vec4(1, 1, 0, 1), # Gold Static
Vec4(1, 1, 0, 1) # Gold Spinning
)
# Speeds of various characters
NPCSpeed = {
"mickey": 5.0,
"vampireMickey": 1.15,
"minnie": 3.2,
"witchMinnie": 1.8,
"donald": 3.68,
"frankenDonald": 0.9,
def __init__(self):
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
self.cManager = QueuedConnectionManager()
self.cListener = QueuedConnectionListener(self.cManager, 0)
self.cReader = QueuedConnectionReader(self.cManager, 0)
self.cWriter = ConnectionWriter(self.cManager, 0)
self.opponents = dict()
self.logStat = -1
self.id = 0
self.username = ""
host = "localhost"
port = 9252
self.connection = self.cManager.openTCPClientConnection(host, port, 10000)
self.received = 1
self.playersText = []
if self.connection:
self.cReader.addConnection(self.connection)
taskMgr.add(self.updateRoutine, 'updateRoutine')
taskMgr.add(self.login, 'login')
taskMgr.doMethodLater(.1, self.heartbeat, 'heartbeat')
# Replace with actual, dynamic list of players from the server
self.players = dict()
# Placeholder, replace with actual # of players later
self.numberOfPlayers = 2
# Stores the OnScreenText for each player in the players list
# Populated and depopulated using listPlayers and delistPlayers
self.playersText = []
# Stores all the player objects currently logged in
self.playerObjects = []
base.win.setClearColor(Vec4(0,0,0,1))
# Post the instructions
#self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
#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.60, "[Q]: Display List Of Connected Players")
# 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)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
ralphStartPos.setY(ralphStartPos.getY()-10)
self.ralph.setPos(ralphStartPos.getX(),ralphStartPos.getY(),ralphStartPos.getZ())
self.initx = ralphStartPos.getX()
# Add our Ralph to list to Ralphs
self.playerObjects.append(self.ralph)
# Load and transform the panda actor.
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.003, 0.003, 0.003)
self.pandaActor.reparentTo(render)
# Loop its animation.
#self.pandaActor.loop("walk")
self.pandaActor.setPos(ralphStartPos.getX(),ralphStartPos.getY()-20,ralphStartPos.getZ())
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", self.disconnect)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
self.accept("q", self.listPlayers)
self.accept("q-up", self.delistPlayers)
taskMgr.add(self.move,"moveTask")
# Call whenever a ralph has logged in, use arg "out" for logouts
self.displayLoginText()
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
# 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.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.pandaActorGroundRay = CollisionRay()
self.pandaActorGroundRay.setOrigin(0,0,1000)
self.pandaActorGroundRay.setDirection(0,0,-1)
self.pandaActorGroundCol = CollisionNode('pandaActorRay')
self.pandaActorGroundCol.addSolid(self.pandaActorGroundRay)
self.pandaActorGroundCol.setFromCollideMask(BitMask32.bit(0))
self.pandaActorGroundCol.setIntoCollideMask(BitMask32.allOff())
self.pandaActorGroundColNp = self.pandaActor.attachNewNode(self.pandaActorGroundCol)
self.pandaActorGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.pandaActorGroundColNp, self.pandaActorGroundHandler)
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()
self.miniMap = miniMap(self.ralph)
self.miniMap.setNpc('tower_1', 'models/hexahedron.png', 0.05, 0.2, 0.3)
self.miniMap.setNpc('tower_2', 'models/hexahedron.png', 0.05, -0.4, -0.5)
# 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))
self.setAI()
from .MapWritable import MapWritable
from src.leveleditor import LEGlobals
from .TransformProperties import OriginProperty, AnglesProperty, ScaleProperty, ShearProperty
from . import MetaData
from .ObjectProperty import ObjectProperty
from src.leveleditor.math.Line import Line
from src.leveleditor.geometry.Box import Box
from src.leveleditor.geometry.GeomView import GeomView
from src.leveleditor.viewport.ViewportType import VIEWPORT_2D_MASK, VIEWPORT_3D_MASK
from enum import IntEnum
BoundsBox3DState = RenderState.make(
ColorAttrib.makeFlat(Vec4(1, 1, 0, 1))
)
BoundsBox2DState = RenderState.make(
ColorAttrib.makeFlat(Vec4(1, 0, 0, 1)),
CullBinAttrib.make("selected-foreground", 0)
)
MapObjectInit = PStatCollector("Arch:CreateSolid:MapObjInit")
# Base class for any object in the map (brush, entity, etc)
class MapObject(MapWritable):
ObjectName = "object"
def __init__(self, id):
def __init__(self):
__builtin__.main = self
self.cManager = ConnectionManager()
self.startConnection()
self.taskMgr = taskMgr
self.base = base
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0
}
self.characters = dict()
self.cpList = dict()
base.win.setClearColor(Vec4(0, 0, 0, 1))
#self.environ = loader.loadModel("models/world")
self.environ = loader.loadModel("models/land")
"""
self.swordLeft = loader.loadModel("models/Sword_Left")
self.swordRight = loader.loadModel("models/Sword_Right")
self.shieldLeft = loader.loadModel("models/Shield_Left")
self.shieldRight = loader.loadModel("models/Shield_Right")
self.money = loader.loadModel("models/Money")
"""
self.left_atk_tower = loader.loadModel("models/attack_tower")
self.left_def_tower = loader.loadModel("models/defense_tower")
self.right_atk_tower = loader.loadModel("models/attack_tower")
self.right_def_tower = loader.loadModel("models/defense_tower")
self.money_cp = loader.loadModel("models/money_point")
self.left_atk_tower.setPos(141.016, 0.440607, 0)
self.left_def_tower.setPos(210.984, 115.005, 0)
self.right_atk_tower.setPos(-149.953, 0.674369, 0)
self.right_def_tower.setPos(-210.771, 113.753, 0)
self.money_cp.setPos(-0.903916, 11.3765, 0)
self.left_atk_tower.setScale(2.0)
self.right_atk_tower.setScale(2.0)
self.left_def_tower.setScale(2.0)
self.right_def_tower.setScale(2.0)
self.money_cp.setScale(2.0)
self.left_atk_tower.reparentTo(render)
self.right_atk_tower.reparentTo(render)
self.left_def_tower.reparentTo(render)
self.right_def_tower.reparentTo(render)
self.money_cp.reparentTo(render)
self.environ.reparentTo(render)
"""
self.swordLeft.reparentTo(render)
self.swordRight.reparentTo(render)
self.shieldLeft.reparentTo(render)
self.shieldRight.reparentTo(render)
self.money.reparentTo(render)
"""
self.environ.setPos(0, 0, 0)
self.environ.setH(90)
"""
self.swordLeft.setH(90)
self.swordRight.setH(90)
self.shieldLeft.setH(90)
self.shieldRight.setH(90)
self.money.setH(90)
"""
mySound = loader.loadSfx("sound/Retribution.mp3")
mySound.setLoop(True)
mySound.play()
fp = FilterProperties()
#fp.addReverb(0.6, 0.5, 0.1, 0.1, 0.1)
base.sfxManagerList[0].configureFilters(fp)
## swordsmanStartPos = self.environ.find("**/start_point").getPos()
## self.player = Swordsman("Swordsman", 0)
## self.player._character.reparentTo(render)
## self.player._character.setScale(.1)
## self.player._character.setPos(swordsmanStartPos)
## swordsmanStartPos.setY(swordsmanStartPos.getY()-10)
## self.player._character.setPos(swordsmanStartPos.getX(),swordsmanStartPos.getY(),swordsmanStartPos.getZ())
## self.initx = swordsmanStartPos.getX()
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
## self.characters["Axeman"] = Axeman("Axeman", 1)
## self.characters["Axeman"]._character.reparentTo(render)
## self.characters["Axeman"]._character.setScale(.1)
## self.characters["Axeman"]._character.setPos(swordsmanStartPos)
## swordsmanStartPos.setY(swordsmanStartPos.getY()-10)
## self.characters["Axeman"]._character.setPos(swordsmanStartPos.getX(),swordsmanStartPos.getY() - 10,swordsmanStartPos.getZ())
## self.characters["Axeman"]._character.loop("idle")
self.accept("a", self.setKey, ["left", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("w", self.setKey, ["forward", 1])
self.accept("d", self.setKey, ["right", 1])
self.accept("a-up", self.setKey, ["left", 0])
self.accept("s-up", self.setKey, ["backward", 0])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("d-up", self.setKey, ["right", 0])
self.accept("arrow_left", self.setKey, ["cam-left", 1])
self.accept("arrow_right", self.setKey, ["cam-right", 1])
self.accept("arrow_left-up", self.setKey, ["cam-left", 0])
self.accept("arrow_right-up", self.setKey, ["cam-right", 0])
self.accept("mouse1", self.attack, [3])
self.accept("mouse3", self.attack, [4])
self.username = str(raw_input("Username: "******"Type: ")
faction = input("Faction: ")
self.cManager.sendRequest(Constants.CMSG_AUTH,
[self.username, type, faction])
#taskMgr.add(self.move,"moveTask")
taskMgr.doMethodLater(.10, self.refresh, "heartbeat")
base.disableMouse()
#base.camera.setPos(self.player._character.getX(),self.player._character.getY()+10,2)
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))
directionalLight2 = DirectionalLight("directionalLight2")
directionalLight2.setDirection(Vec3(5, 5, 5))
directionalLight2.setColor(Vec4(1, 1, 1, 1))
directionalLight2.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
render.setLight(render.attachNewNode(directionalLight2))
Chat(self.cManager)
# Create control points
self.cpList[1] = ControlPoint(1, 210.984, 115.005, -5, 10, RED)
self.cpList[2] = ControlPoint(2, 141.016, 0.440607, -5, 10, RED)
self.cpList[3] = ControlPoint(3, -0.903916, 11.3765, -2, 10, RED)
self.cpList[4] = ControlPoint(4, -210.771, 113.753, -2, 10, BLUE)
self.cpList[5] = ControlPoint(5, -149.953, 0.674369, -2, 10, BLUE)
# Create the control point Bar UI
self.cp_bar = ControlPointBar()
# self.resource_bar = ResourceBar()
taskMgr.doMethodLater(0.1, self.refresh, "heartbeat")
taskMgr.doMethodLater(1, self.CPHandler, "CPHandler")
taskMgr.doMethodLater(0.1, self.CPBarHandler, 'CPBarHandler')
'''NPC Code Additions'''
#self.isChased =[False,False]
#self.npcList = [0,0]
self.isChased = False
self.npcList = 0
self.controlNpc = NPCController(render)
taskMgr.add(self.taskAIUpdate, "AIUpdate")
taskMgr.add(self.moveNpc, "Move")
def __init__(self):
ShowBase.__init__(self)
self.scene = self.loader.loadModel(models_dir + "hallway.bam") # Load the environment model
self.scene.reparentTo(self.render)
self.scene.setScale(1, 1, 1)
self.scene.setPos(0, 0, 1)
self.scene.setHpr(90, 0, 0)
# Add an ambient light and set sky color
sky_col = VBase3(135 / 255.0, 206 / 255.0, 235 / 255.0)
self.set_background_color(sky_col)
alight = AmbientLight("sky")
alight.set_color(VBase4(sky_col * 0.04, 1))
alight_path = self.render.attachNewNode(alight)
self.render.set_light(alight_path)
# # 4 perpendicular lights (flood light)
for light_no in range(4):
d_light = DirectionalLight('directionalLight')
d_light.setColor(Vec4(*([0.3] * 4)))
d_light_NP = self.render.attachNewNode(d_light)
d_light_NP.setHpr(-90 * light_no, 0, 0)
self.render.setLight(d_light_NP)
# # 1 directional light (Sun)
sun_light = DirectionalLight('directionalLight')
sun_light.setColor(Vec4(*([0.7] * 4))) # directional light is dim green
sun_light.getLens().setFilmSize(Vec2(0.8, 0.8))
sun_light.getLens().setNearFar(-0.3, 12)
sun_light.setShadowCaster(True, 2 ** 7, 2 ** 7)
self.dlightNP = self.render.attachNewNode(sun_light)
self.dlightNP.setHpr(0, -65, 0)
# Turning shader and lights on
self.render.setLight(self.dlightNP)
# Load and transform the quadrotor actor.
self.quad_model = self.loader.loadModel(models_dir + f'{quad_model_filename}.egg')
self.prop_models = []
for prop_no in range(4):
prop = self.loader.loadModel(models_dir + 'propeller.egg')
x = 0 if prop_no % 2 == 1 else (-0.26 if prop_no == 0 else 0.26)
y = 0 if prop_no % 2 == 0 else (-0.26 if prop_no == 3 else 0.26)
prop.setPos(x, y, 0)
prop.reparentTo(self.quad_model)
self.prop_models.append(prop)
self.prop_models = tuple(self.prop_models)
# self.quad_model.reparentTo(self.scene)
self.quad_model.setPos(0, 0, 2)
self.quad_neutral_hpr = (90, 0, 0)
self.quad_model.setHpr(*self.quad_neutral_hpr)
# env cam
self.cam_neutral_pos = (0, -4, 3)
self.cam.reparentTo(self.scene)
# self.cam_neutral_pos = (-4, 0, 1)
# self.cam.reparentTo(self.quad_model)
self.cam.setPos(*self.cam_neutral_pos)
self.cam.lookAt(self.quad_model)
self.enableParticles()
node = NodePath("PhysicsNode")
node.reparentTo(self.scene)
self.actor_node = ActorNode("quadrotor-physics")
# self.actor_node.getPhysicsObject().setMass(1)
self.actor_node_physics = node.attachNewNode(self.actor_node)
self.physicsMgr.attachPhysicalNode(self.actor_node)
self.quad_model.reparentTo(self.actor_node_physics)
# add gravity
# gravity_force_node = ForceNode('world-forces')
# gravityForce = LinearVectorForce(0, 0, -0.1) # gravity acceleration
# gravity_force_node.addForce(gravityForce)
# self.physicsMgr.addLinearForce(gravityForce)
self.time = datetime.datetime.today().strftime('%Y-%m-%d-%H.%M.%S')
self.simulation_folder = "\sims\\" + self.time + '\\'
self.simulation_folder_path = ROOT_DIR + self.simulation_folder
os.makedirs(self.simulation_folder_path)
self.movements = ''
self.taskMgr.add(self.camera_move, 'Camera Movement')
self.taskMgr.add(self.quad_move, 'Quad Movement')
self.taskMgr.add(self.rotate_propellers, 'Propellers Rotation')
self.taskMgr.add(self.save_image, 'Screenshot Capture')
# self.buffer: GraphicsBuffer = self.win.makeTextureBuffer(name='buffer', x_size=84, y_size=84, tex=None, to_ram=True)
# self.buffer.setActive(1)
self.images = []
self.image_index = 1
def setup(self):
#self.targetAlt = r.randrange(100,300)
self.Valves = np.array([0.15,0.2,0.15])
self.EngObs = self.vulcain.predict_data_point(np.array(self.Valves).reshape(1,-1))
if self.VISUALIZE is True:
self.worldNP = self.render.attachNewNode('World')
else:
self.root = NodePath(PandaNode("world root"))
self.worldNP = self.root.attachNewNode('World')
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.80665))
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.node().showWireframe(True)
self.debugNP.node().showConstraints(True)
self.debugNP.node().showBoundingBoxes(False)
self.debugNP.node().showNormals(True)
self.debugNP.show()
self.world.setDebugNode(self.debugNP.node())
# self.debugNP.showTightBounds()
# self.debugNP.showBounds()
# Ground (static)
shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
self.groundNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
self.groundNP.node().addShape(shape)
self.groundNP.setPos(0, 0, 0)
self.groundNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.groundNP.node())
# Rocket
shape = BulletCylinderShape(self.radius, self.length, ZUp)
self.rocketNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Cylinder'))
self.rocketNP.node().setMass(27200 * self.scale)
self.rocketNP.node().addShape(shape)
#self.rocketNP.setPos(20,20,250)
self.rocketNP.setPos(r.randrange(-200,200), 20, r.randrange(300, 500))
#self.rocketNP.setPos(r.randrange(-self.lateralError, self.lateralError, 1), r.randrange(-self.lateralError, self.lateralError, 1), self.height)
# self.rocketNP.setPos(0, 0, self.length*10)
self.rocketNP.setCollideMask(BitMask32.allOn())
# self.rocketNP.node().setCollisionResponse(0)
self.rocketNP.node().notifyCollisions(True)
self.world.attachRigidBody(self.rocketNP.node())
for i in range(4):
leg = BulletCylinderShape(0.1 * self.radius, 0.5 * self.length, XUp)
self.rocketNP.node().addShape(leg, TransformState.makePosHpr(
Vec3(6 * self.radius * math.cos(i * math.pi / 2), 6 * self.radius * math.sin(i * math.pi / 2),
-0.6 * self.length), Vec3(i * 90, 0, 30)))
shape = BulletConeShape(0.75 * self.radius, 0.5 * self.radius, ZUp)
self.rocketNP.node().addShape(shape, TransformState.makePosHpr(Vec3(0, 0, -1 / 2 * self.length), Vec3(0, 0, 0)))
# Fuel
self.fuelRadius = 0.9 * self.radius
shape = BulletCylinderShape(self.fuelRadius, 0.01 * self.length, ZUp)
self.fuelNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Cone'))
self.fuelNP.node().setMass(self.fuelMass_full * self.fuelMass_init)
self.fuelNP.node().addShape(shape)
self.fuelNP.setPos(0, 0, self.rocketNP.getPos().getZ() - self.length * 0.5 * (1 - self.fuelMass_init))
self.fuelNP.setCollideMask(BitMask32.allOn())
self.fuelNP.node().setCollisionResponse(0)
self.world.attachRigidBody(self.fuelNP.node())
frameA = TransformState.makePosHpr(Point3(0, 0, 0), Vec3(0, 0, 90))
frameB = TransformState.makePosHpr(Point3(0, 0, 0), Vec3(0, 0, 90))
self.fuelSlider = BulletSliderConstraint(self.rocketNP.node(), self.fuelNP.node(), frameA, frameB, 1)
self.fuelSlider.setTargetLinearMotorVelocity(0)
self.fuelSlider.setDebugDrawSize(2.0)
self.fuelSlider.set_lower_linear_limit(0)
self.fuelSlider.set_upper_linear_limit(0)
self.world.attachConstraint(self.fuelSlider)
self.npThrustForce = LineNodePath(self.rocketNP, 'Thrust', thickness=4, colorVec=Vec4(1, 0.5, 0, 1))
self.npDragForce = LineNodePath(self.rocketNP, 'Drag', thickness=4, colorVec=Vec4(1, 0, 0, 1))
self.npLiftForce = LineNodePath(self.rocketNP, 'Lift', thickness=4, colorVec=Vec4(0, 0, 1, 1))
self.npFuelState = LineNodePath(self.fuelNP, 'Fuel', thickness=20, colorVec=Vec4(0, 1, 0, 1))
self.rocketCSLon = self.radius ** 2 * math.pi
self.rocketCSLat = self.length * 2 * self.radius
if self.VISUALIZE is True:
self.terrain = loader.loadModel("../LZGrid2.egg")
self.terrain.setScale(10)
self.terrain.reparentTo(self.render)
self.terrain.setColor(Vec4(0.1, 0.2, 0.1, 1))
self.toggleTexture()
#self.fuelNP.setPos(0, 0, self.rocketNP.getPos().getZ() - self.length * 0.4 * (1 - self.fuelMass_init))
for i in range(5):
self.world.doPhysics(self.dt, 5, 1.0 / 180.0)
self.fuelSlider.set_lower_linear_limit(-self.length * 0.5 * (1 - self.fuelMass_init))
self.fuelSlider.set_upper_linear_limit(self.length * 0.5 * (1 - self.fuelMass_init))
for i in range(100):
self.world.doPhysics(self.dt, 5, 1.0 / 180.0)
self.rocketNP.node().applyForce(Vec3(0,0,300000), Vec3(0, 0, 0))
def createGuiObjects(self):
self.dayButton = DirectButton(parent=self.dayButtonLocator, image=self.selectedFrame, relief=None, command=self.__clickedOnDay, pressEffect=1, rolloverSound=None, clickSound=None)
self.numberWidget = DirectLabel(parent=self.numberLocator, relief=None, text=str(self.myDate.day), text_scale=0.04, text_align=TextNode.ACenter, text_font=ToontownGlobals.getInterfaceFont(), text_fg=Vec4(110 / 255.0, 126 / 255.0, 255 / 255.0, 1))
self.attachMarker(self.numberLocator)
self.listXorigin = 0
self.listFrameSizeX = self.scrollBottomRightLocator.getX() - self.scrollLocator.getX()
self.scrollHeight = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ()
self.listZorigin = self.scrollBottomRightLocator.getZ()
self.listFrameSizeZ = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ()
self.arrowButtonXScale = 1
self.arrowButtonZScale = 1
self.itemFrameXorigin = 0
self.itemFrameZorigin = 0
self.buttonXstart = self.itemFrameXorigin + 0.21
self.gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui')
buttonOffSet = -0.01
incButtonPos = (0.0, 0, 0)
decButtonPos = (0.0, 0, 0)
itemFrameMinZ = self.listZorigin
itemFrameMaxZ = self.listZorigin + self.listFrameSizeZ
arrowUp = self.find('**/downScroll_up')
arrowDown = self.find('**/downScroll_down')
arrowHover = self.find('**/downScroll_hover')
self.scrollList = DirectScrolledList(parent=self.scrollLocator, relief=None, pos=(0,
0,
0), incButton_image=(arrowUp,
arrowDown,
arrowHover,
arrowUp), incButton_relief=None, incButton_scale=(self.arrowButtonXScale, 1, self.arrowButtonZScale), incButton_pos=incButtonPos, incButton_image3_color=Vec4(1, 1, 1, 0.2), decButton_image=(arrowUp,
arrowDown,
arrowHover,
arrowUp), decButton_relief=None, decButton_scale=(self.arrowButtonXScale, 1, -self.arrowButtonZScale), decButton_pos=decButtonPos, decButton_image3_color=Vec4(1, 1, 1, 0.2), itemFrame_pos=(self.itemFrameXorigin, 0, -0.03), numItemsVisible=4, incButtonCallback=self.scrollButtonPressed, decButtonCallback=self.scrollButtonPressed)
itemFrameParent = self.scrollList.itemFrame.getParent()
self.scrollList.incButton.reparentTo(self.scrollDownLocator)
self.scrollList.decButton.reparentTo(self.scrollUpLocator)
arrowUp.removeNode()
arrowDown.removeNode()
arrowHover.removeNode()
clipper = PlaneNode('clipper')
clipper.setPlane(Plane(Vec3(-1, 0, 0), Point3(0.23, 0, 0)))
clipNP = self.scrollList.component('itemFrame').attachNewNode(clipper)
self.scrollList.component('itemFrame').setClipPlane(clipNP)
return
class LaffMeter(DirectFrame):
deathColor = Vec4(0.58039216, 0.80392157, 0.34117647, 1.0)
def __init__(self, avdna, hp, maxHp):
DirectFrame.__init__(self, relief=None, sortOrder=50)
self.initialiseoptions(LaffMeter)
self.container = DirectFrame(parent=self, relief=None)
self.style = avdna
self.av = None
self.hp = hp
self.maxHp = maxHp
self.__obscured = 0
if self.style.type == 't':
self.isToon = 1
else:
self.isToon = 0
self.load()
return
def obscure(self, obscured):
self.__obscured = obscured
if self.__obscured:
self.hide()
def isObscured(self):
return self.__obscured
def load(self):
gui = loader.loadModel('phase_3/models/gui/laff_o_meter')
if self.isToon:
hType = self.style.getType()
if hType == 'dog':
headModel = gui.find('**/doghead')
elif hType == 'cat':
headModel = gui.find('**/cathead')
elif hType == 'mouse':
headModel = gui.find('**/mousehead')
elif hType == 'horse':
headModel = gui.find('**/horsehead')
elif hType == 'rabbit':
headModel = gui.find('**/bunnyhead')
elif hType == 'duck':
headModel = gui.find('**/duckhead')
elif hType == 'chicken':
headModel = gui.find('**/duckhead')
elif hType == 'monkey':
headModel = gui.find('**/monkeyhead')
elif hType == 'bear':
headModel = gui.find('**/bearhead')
elif hType == 'pig':
headModel = gui.find('**/pighead')
else:
raise StandardError('unknown toon species: ', hType)
self.color = self.style.getHeadColor()
self.container['image'] = headModel
self.container['image_color'] = self.color
self.resetFrameSize()
self.setScale(0.1)
self.frown = DirectFrame(parent=self.container, relief=None, image=gui.find('**/frown'))
self.smile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/smile'))
self.eyes = DirectFrame(parent=self.container, relief=None, image=gui.find('**/eyes'))
self.openSmile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/open_smile'))
self.tooth1 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_1'))
self.tooth2 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_2'))
self.tooth3 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_3'))
self.tooth4 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_4'))
self.tooth5 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_5'))
self.tooth6 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_6'))
self.maxLabel = DirectLabel(parent=self.eyes, relief=None, pos=(0.442, 0, 0.051), text='120', text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont())
self.hpLabel = DirectLabel(parent=self.eyes, relief=None, pos=(-0.398, 0, 0.051), text='120', text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont())
self.teeth = [self.tooth6,
self.tooth5,
self.tooth4,
self.tooth3,
self.tooth2,
self.tooth1]
self.fractions = [0.0,
0.166666,
0.333333,
0.5,
0.666666,
0.833333]
gui.removeNode()
return
def destroy(self):
if self.av:
ToontownIntervals.cleanup(self.av.uniqueName('laffMeterBoing') + '-' + str(self.this))
ToontownIntervals.cleanup(self.av.uniqueName('laffMeterBoing') + '-' + str(self.this) + '-play')
self.ignore(self.av.uniqueName('hpChange'))
del self.style
del self.av
del self.hp
del self.maxHp
if self.isToon:
del self.frown
del self.smile
del self.openSmile
del self.tooth1
del self.tooth2
del self.tooth3
del self.tooth4
del self.tooth5
del self.tooth6
del self.teeth
del self.fractions
del self.maxLabel
del self.hpLabel
DirectFrame.destroy(self)
def adjustTeeth(self):
if self.isToon:
for i in xrange(len(self.teeth)):
if self.hp > self.maxHp * self.fractions[i]:
self.teeth[i].show()
else:
self.teeth[i].hide()
def adjustText(self):
if self.isToon:
if self.maxLabel['text'] != str(self.maxHp) or self.hpLabel['text'] != str(self.hp):
self.maxLabel['text'] = str(self.maxHp)
self.hpLabel['text'] = str(self.hp)
def animatedEffect(self, delta):
if delta == 0 or self.av == None:
return
name = self.av.uniqueName('laffMeterBoing') + '-' + str(self.this)
ToontownIntervals.cleanup(name)
if delta > 0:
ToontownIntervals.start(ToontownIntervals.getPulseLargerIval(self.container, name))
else:
ToontownIntervals.start(ToontownIntervals.getPulseSmallerIval(self.container, name))
return
def adjustFace(self, hp, maxHp, quietly = 0):
if self.isToon and self.hp != None:
self.frown.hide()
self.smile.hide()
self.openSmile.hide()
self.eyes.hide()
for tooth in self.teeth:
tooth.hide()
delta = hp - self.hp
self.hp = hp
self.maxHp = maxHp
if self.hp < 1:
self.frown.show()
self.container['image_color'] = self.deathColor
elif self.hp >= self.maxHp:
self.smile.show()
self.eyes.show()
self.container['image_color'] = self.color
else:
self.openSmile.show()
self.eyes.show()
self.maxLabel.show()
self.hpLabel.show()
self.container['image_color'] = self.color
self.adjustTeeth()
self.adjustText()
if not quietly:
self.animatedEffect(delta)
return
def start(self):
if self.av:
self.hp = self.av.hp
self.maxHp = self.av.maxHp
if self.isToon:
if not self.__obscured:
self.show()
self.adjustFace(self.hp, self.maxHp, 1)
if self.av:
self.accept(self.av.uniqueName('hpChange'), self.adjustFace)
def stop(self):
if self.isToon:
self.hide()
if self.av:
self.ignore(self.av.uniqueName('hpChange'))
def setAvatar(self, av):
if self.av:
self.ignore(self.av.uniqueName('hpChange'))
self.av = av
from panda3d.core import Vec3, Vec4, BitMask32
from direct.showbase.DirectObject import DirectObject
from panda3d.core import BitMask32, CollisionTraverser, CollisionNode, CollisionHandlerQueue, CollisionSphere
from direct.gui.DirectGui import DirectWaitBar
VALID_HIGHLIGHT_COLOR = Vec4(36.0 / 255, 225.0 / 255, 213.0 / 255, 1)
INVALID_HIGHLIGHT_COLOR = Vec4(1, 0, 0, 1)
RIGHT = 0
DOWN = 1
LEFT = 2
UP = 3
DIRECTION_TO_VECTOR = {
RIGHT: Vec3(1, 0, 0),
DOWN: Vec3(0, -1, 0),
LEFT: Vec3(-1, 0, 0),
UP: Vec3(0, 1, 0)
}
SLOW_COLOR = Vec4(0, 0, 1, 0.2)
STUN_COLOR = Vec4(0, 0.5, 0.5, 0.2)
# Parent Class for environment blocks
class Block(DirectObject):
def __init__(self, model, parent, x, y, z=0.5):
self.index = -1
self.tower = 0 # Whether a tower is on top of this block
# Load and position 3D Model
self.model = loader.loadModel('models/' + model)
def update(self, task):
if not self.shouldRender():
self.removeCurrentGrid()
return task.cont
zoom = self.calcZoom()
step = GridSettings.DefaultStep
low = GridSettings.Low
high = GridSettings.High
actualDist = step * zoom
if GridSettings.HideSmallerToggle:
while actualDist < GridSettings.HideSmallerThan:
step *= GridSettings.HideFactor
actualDist *= GridSettings.HideFactor
if step == self.lastStep and self.gridNp:
return task.cont
self.removeCurrentGrid()
self.lastStep = step
if step in self.gridsByStep:
self.gridNp = self.gridsByStep[step].copyTo(self.viewport.gridRoot)
return task.cont
segs = LineSegs()
i = low
while i <= high:
color = GridSettings.GridLines
if i == 0:
# On zero lines, give each axis an appropriate color.
axes = self.viewport.getGridAxes()
color = Vec4(0, 0, 0, 1)
color[axes[0]] = 1
color2 = Vec4(0, 0, 0, 1)
color2[axes[1]] = 1
#elif (i % GridSettings.Highlight2Unit) == 0 and GridSettings.Highlight2Toggle:
# color = GridSettings.Highlight2
elif (i % (step * GridSettings.Highlight1Line) == 0) and GridSettings.Highlight1Toggle:
color = GridSettings.Highlight1
segs.setColor(color)
segs.moveTo(self.viewport.expand(Point3(low, 0, i)))
segs.drawTo(self.viewport.expand(Point3(high, 0, i)))
if i == 0:
segs.setColor(color2)
segs.moveTo(self.viewport.expand(Point3(i, 0, low)))
segs.drawTo(self.viewport.expand(Point3(i, 0, high)))
i += step
#segs.setColor(GridSettings.BoundaryLines)
# top
#segs.moveTo(self.viewport.expand(Point3(low, 0, high)))
#segs.drawTo(self.viewport.expand(Point3(high, 0, high)))
# left
#segs.moveTo(self.viewport.expand(Point3(low, 0, low)))
#segs.drawTo(self.viewport.expand(Point3(low, 0, high)))
# right
#segs.moveTo(self.viewport.expand(Point3(high, 0, low)))
#segs.drawTo(self.viewport.expand(Point3(high, 0, high)))
# bottom
#segs.moveTo(self.viewport.expand(Point3(low, 0, low)))
#segs.drawTo(self.viewport.expand(Point3(high, 0, low)))
np = NodePath(segs.create())
#np.setAntialias(AntialiasAttrib.MLine)
#loader.loadModel("models/smiley.egg.pz").reparentTo(np)
self.gridsByStep[step] = np
self.gridNp = np.copyTo(self.viewport.gridRoot)
return task.cont
def load(self):
Hood.Hood.load(self)
self.whiteFogColor = Vec4(0.80000000000000004, 0.80000000000000004,
0.80000000000000004, 1)
self.underwaterFogColor = Vec4(0.0, 0.0, 0.59999999999999998, 1.0)
def _updateShadowSources(self):
""" Updates the PSSM Frustum and all PSSM Splits """
mixVector = lambda p1, p2, a: ((p2*a) + (p1*(1.0-a)))
pstats_PSSM.start()
# Fetch camera data
camPos = self.pssmTargetCam.getPos()
# Compute frustum points
nearPoint = Point3()
farPoint = Point3()
self.pssmTargetLens.extrude(Point2(0.0), nearPoint, farPoint)
nearPoint = Globals.base.render.getRelativePoint(self.pssmTargetCam, nearPoint)
farPoint = Globals.base.render.getRelativePoint(self.pssmTargetCam, farPoint)
trNearPoint = Point3()
trFarPoint = Point3()
self.pssmTargetLens.extrude(Point2(1.0), trNearPoint, trFarPoint)
trNearPoint = Globals.base.render.getRelativePoint(self.pssmTargetCam, trNearPoint)
trFarPoint = Globals.base.render.getRelativePoint(self.pssmTargetCam, trFarPoint)
# Position the splits
# This is the PSSM split function, currently cubic
splitFunc = lambda x: math.pow(float(x+0.5)/(self.splitCount+0.5), self.pssmSplitPow)
relativeSplitSize = self.pssmFarPlane / self.pssmTargetLens.getFar()
self.updateIndex += 1
self.updateIndex = self.updateIndex % 2
direction = Vec3(self.position)
direction.normalize()
# Process each cascade
for i in xrange(self.splitCount):
source = self.shadowSources[i]
# Find frustum section for this cascade
splitParamStart = splitFunc(i) * relativeSplitSize
splitParamEnd = splitFunc(i+1) * relativeSplitSize
midPos = mixVector(nearPoint, farPoint, (splitParamStart + splitParamEnd) / 2.0 )
topPlanePos = mixVector(trNearPoint, trFarPoint, splitParamEnd )
filmSize = (topPlanePos - midPos).length() * 2.0
midPos += camPos
destPos = midPos + direction * 1.0
# Set source position + rotation
source.setPos(destPos)
source.lookAt(midPos)
source.setFilmSize(filmSize, filmSize)
# Stable CSM Snapping
# This snaps the source to its texel grids, so that there is no flickering
# visible when the source moves. This works by projecting the
# Point (0,0,0) to light space, compute the texcoord differences and
# offset the light world space position by that.
mvp = Mat4(source.computeMVP())
basePoint = mvp.xform(Point4(0,0,0,1))
texelSize = 1.0 / float(source.resolution)
basePoint *= 0.5
basePoint += Vec4(0.5)
offsetX = basePoint.x % texelSize
offsetY = basePoint.y % texelSize
mvp.invertInPlace()
newBase = mvp.xform(Point4(
(basePoint.x - offsetX) * 2.0 - 1.0,
(basePoint.y - offsetY) * 2.0 - 1.0,
(basePoint.z) * 2.0 - 1.0, 1))
destPos -= Vec3(newBase.x, newBase.y, newBase.z)
self.shadowSources[i].setPos(destPos)
# Invalidate the source after changing the position
self.shadowSources[i].invalidate()
pstats_PSSM.stop()
import direct.directbase.DirectStart
from panda3d.core import CollisionTraverser, CollisionNode
from panda3d.core import CollisionHandlerQueue, CollisionRay
from panda3d.core import AmbientLight, DirectionalLight, LightAttrib
from panda3d.core import TextNode
from panda3d.core import Point3, Vec3, Vec4, BitMask32
from direct.gui.OnscreenText import OnscreenText
from direct.showbase.DirectObject import DirectObject
from direct.task.Task import Task
from direct.actor.Actor import Actor
import sys
import random
from direct.gui.DirectGui import *
#First we define some contants for the colors
BLACK = Vec4(0.5, 0.1, 0.1, 1)
WHITE = Vec4(1, 1, 1, 1)
HIGHLIGHT = Vec4(0, 1, 1, 1)
#Now we define some helper functions that we will need later
#This function, given a line (vector plus origin point) and a desired z value,
#will give us the point on the line where the desired z value is what we want.
#This is how we know where to position an object in 3D space based on a 2D mouse
#position. It also assumes that we are dragging in the XY plane.
#
#This is derived from the mathmatical of a plane, solved for a given point
def PointAtZ(z, point, vec):
return point + vec * ((z - point.getZ()) / vec.getZ())
def __init__(self):
GameObject.__init__(self, Vec3(0, 0, 0), None, None, 100, 15, "player",
1, MASK_INTO_PLAYER)
Walker.__init__(self)
ArmedObject.__init__(self)
self.weaponNP = self.actor
light = PointLight("basic light")
light.setColor(Vec4(1, 1, 1, 1))
light.setAttenuation((1, 0.01, 0.005))
self.lightNP = self.root.attachNewNode(light)
self.lightNP.setZ(1)
render.setLight(self.lightNP)
self.collider.node().setFromCollideMask(MASK_WALLS | MASK_FROM_PLAYER)
self.actor.setZ(self.height)
base.camera.reparentTo(self.actor)
base.camera.setPos(0, 0, 0)
base.camera.setHpr(0, 0, 0)
lens = base.camLens
ratio = lens.getAspectRatio()
lens.setFov(80 * ratio)
lens.setNear(0.03)
self.lastMousePos = Vec2(0, 0)
self.mouseSpeedHori = 50.0
self.mouseSpeedVert = 30.0
self.mouseSensitivity = 1.0
self.healthLeft = -0.9
self.healthRight = 0.9
self.healthWidth = self.healthRight - self.healthLeft
self.uiRoot = base.a2dBottomCenter.attachNewNode(
PandaNode("player UI"))
self.healthBar = loader.loadModel("UI/healthBar")
self.healthBar.reparentTo(self.uiRoot)
self.healthBar.setZ(0.05)
self.healthBar.setX(self.healthLeft)
self.healthBar.getChild(0).setScale(self.healthWidth / 6.0)
self.weaponUIRoot = self.uiRoot.attachNewNode(
PandaNode("player weapon UI"))
self.weaponUIRoot.setPos(0, 0, 0.1)
self.addWeapon(RapidShotgunWeapon(self.weaponUIRoot))
self.addWeapon(BlasterWeapon(self.weaponUIRoot))
self.weapons[0].setAvailable(True)
self.setCurrentWeapon(0)
self.updateHealthUI()
self.inventory = []
self.updatingEffects = []
self.interactionSegment = CollisionSegment(0, 0, 0, 0, 1.5, 0)
rayNode = CollisionNode("player interaction ray")
rayNode.addSolid(self.interactionSegment)
rayNode.setFromCollideMask(MASK_WALLS | MASK_FLOORS | MASK_INTO_ENEMY)
rayNode.setIntoCollideMask(0)
self.interactionSegmentNodePath = self.actor.attachNewNode(rayNode)
#self.interactionSegmentNodePath.show()
self.interactionSegmentQueue = CollisionHandlerQueue()
self.interactionSegmentTraverser = CollisionTraverser()
self.interactionSegmentTraverser.addCollider(
self.interactionSegmentNodePath, self.interactionSegmentQueue)
def __init__(self):
self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0}
base.win.setClearColor(Vec4(0, 0, 0, 1))
# number of collectibles
self.numObjects = 10
# print the number of objects
printNumObj(self.numObjects)
# Post the instructions
self.title = addTitle("Roaming Ralph (Edited by Adam Gressen)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[A]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[D]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[W]: Run Ralph Forward")
self.inst5 = addInstructions(0.75, "[S]: Run Ralph Backward")
self.inst6 = addInstructions(0.70, "[Space]: Run, Ralph, Run")
# 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)
# Timer to increment in the move task
self.time = 0
# Get bounds of environment
min, max = self.environ.getTightBounds()
self.mapSize = max - min
# Create the main character, Ralph
self.ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(self.ralphStartPos)
# ralph's health
self.health = 100
# ralph's stamina
self.stamina = 100
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
# these don't work well in combination with the space bar
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
self.accept("arrow_up", self.setKey, ["forward", 1])
self.accept("arrow_down", self.setKey, ["backward", 1])
self.accept("arrow_left-up", self.setKey, ["left", 0])
self.accept("arrow_right-up", self.setKey, ["right", 0])
self.accept("arrow_up-up", self.setKey, ["forward", 0])
self.accept("arrow_down-up", self.setKey, ["backward", 0])
self.accept("space", self.runRalph, [True])
self.accept("space-up", self.runRalph, [False])
self.accept("a", self.setKey, ["left", 1])
self.accept("d", self.setKey, ["right", 1])
self.accept("w", self.setKey, ["forward", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("a-up", self.setKey, ["left", 0])
self.accept("d-up", self.setKey, ["right", 0])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("s-up", self.setKey, ["backward", 0])
# Game state variables
self.isMoving = False
self.isRunning = False
# Set up the camera
base.disableMouse()
#base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
base.camera.setPos(0, 0, 0)
base.camera.reparentTo(self.ralph)
base.camera.setPos(0, 40, 2)
base.camera.lookAt(self.ralph)
# 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.
base.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 300)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
# camera ground collision handler
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 300)
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()
base.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Place the health items
self.placeHealthItems()
# Place the collectibles
self.placeCollectibles()
# Uncomment this line to show a visual representation of the
# collisions occuring
#base.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))
taskMgr.add(self.move, "moveTask")
taskMgr.doMethodLater(0.5, self.healthDec, "healthTask")
def set_clear_color(self, *args):
""" Sets the clear color """
self._internal_buffer.set_clear_color_active(True)
self._internal_buffer.set_clear_color(Vec4(*args))
MinniesMelodyland: 2,
GoofySpeedway: 2,
TheBrrrgh: 2,
DaisyGardens: 2,
FunnyFarm: 2,
DonaldsDreamland: 2,
OutdoorZone: 2,
BossbotHQ: 2,
SellbotHQ: 43,
CashbotHQ: 2,
LawbotHQ: 2,
GolfZone: 2,
PartyHood: 2
}
TrophyStarLevels = (10, 20, 30, 50, 75, 100)
TrophyStarColors = (Vec4(0.9, 0.6, 0.2, 1), Vec4(0.9, 0.6, 0.2,
1), Vec4(0.8, 0.8, 0.8, 1),
Vec4(0.8, 0.8, 0.8, 1), Vec4(1, 1, 0, 1), Vec4(1, 1, 0, 1))
MickeySpeed = 5.0
VampireMickeySpeed = 1.15
MinnieSpeed = 3.2
WitchMinnieSpeed = 1.8
DonaldSpeed = 3.68
FrankenDonaldSpeed = 0.9
DaisySpeed = 2.3
GoofySpeed = 5.2
SuperGoofySpeed = 1.6
PlutoSpeed = 5.5
WesternPlutoSpeed = 3.2
ChipSpeed = 3
DaleSpeed = 3.5
def makeObject(self, point_cloud):
self.set_node_p3d(
custom_geometry.create_colored_polygon2d_GeomNode_from_point_cloud(
point_cloud, color_vec4=Vec4(1., 1., 1., 1.)))
self.set_p3d_nodepath(self.getParent_p3d().attachNewNode_p3d(
self.p3d_node))
def update(self):
""" Updates the commonly used resources, mostly the shader inputs """
update = self._input_ubo.update_input
# Get the current transform matrix of the camera
view_mat = Globals.render.get_transform(self._showbase.cam).get_mat()
# Compute the view matrix, but with a z-up coordinate system
zup_conversion = Mat4.convert_mat(CS_zup_right, CS_yup_right)
update("view_mat_z_up", view_mat * zup_conversion)
# Compute the view matrix without the camera rotation
view_mat_billboard = Mat4(view_mat)
view_mat_billboard.set_row(0, Vec3(1, 0, 0))
view_mat_billboard.set_row(1, Vec3(0, 1, 0))
view_mat_billboard.set_row(2, Vec3(0, 0, 1))
update("view_mat_billboard", view_mat_billboard)
update("camera_pos", self._showbase.camera.get_pos(Globals.render))
# Compute last view projection mat
curr_vp = self._input_ubo.get_input("view_proj_mat_no_jitter")
update("last_view_proj_mat_no_jitter", curr_vp)
curr_vp = Mat4(curr_vp)
curr_vp.invert_in_place()
curr_inv_vp = curr_vp
update("last_inv_view_proj_mat_no_jitter", curr_inv_vp)
proj_mat = Mat4(self._showbase.camLens.get_projection_mat())
# Set the projection matrix as an input, but convert it to the correct
# coordinate system before.
proj_mat_zup = Mat4.convert_mat(CS_yup_right, CS_zup_right) * proj_mat
update("proj_mat", proj_mat_zup)
# Set the inverse projection matrix
update("inv_proj_mat", invert(proj_mat_zup))
# Remove jitter and set the new view projection mat
proj_mat.set_cell(1, 0, 0.0)
proj_mat.set_cell(1, 1, 0.0)
update("view_proj_mat_no_jitter", view_mat * proj_mat)
# Store the frame delta
update("frame_delta", Globals.clock.get_dt())
update("smooth_frame_delta",
1.0 / max(1e-5, Globals.clock.get_average_frame_rate()))
update("frame_time", Globals.clock.get_frame_time())
# Store the current film offset, we use this to compute the pixel-perfect
# velocity, which is otherwise not possible. Usually this is always 0
# except when SMAA and reprojection is enabled
update("current_film_offset", self._showbase.camLens.get_film_offset())
update("frame_index", Globals.clock.get_frame_count())
# Compute frustum corners in the order BL, BR, TL, TR
ws_frustum_directions = Mat4()
vs_frustum_directions = Mat4()
inv_proj_mat = Globals.base.camLens.get_projection_mat_inv()
view_mat_inv = Mat4(view_mat)
view_mat_inv.invert_in_place()
for i, point in enumerate(((-1, -1), (1, -1), (-1, 1), (1, 1))):
result = inv_proj_mat.xform(Vec4(point[0], point[1], 1.0, 1.0))
vs_dir = (zup_conversion.xform(result)).xyz.normalized()
vs_frustum_directions.set_row(i, Vec4(vs_dir, 1))
ws_dir = view_mat_inv.xform(Vec4(result.xyz, 0))
ws_frustum_directions.set_row(i, ws_dir)
update("vs_frustum_directions", vs_frustum_directions)
update("ws_frustum_directions", ws_frustum_directions)
update("screen_size", Globals.resolution)
update("native_screen_size", Globals.native_resolution)
update("lc_tile_count", self._pipeline.light_mgr.num_tiles)
def start(self):
base.transitions.fadeOut(t=0)
self.setColorScale(Vec4(1, 1, 1, 1))
if self.fadeTrack is not None:
self.fadeTrack.finish()
self.fadeTrack = None
self.fadeTrack = base.transitions.getFadeInIval(t=2)
self.fadeTrack.start()
if self.logoScaleTrack is not None:
self.logoScaleTrack.finish()
self.logoScaleTrack = None
self.logoScaleTrack = Sequence(
LerpScaleInterval(self.logo,
2,
Vec3(1.1, 1, 0.55),
Vec3(1, 1, 0.5),
blendType='easeInOut'),
LerpScaleInterval(self.logo,
2,
Vec3(1, 1, 0.5),
Vec3(1.1, 1, 0.55),
blendType='easeInOut'))
if self.logoPosTrack is not None:
self.logoPosTrack.finish()
self.logoPosTrack = None
self.logoPosTrack = Sequence(
LerpPosInterval(self.logo,
2,
Point3(0, 0, -0.85),
Point3(0, 0, -0.7),
blendType='easeOut'),
Func(self.logoScaleTrack.loop))
self.logoPosTrack.start()
if self.labelColorScaleTrack is not None:
self.labelColorScaleTrack.finish()
self.labelColorScaleTrack = None
self.labelColorScaleTrack = Sequence(
LerpColorScaleInterval(self.label, 1, Vec4(1, 1, 1, 0.6),
Vec4(1, 1, 1, 1)),
LerpColorScaleInterval(self.label, 1, Vec4(1, 1, 1, 1),
Vec4(1, 1, 1, 0.6)))
if self.labelPosTrack is not None:
self.labelPosTrack.finish()
self.labelPosTrack = None
self.labelPosTrack = Sequence(
LerpPosInterval(self.label,
2,
Point3(0, 0, 0.35),
Point3(0, 0, 0.15),
blendType='easeOut'),
Func(self.labelColorScaleTrack.loop))
self.labelPosTrack.start()
self.acceptOnce('mouse1', self.begin)
boxBody.setPosition(boxNP.getPos(render))
boxBody.setQuaternion(boxNP.getQuat(render))
# Create a BoxGeom
boxGeom = OdeBoxGeom(space, 1, 1, 1)
boxGeom.setCollideBits(BitMask32(0x00000002))
boxGeom.setCategoryBits(BitMask32(0x00000001))
boxGeom.setBody(boxBody)
boxes.append((boxNP, boxBody))
# Add a plane to collide with
cm = CardMaker("ground")
cm.setFrame(-20, 20, -20, 20)
ground = render.attachNewNode(cm.generate())
ground.setPos(0, 0, 0)
ground.lookAt(0, 0, -1)
groundGeom = OdePlaneGeom(space, Vec4(0, 0, 1, 0))
# groundGeom.setCollideBits(BitMask32(0x00000001))
# groundGeom.setCategoryBits(BitMask32(0x00000002))
# Set the camera position
base.disableMouse()
base.camera.setPos(40, 40, 20)
base.camera.lookAt(0, 0, 0)
# The task for our simulation
def simulationTask(task):
space.autoCollide() # Setup the contact joints
# Step the simulation and set the new positions
world.quickStep(globalClock.getDt())
for np, body in boxes:
def __init__(self, name='glow', amount=0, red=100, green=100, blue=100):
print "Glow enabled!"
## Glow by Adam Bell ([email protected])
## with some original code from Kwasi Mensah ([email protected])
## for PandaCamp (code.google.com/p/pandacamp/)
#The shader is important (but yet a variable).
## The next part I'll replace with a single file as soon
## as I can work with variables in the *.SHA files.
redd = red / 100
greend = green / 100
blued = blue / 100
if amount == 0:
print "glowShader set to it's default value of 1."
amount = 1
## Custom number for a positive non-integer or above 4.
if amount > 0:
### NOTE: the line below is an RGB
render.setShaderInput('amnt', amount * redd, amount * greend,
amount * blued, amount)
print "glowShader set as " + str(amount) + "!"
if amount < 0:
raise TypeError('Only positive numbers work for the glowShader!')
# except that only the glowing materials should show up nonblack.
base.disableMouse()
glowBuffer = base.win.makeTextureBuffer("Glow scene", 512, 512)
glowBuffer.setSort(-3)
glowBuffer.setClearColor(Vec4(0, 0, 0, 1))
glowCamera = base.makeCamera(glowBuffer,
lens=base.cam.node().getLens())
# Tell the glow camera to use the glow shader
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(
loader.loadShader('/c/panda/pandacamp/src/shaders/glowShader.sha'))
## Was 'Shader.load'
glowCamera.node().setInitialState(tempnode.getState())
# X and Y shaders to make the earlier "glowShader.sha" work (or effective).
blurXBuffer = makeFilterBuffer(
glowBuffer, "Blur X", -2,
"/c/panda/pandacamp/src/shaders/XBlurShader.sha")
blurYBuffer = makeFilterBuffer(
blurXBuffer, "Blur Y", -1,
"/c/panda/pandacamp/src/shaders/YBlurShader.sha")
self.finalcard = blurYBuffer.getTextureCard()
self.finalcard.reparentTo(render2d)
self.finalcard.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setLayout("hline")
base.bufferViewer.setCardSize(0.652, 0)
def __init__(self):
ShowBase.__init__(self)
#renaming properties
properties = WindowProperties()
#set windows size property
properties.setSize(1000, 750)
#activate the property to the current window
self.win.requestProperties(properties)
#Calling one of Panda's lighting functions and naming it
ambientLight = AmbientLight("ambient light")
#setting the colour
ambientLight.setColor(Vec4(1, 1, 1, 1))
#creating a lighting node and adding it to the render list (doesn't do anything yet)
self.ambientLightNodePath = self.render.attachNewNode(ambientLight)
#We need to also use the setLight function to actually light the scene
self.render.setLight(self.ambientLightNodePath)
#choose shader
self.render.setShaderAuto()
#gather main camera generated by showbase
self.first_person_camera_node = self.cam
self.mouseLook = FirstPersonCamera(self, self.first_person_camera_node,
self.render)
lens = OrthographicLens()
lens.setFilmSize(2, 2) # Or whatever is appropriate for your scene
self.spot_camera = Camera("Spot Camera")
self.spot_camera.setLens(lens)
self.spot_camera_node = self.render.attachNewNode(self.spot_camera)
self.spot_camera_node.node().setLens(lens)
self.spot_camera_node.setName("Spot Camera")
self.spot_camera_node.setPos(2, 0, 0)
self.spot_camera_node.lookAt(0, 0, 0)
dr = base.camNode.getDisplayRegion(0)
dr.setActive(0)
window = dr.getWindow()
dr1 = window.makeDisplayRegion(0, 0.8, 0, 1)
dr1.setSort(dr.getSort())
dr2 = window.makeDisplayRegion(0.8, 0.9, 0.2, 0.4)
dr2.setSort(dr.getSort())
dr1.setCamera(self.first_person_camera_node)
dr2.setCamera(self.spot_camera_node)
axes = self.createAxes(2)
axes.reparentTo(self.render)
self.Line = self.render.attachNewNode(LineSegs().create())
self.taskMgr.add(self.update, "Update")
def setup(self):
#self.targetAlt = r.randrange(100,300)
self.Valves = np.array([0.15, 0.2, 0.15])
self.EngObs = self.vulcain.predict_data_point(
np.array(self.Valves).reshape(1, -1))
if self.VISUALIZE is True:
self.worldNP = self.render.attachNewNode('World')
else:
self.root = NodePath(PandaNode("world root"))
self.worldNP = self.root.attachNewNode('World')
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.80665))
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.node().showWireframe(True)
self.debugNP.node().showConstraints(True)
self.debugNP.node().showBoundingBoxes(False)
self.debugNP.node().showNormals(True)
self.debugNP.show()
self.world.setDebugNode(self.debugNP.node())
# self.debugNP.showTightBounds()
# self.debugNP.showBounds()
# Ground (static)
shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
self.groundNP = self.worldNP.attachNewNode(
BulletRigidBodyNode('Ground'))
self.groundNP.node().addShape(shape)
self.groundNP.setPos(0, 0, 0)
self.groundNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.groundNP.node())
# Rocket
shape = BulletCylinderShape(self.radius, self.length, ZUp)
self.rocketNP = self.worldNP.attachNewNode(
BulletRigidBodyNode('Cylinder'))
self.rocketNP.node().setMass(self.drymass + self.fuelAmount_LH2 +
self.fuelAmount_LOX)
self.rocketNP.node().addShape(shape)
#self.rocketNP.setPos(20,20,250)
self.rocketNP.setPos(r.randrange(-200, 200), 20,
350) #r.randrange(300, 500))
#self.rocketNP.setPos(r.randrange(-self.lateralError, self.lateralError, 1), r.randrange(-self.lateralError, self.lateralError, 1), self.height)
# self.rocketNP.setPos(0, 0, self.length*10)
self.rocketNP.setCollideMask(BitMask32.allOn())
# self.rocketNP.node().setCollisionResponse(0)
self.rocketNP.node().notifyCollisions(True)
self.world.attachRigidBody(self.rocketNP.node())
for i in range(4):
leg = BulletCylinderShape(0.1 * self.radius, 0.5 * self.length,
XUp)
self.rocketNP.node().addShape(
leg,
TransformState.makePosHpr(
Vec3(6 * self.radius * math.cos(i * math.pi / 2),
6 * self.radius * math.sin(i * math.pi / 2),
-0.6 * self.length), Vec3(i * 90, 0, 30)))
shape = BulletConeShape(0.75 * self.radius, 0.5 * self.radius, ZUp)
self.rocketNP.node().addShape(
shape,
TransformState.makePosHpr(Vec3(0, 0, -1 / 2 * self.length),
Vec3(0, 0, 0)))
self.npThrustForce = LineNodePath(self.rocketNP,
'Thrust',
thickness=4,
colorVec=Vec4(1, 0.5, 0, 1))
self.npDragForce = LineNodePath(self.rocketNP,
'Drag',
thickness=4,
colorVec=Vec4(1, 0, 0, 1))
self.npLiftForce = LineNodePath(self.rocketNP,
'Lift',
thickness=4,
colorVec=Vec4(0, 0, 1, 1))
self.rocketCSLon = self.radius**2 * math.pi
self.rocketCSLat = self.length * 2 * self.radius
if self.VISUALIZE is True:
self.terrain = loader.loadModel("../LZGrid2.egg")
self.terrain.setScale(10)
self.terrain.reparentTo(self.render)
self.terrain.setColor(Vec4(0.1, 0.2, 0.1, 1))
self.toggleTexture()
def __setattr__(self, name, value):
if name == 'enabled':
try:
# try calling on_enable() on classes inheriting from Entity
if value == True:
self.on_enable()
else:
self.on_disable()
except:
pass
if value == True:
if not self.is_singleton():
self.unstash()
else:
if not self.is_singleton():
self.stash()
if name == 'eternal':
for c in self.children:
c.eternal = value
if name == 'world_parent':
self.reparent_to(value)
if name == 'model':
if value is None:
if hasattr(self, 'model') and self.model:
self.model.removeNode()
# print('removed model')
object.__setattr__(self, name, value)
return None
if isinstance(value, NodePath): # pass procedural model
if self.model is not None and value != self.model:
self.model.removeNode()
object.__setattr__(self, name, value)
elif isinstance(value, str): # pass model asset name
m = load_model(value, application.asset_folder)
if not m:
m = load_model(
value, application.internal_models_compressed_folder)
if m:
if self.model is not None:
self.model.removeNode()
object.__setattr__(self, name, m)
if isinstance(m, Mesh):
m.recipe = value
# print('loaded model successively')
else:
print('missing model:', value)
return
if self.model:
self.model.reparentTo(self)
self.model.setTransparency(TransparencyAttrib.M_dual)
self.color = self.color # reapply color after changing model
self.texture = self.texture # reapply texture after changing model
self._vert_cache = None
if isinstance(value, Mesh):
if hasattr(value, 'on_assign'):
value.on_assign(assigned_to=self)
return
if name == 'color' and value is not None:
if not isinstance(value, Vec4):
value = Vec4(value[0], value[1], value[2], value[3])
if self.model:
self.model.setColorScaleOff(
) # prevent inheriting color from parent
self.model.setColorScale(value)
object.__setattr__(self, name, value)
if name == 'texture_scale':
if self.model and self.texture:
self.model.setTexScale(TextureStage.getDefault(), value[0],
value[1])
if name == 'texture_offset':
if self.model and self.texture:
self.model.setTexOffset(TextureStage.getDefault(), value[0],
value[1])
self.texture = self.texture
if name == 'collision' and hasattr(self, 'collider') and self.collider:
if value:
self.collider.node_path.unstash()
else:
self.collider.node_path.stash()
object.__setattr__(self, name, value)
return
if name == 'render_queue':
if self.model:
self.model.setBin('fixed', value)
if name == 'double_sided':
self.setTwoSided(value)
if name == 'always_on_top' and value:
self.set_bin("fixed", 0)
self.set_depth_write(False)
self.set_depth_test(False)
try:
super().__setattr__(name, value)
except:
pass
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up": False,
"down": False,
"left": False,
"right": False,
"shoot": False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.pusher = CollisionHandlerPusher()
self.cTrav = CollisionTraverser()
self.pusher.setHorizontal(True)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
self.updateTask = taskMgr.add(self.update, "update")
self.player = Player()
self.tempEnemy = WalkingEnemy(Vec3(5, 0, 0))
def rgbPanel(nodePath, callback=None, style='mini'):
def onRelease(r, g, b, a, nodePath=nodePath):
messenger.send('RGBPanel_setColor', [nodePath, r, g, b, a])
def popupColorPicker():
# Can pass in current color with: color = (255, 0, 0)
color = askcolor(
parent=vgp.interior(),
# Initialize it to current color
initialcolor=tuple(vgp.get()[:3]))[0]
if color:
vgp.set((color[0], color[1], color[2], vgp.getAt(3)))
def printToLog():
c = nodePath.getColor()
print("Vec4(%.3f, %.3f, %.3f, %.3f)" % (c[0], c[1], c[2], c[3]))
# Check init color
if nodePath.hasColor():
initColor = nodePath.getColor() * 255.0
else:
initColor = Vec4(255)
# Create entry scale group
vgp = ValuatorGroupPanel(
title='RGBA Panel: ' + nodePath.getName(),
dim=4,
labels=['R', 'G', 'B', 'A'],
value=[
int(initColor[0]),
int(initColor[1]),
int(initColor[2]),
int(initColor[3])
],
type='slider',
valuator_style=style,
valuator_min=0,
valuator_max=255,
valuator_resolution=1,
# Destroy not withdraw panel on dismiss
fDestroy=1)
# Update menu button
vgp.component('menubar').component('Valuator Group-button')['text'] = (
'RGBA Panel')
# Set callback
vgp['postCallback'] = onRelease
# Add a print button which will also serve as a color tile
pButton = Button(vgp.interior(),
text='Print to Log',
bg=getTkColorString(initColor),
command=printToLog)
pButton.pack(expand=1, fill=BOTH)
# Update menu
menubar = vgp.component('menubar')
menubar.deletemenuitems('Valuator Group', 1, 1)
# Some helper functions
# Clear color
menubar.addmenuitem('Valuator Group',
'command',
label='Clear Color',
command=lambda: nodePath.clearColor())
# Set Clear Transparency
menubar.addmenuitem('Valuator Group',
'command',
label='Set Transparency',
command=lambda: nodePath.setTransparency(1))
menubar.addmenuitem('Valuator Group',
'command',
label='Clear Transparency',
command=lambda: nodePath.clearTransparency())
# System color picker
menubar.addmenuitem('Valuator Group',
'command',
label='Popup Color Picker',
command=popupColorPicker)
menubar.addmenuitem('Valuator Group',
'command',
label='Print to log',
command=printToLog)
menubar.addmenuitem('Valuator Group',
'command',
'Dismiss Valuator Group panel',
label='Dismiss',
command=vgp.destroy)
def setNodePathColor(color):
nodePath.setColor(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0,
color[3] / 255.0)
# Update color chip button
pButton['bg'] = getTkColorString(color)
# Execute callback to pass along color info
if callback:
callback(color)
vgp['command'] = setNodePathColor
return vgp
