def plot_xy_vs_t(self):
then = self.now
if self.now == 0:
then = time.time()
self.now = time.time()
#print self.now
dt = (self.now - then) / 10
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
y_mag = event_mag
#print('forward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('forward', self.y_mag)
elif event_name == 'moveBackward':
y_mag = -event_mag
#print('backward', y_mag)
self.y_mag = (y_mag * self.gain) - self.offset
#print('backward', self.y_mag)
elif event_name == 'turnRight':
x_mag = event_mag
#print('right', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('right', self.x_mag)
elif event_name == 'turnLeft':
x_mag = -event_mag
#print('left', x_mag)
self.x_mag = (x_mag * self.gain) + self.offset
#print('left', self.x_mag)
plot_x = LineSegs()
plot_x.setThickness(2.0)
plot_x.setColor(Vec4(1, 1, 0, 1))
plot_x.moveTo(self.time, 0, self.old_x)
plot_y = LineSegs()
plot_y.setThickness(2.0)
plot_y.setColor(Vec4(1, 0, 0, 1))
plot_y.moveTo(self.time, 0, self.old_y)
self.time += dt
#print('dt', dt)
#print('time', self.time)
plot_x.drawTo(self.time, 0, self.x_mag)
node = base.render2d.attach_new_node(plot_x.create(True))
self.plot.append(node)
plot_y.drawTo(self.time, 0, self.y_mag)
node = base.render2d.attach_new_node(plot_y.create(True))
self.plot.append(node)
self.old_x = self.x_mag
self.old_y = self.y_mag
if self.time > 1:
self.clear_plot()
def plot_eye_trace(self, first_eye):
# print 'plot trace'
# if plotting too many eye positions, things slow down and
# python goes into lala land. Never need more than 500, and
# last 300 is definitely plenty, so every time it hits 500,
# get rid of first 200.
if len(self.eye_nodes) > 500:
# print('get rid of eye nodes', len(self.eye_nodes))
# Since this just removes the node, but doesn't delete
# the object in the list, can do this in a for loop,
for index in range(200):
self.eye_nodes[index].removeNode()
# now get rid of the empty nodes in eye_nodes
# print('new length', len(self.eye_nodes))
self.eye_nodes = self.eye_nodes[200:]
# print('new length', len(self.eye_nodes))
eye = LineSegs()
# eye.setThickness(2.0)
eye.setThickness(2.0)
# print 'last', last_eye
# print 'now', self.current_eye_data
eye.moveTo(first_eye[0], 55, first_eye[1])
for data_point in self.current_eye_data:
eye.drawTo(data_point[0], 55, data_point[1])
# print('plotted eye', eye_data_to_plot)
node = self.base.render.attachNewNode(eye.create(True))
node.show(BitMask32.bit(0))
node.hide(BitMask32.bit(1))
self.eye_nodes.append(node)
def createMoveVis(self):
# Instance each selected map object to the vis root
for obj in base.selectionMgr.selectedObjects:
instRoot = NodePath("instRoot")
inst = obj.np.instanceTo(instRoot)
instRoot.wrtReparentTo(self.toolVisRoot)
self.xformObjects.append((obj, instRoot, inst))
# Show an infinite line along the axis we are moving the object
# if we are using the 3D view
if self.widget.activeAxis:
axis = self.widget.activeAxis.axisIdx
segs = LineSegs()
col = Vec4(0, 0, 0, 1)
col[axis] = 1.0
segs.setColor(col)
p = Point3(0)
p[axis] = -1000000
segs.moveTo(p)
p[axis] = 1000000
segs.drawTo(p)
self.axis3DLines = self.toolRoot.attachNewNode(segs.create())
self.axis3DLines.setLightOff(1)
self.axis3DLines.setFogOff(1)
self.widget.stash()
def drawBBox(self, scnObj):
ls = LineSegs()
x, y, z = scnObj.pos
rx, rz, ry = scnObj.radius
ls.setThickness(5)
ls.setColor(1, 0.4, 0.0, 0.3)
ls.moveTo(x, y, z)
ls.drawTo(x + rx, y + ry, z + rz)
ls.drawTo(x + rx, y - ry, z + rz)
ls.drawTo(x - rx, y - ry, z + rz)
ls.drawTo(x - rx, y + ry, z + rz)
ls.drawTo(x + rx, y + ry, z + rz)
ls.moveTo(x, y, z)
ls.drawTo(x + rx, y + ry, z - rz)
ls.drawTo(x + rx, y - ry, z - rz)
ls.drawTo(x - rx, y - ry, z - rz)
ls.drawTo(x - rx, y + ry, z - rz)
ls.drawTo(x + rx, y + ry, z - rz)
linegeomn = ls.create(dynamic=False)
np = self.render.attachNewNode(linegeomn)
scnObj.setNodePath(
np) # Rotation should occure ere, TODO but maybe it shouldnt
def plot_xy(self):
joy_in = self.js.getEvents()
if joy_in:
#print type(joy_in)
for event_name in joy_in:
#print event_name
event = joy_in[event_name]
#print event
#print type(event)
#print inspect.getmembers(event, predicate=inspect.ismethod)
event_mag = event.getMagnitude()
if event_name == 'moveForward':
self.y_mag = event_mag
print('forward', self.y_mag)
elif event_name == 'moveBackward':
self.y_mag = -event_mag
print('backward', self.y_mag)
elif event_name == 'turnRight':
self.x_mag = event_mag
print('right', self.x_mag)
elif event_name == 'turnLeft':
self.x_mag = -event_mag
print('left', self.x_mag)
plot_xy = LineSegs()
plot_xy.setThickness(2.0)
plot_xy.setColor(Vec4(1, 1, 0, 1))
plot_xy.moveTo(self.old_x, 0, self.old_y)
plot_xy.drawTo(self.x_mag, 0, self.y_mag)
base.render2d.attach_new_node(plot_xy.create(True))
self.old_x = self.x_mag
self.old_y = self.y_mag
def procedural_sight(line_seg, lower_level, engaged):
sight_width = 0.25
sight_tick = 0.1
x0 = -sight_width / 2
z0 = sight_tick
sight_lower = -0.23
sight_upper = 0.23
if line_seg is None:
line_seg = LineSegs()
if lower_level:
sight_level = sight_lower
m = 1
else:
sight_level = sight_upper
m = -1
if engaged:
x_eng = 0.07
z_eng = 0.07
else:
x_eng = 0
z_eng = 0
line_seg.moveTo(x0 + x_eng, 0, m * z0 + sight_level + m * z_eng)
line_seg.draw_to(x0, 0, sight_level)
line_seg.draw_to(x0 + sight_width, 0, 0 + sight_level)
line_seg.draw_to(x0 + sight_width - x_eng, 0,
m * z0 + sight_level + m * z_eng)
# outer - central lines
line_seg.moveTo(0, 0, 0 + sight_level)
line_seg.draw_to(0, 0, 0 + sight_level - m * 0.25)
return line_seg
def update_LFP(self, dt, last_lfp, lfp_trace, offset, gen_lfp):
# lfp data is taken at 1000Hz, and dt is the number of seconds since
# the last frame was flipped, so plot number of points = dt * 1000
lfp = LineSegs()
lfp.setThickness(1.0)
#print('points to plot', int(dt * 1000))
#self.lfp_test += int(dt * 1000)
#print('points so far', self.lfp_test)
for i in range(int(dt * 1000)):
try:
last_lfp.append((next(gen_lfp) * self.lfp_gain) + offset)
#last_lfp_x += 0.05
# only plotting 200 data points at a time
while len(last_lfp) > 3500:
last_lfp.pop(0)
except StopIteration:
#print('done with lfp')
break
if lfp_trace:
lfp_trace[0].removeNode()
lfp_trace.pop(0)
lfp.moveTo(self.start_x_trace, 55, last_lfp[0])
x = self.start_x_trace
for i in last_lfp:
x += .1
lfp.drawTo(x, 55, i)
node = self.base.pixel2d.attachNewNode(lfp.create())
lfp_trace.append(node)
def add_line(self, start_p: Union[Vec3, Tuple], end_p: Union[Vec3, Tuple],
color, thickness: float):
line_seg = LineSegs("interface")
line_seg.setColor(*color)
line_seg.moveTo(start_p)
line_seg.drawTo(end_p)
line_seg.setThickness(thickness)
NodePath(line_seg.create(False)).reparentTo(self.render)
def create(self, s):
segs = LineSegs( )
segs.setThickness( 2.0 )
segs.setColor( Vec4(1,0,0,1) )
segs.moveTo( s.points[0] )
for p in s.points[1:]:
segs.drawTo( p )
return segs.create( )
def plot_zero_lines(self):
plot_zero = LineSegs()
plot_zero.setThickness(2.0)
plot_zero.setColor(Vec4(1, 0, 1, 1))
plot_zero.moveTo(-1, 0, self.x_mag)
plot_zero.drawTo(1, 0, self.x_mag)
plot_zero.moveTo(-1, 0, self.y_mag)
plot_zero.drawTo(1, 0, self.y_mag)
base.render2d.attach_new_node(plot_zero.create(True))
def draw_edge(self,e,e_color):
line_drawer = LineSegs('line_drawer')
line_drawer.setColor(e_color)
line_drawer.setThickness(1.5)
line_drawer.moveTo(e.v1.pos)
line_drawer.drawTo(e.v2.pos)
edge_node = line_drawer.create()
rendered_edge = self.render_root.attachNewNode(edge_node)
self.render_nodes['edge_'+str(e.ID)] = rendered_edge
def _drawSetpointLine(self):
self.setpointNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(1.0, 1.0, 1.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.setpoint)
node = ls.create()
self.setpointNP = self.base.render.attachNewNode(node)
def _drawVelocityLine(self):
self.velocityLineNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(0.0, 0.0, 1.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.getPos() + self.getVel())
node = ls.create()
self.velocityLineNP = self.base.render.attachNewNode(node)
def _drawForceLine(self):
self.forceLineNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(0.0, 1.0, 0.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.getPos() + self.rigidBody.getTotalForce() * 0.2)
node = ls.create()
self.forceLineNP = self.base.render.attachNewNode(node)
def plot_zero_lines(self):
plot_zero = LineSegs()
plot_zero.setThickness(2.0)
plot_zero.setColor(Vec4(1, 0, 1, 1))
plot_zero.moveTo(-1, 0, self.x_mag)
plot_zero.drawTo(1, 0, self.x_mag)
plot_zero.moveTo(-1, 0, self.y_mag)
plot_zero.drawTo(1, 0, self.y_mag)
base.render2d.attach_new_node(plot_zero.create(True))
def draw(self, start, end):
if self.car.fsm.getCurrentOrNextState() != 'Results':
if self.car.name == game.player_car.name:
segs = LineSegs()
segs.set_color(*self.color)
segs.moveTo(start)
segs.drawTo(end)
segs_node = segs.create()
self.gnd_lines += [render.attachNewNode(segs_node)]
def draw_line(self,p,col):
line = LineSegs()
line.setColor(col[0],col[1],col[2], 1)
line.setThickness(2)
line.moveTo(p[0],p[1],0)
line.drawTo(p[2],p[3],0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
def _drawActualDroneLine(self):
self.actualDroneLineNP.removeNode()
ls = LineSegs()
# ls.setThickness(1)
ls.setColor(0.0, 0.0, 0.0, 1.0)
ls.moveTo(self.getPos())
ls.drawTo(self.actualDronePosition)
node = ls.create()
self.actualDroneLineNP = self.base.render.attachNewNode(node)
def draw_edge(self, e, e_color):
line_drawer = LineSegs('line_drawer')
line_drawer.setColor(e_color)
line_drawer.setThickness(1.5)
line_drawer.moveTo(e.v1.pos)
line_drawer.drawTo(e.v2.pos)
edge_node = line_drawer.create()
rendered_edge = self.render_root.attachNewNode(edge_node)
self.render_nodes['edge_' + str(e.ID)] = rendered_edge
def drawLineSeg(self, loader, parent, start, end):
lines = LineSegs()
lines.setThickness(5.0)
lines.setColor(VBase4(1, 0.5, 0.5, 1.0))
lines.moveTo(start)
lines.drawTo(end)
np = parent.attachNewNode(lines.create())
np.setDepthWrite(True)
np.setDepthTest(True)
def draw_path(self,path):
if self.vis:
self.vis.removeNode()
l=LineSegs()
l.setColor(1,0,0,1)
l.setThickness(2)
l.moveTo(path[0])
for point in path:
l.drawTo(point)
self.vis=render.attachNewNode(l.create())
self.vis.setZ(0.5)
def draw_cross(self, deg_per_pixel):
cross = LineSegs()
cross.setThickness(2.0)
# cross hair is 1/2 degree visual angle,
# so go 1/4 on each side
dist_from_center = 0.25 / deg_per_pixel
cross.moveTo(0 + dist_from_center, 55, 0)
cross.drawTo(0 - dist_from_center, 55, 0)
cross.moveTo(0, 55, 0 - dist_from_center)
cross.drawTo(0, 55, 0 + dist_from_center)
self.x_node = self.base.render.attachNewNode(cross.create(True))
self.x_node.hide()
def createGrid(self):
segs = LineSegs()
segs.setThickness(4.0)
segs.setColor(Vec4(1, 1, 0, 0.3))
for i in xrange(self.level.maxX):
segs.moveTo(i + 1, 0, utils.GROUND_LEVEL)
segs.drawTo(i + 1, self.level.maxY, utils.GROUND_LEVEL + 0.02)
for j in xrange(self.level.maxY):
segs.moveTo(0, j + 1, utils.GROUND_LEVEL)
segs.drawTo(self.level.maxX, j + 1, utils.GROUND_LEVEL + 0.02)
self.grid = NodePath(segs.create())
self.grid.setTransparency(TransparencyAttrib.MAlpha)
def create_lines(joints, color, thickness=5.0):
for node, parent in joints:
if parent is not None:
lines = LineSegs()
lines.setThickness(thickness)
lines.setColor(color)
lines.moveTo(0, 0, 0)
lines.drawTo(node.getPos(parent))
np = parent.attachNewNode(lines.create())
np.setDepthWrite(True)
np.setDepthTest(True)
def drawWheelBase(self):
wheelSegs = LineSegs("wheelBase")
wheelSegs.setThickness(5)
wheelSegs.moveTo(self.wheelFront + Vec3(0.0, 5.0, 1.44))
wheelSegs.drawTo(self.wheelFront + Vec3(0.0, -5.0, 1.44))
wheelSegs.moveTo(self.wheelBack + Vec3(0.0, 5.0, 1.44))
wheelSegs.drawTo(self.wheelBack + Vec3(0.0, -5.0, 1.44))
wheelNode = wheelSegs.create()
wheelNodePath = self.car.attachNewNode(wheelNode)
return wheelNodePath
def draw_cross(self, deg_per_pixel):
cross = LineSegs()
cross.setThickness(2.0)
# cross hair is 1/2 degree visual angle,
# so go 1/4 on each side
dist_from_center = 0.25 / deg_per_pixel
cross.moveTo(0 + dist_from_center, 55, 0)
cross.drawTo(0 - dist_from_center, 55, 0)
cross.moveTo(0, 55, 0 - dist_from_center)
cross.drawTo(0, 55, 0 + dist_from_center)
self.x_node = self.base.render.attachNewNode(cross.create(True))
self.x_node.hide()
def redraw_wps(self):
if not hasattr(self.mediator, 'phys'): return # first frame, refactor
if not self.mediator.phys.waypoints: return
# it may be invoked on track's destruction
if self.wp_np: self.wp_np.remove_node()
segs = LineSegs()
for w_p in self.mediator.phys.waypoints:
for dest in w_p.prevs:
segs.moveTo(w_p.pos)
segs.drawTo(dest.pos)
segs_node = segs.create()
self.wp_np = render.attach_new_node(segs_node)
def __init__(self, widget, axis):
TransformWidgetAxis.__init__(self, widget, axis)
segs = LineSegs()
segs.setThickness(2)
vertices = LEUtils.circle(0, 0, 1, 64)
for i in range(len(vertices)):
x1, y1 = vertices[i]
x2, y2 = vertices[(i + 1) % len(vertices)]
segs.moveTo(x1, 0, y1)
segs.drawTo(x2, 0, y2)
self.axisCircle = self.attachNewNode(segs.create())
self.axisCircle.setAntialias(AntialiasAttrib.MLine)
def __init__(self, widget, axis):
TransformWidgetAxis.__init__(self, widget, axis)
self.head = base.loader.loadModel("models/editor/arrow_head.bam")
self.head.reparentTo(self)
self.head.setY(0.6)
self.head.setScale(0.7)
baseSegs = LineSegs()
baseSegs.setColor(1, 1, 1, 1)
baseSegs.setThickness(2.0)
baseSegs.moveTo(0, 0, 0)
baseSegs.drawTo(0, 0.6, 0)
self.base = self.attachNewNode(baseSegs.create())
self.base.setAntialias(AntialiasAttrib.MLine)
def _createDebugLine(self, points, connectToEnd=False):
segs = LineSegs()
segs.setThickness(1.0)
segs.setColor(Vec4(1, 1, 0, 1))
segs.moveTo(points[0])
for point in points[1:]:
segs.drawTo(point)
if connectToEnd:
segs.drawTo(points[0])
return NodePath(segs.create())
def create_lineSegs_object(data, idx_start=1, name='lines_'):
points = data['points']
lines_def = data['lines']
lines = LineSegs(name)
for line_def in lines_def:
# print(line_def)
idx0 = line_def[0] - idx_start
lines.moveTo(points[idx0][0], points[idx0][1], points[idx0][2])
for idx1 in line_def[1:]:
# print(idx1)
idx1 = idx1 - idx_start
lines.drawTo(points[idx1][0], points[idx1][1], points[idx1][2])
return lines
def draw_connections(self):
try:
self.visual.removeNode()
except:
pass
l=LineSegs()
l.setColor(1,0,0,1)
l.setThickness(2)
for start_node, ends in self.graph['neighbors'].items():
start_pos=self.graph['pos'][start_node]
for end in ends:
end_pos=self.graph['pos'][end]
l.moveTo(start_pos)
l.drawTo(end_pos)
self.visual=render.attachNewNode(l.create())
def __make_border__(cls, parent, thickness, color, l, r , b, t):
moveto_drawto = (
((l,0,t), (l,0,b)),
((r,0,t), (r,0,b)),
((l,0,b), (r,0,b)),
((l,0,t), (r,0,t)),
)
for moveto, drawto in moveto_drawto:
Border = LineSegs()
Border.setThickness(thickness)
Border.setColor(*color)
Border.moveTo(*moveto)
Border.drawTo(*drawto)
b = parent.attachNewNode(Border.create())
b.setBin(*cls.DRAW_ORDER['border'])
def line_small_lakes(self):
for l in range(len(small_lake_lines)):
line = LineSegs()
line.setColor(0,0,0, 1)
line.setThickness(2)
for n in range(len(small_lake_lines[l])):
x = (small_lake_nodes[small_lake_lines[l][n]]["x"]-map_center[0])*amplification
y = (small_lake_nodes[small_lake_lines[l][n]]["y"]-map_center[1])*amplification
if n == 0:
line.moveTo(x,y,0)
else:
line.drawTo(x,y,0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
def __make_border__(cls, parent, thickness, color, l, r, b, t):
moveto_drawto = (
((l, 0, t), (l, 0, b)),
((r, 0, t), (r, 0, b)),
((l, 0, b), (r, 0, b)),
((l, 0, t), (r, 0, t)),
)
for moveto, drawto in moveto_drawto:
Border = LineSegs()
Border.setThickness(thickness)
Border.setColor(*color)
Border.moveTo(*moveto)
Border.drawTo(*drawto)
b = parent.attachNewNode(Border.create())
b.setBin(*cls.DRAW_ORDER['border'])
def line_border(self):
line = LineSegs()
line.setColor(0,0,0, 1)
line.setThickness(5)
x1 = (175.152-map_center[0])*amplification
x2 = (177.358-map_center[0])*amplification
y1 = (-38.808-map_center[1])*amplification
y2 = (-37.462-map_center[1])*amplification
line.moveTo(x1,y1,0)
line.drawTo(x1,y2,0)
line.drawTo(x2,y2,0)
line.drawTo(x2,y1,0)
line.drawTo(x1,y1,0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
def drawLines():
global nodes
for x in nodes:
x.removeNode()
nodes = []
for x in range(len(electrons)):
ls = LineSegs()
ls.setThickness(5)
ls.setColor(1.0, 0.0, 0.0, 1.0)
ls.moveTo(0.0, 0.0, 0.0)
if electrons[x].bonded == False:
ls.drawTo(electrons[x].model.getPos(render))
else:
ls.drawTo(electrons[x].bigmodel.getPos(render))
nodes.append(NodePath(ls.create()))
nodes[x].reparentTo(render)
def draw_axis(self):
for i in range(3):
line = LineSegs()
line.setColor(0.7, 0.7, 0.7, 1)
start = [0, 0, 0]
start[i] = -500
line.moveTo(*start)
end = [0, 0, 0]
end[i] = 500
line.drawTo(*end)
line.setThickness(1)
node = line.create()
nodepath = NodePath(node)
#nodepath.setAntiAlias(8, 1)
#numpy.setColor((1, 1, 1, 1))
nodepath.reparentTo(self.boxnode)
def _createDebugLine(self, points, connectToEnd=False):
""" Helper for visualizing the light bounds.
Draws a line trough all points. When connectToEnd is true,
the last point will get connected to the first point. """
segs = LineSegs()
segs.setThickness(1.0)
segs.setColor(Vec4(1, 1, 0, 1))
segs.moveTo(points[0])
for point in points[1:]:
segs.drawTo(point)
if connectToEnd:
segs.drawTo(points[0])
return NodePath(segs.create())
def draw_line(self, start_p, end_p, color, thickness: float):
"""
Draw line use LineSegs coordinates system. Since a resolution problem is solved, the point on screen should be
described by [horizontal ratio, vertical ratio], each of them are ranged in [-1, 1]
:param start_p: 2d vec
:param end_p: 2d vec
:param color: 4d vec, line color
:param thickness: line thickness
"""
line_seg = LineSegs("interface")
line_seg.setColor(*color)
line_seg.moveTo(start_p[0] * self.w_scale, 0,
start_p[1] * self.h_scale)
line_seg.drawTo(end_p[0] * self.w_scale, 0, end_p[1] * self.h_scale)
line_seg.setThickness(thickness)
line_np = self.aspect2d.attachNewNode(line_seg.create(False))
return line_np
def _createDebugLine(self, points, connectToEnd=False):
""" Helper for visualizing the light bounds.
Draws a line trough all points. When connectToEnd is true,
the last point will get connected to the first point. """
segs = LineSegs()
segs.setThickness(1.0)
segs.setColor(Vec4(1, 1, 0, 1))
segs.moveTo(points[0])
for point in points[1:]:
segs.drawTo(point)
if connectToEnd:
segs.drawTo(points[0])
return NodePath(segs.create())
def draw_floor_plane(self, size, granularity):
line_drawer = LineSegs('grid_line_drawer')
line_drawer.setColor(0.0, 0.0, 0.0, 1.0)
line_drawer.setThickness(1.0)
for i in range(-size, size + 1, granularity):
line_drawer.moveTo(Vec3(float(i), float(-size), 0.0))
line_drawer.drawTo(Vec3(float(i), float(size), 0.0))
for i in range(-size, size + 1, granularity):
line_drawer.moveTo(Vec3(float(-size), float(i), 0.0))
line_drawer.drawTo(Vec3(float(size), float(i), 0.0))
edge_node = line_drawer.create()
rendered_edges = render.attachNewNode(edge_node)
rendered_edges.setTransparency(TransparencyAttrib.MAlpha)
rendered_edges.setAlphaScale(0.5)
return 0
def draw_floor_plane(self,size,granularity):
line_drawer = LineSegs('grid_line_drawer')
line_drawer.setColor(0.0,0.0,0.0,1.0)
line_drawer.setThickness(1.0)
for i in range(-size,size+1,granularity):
line_drawer.moveTo(Vec3(float(i),float(-size),0.0))
line_drawer.drawTo(Vec3(float(i),float(size),0.0))
for i in range(-size,size+1,granularity):
line_drawer.moveTo(Vec3(float(-size),float(i),0.0))
line_drawer.drawTo(Vec3(float(size),float(i),0.0))
edge_node = line_drawer.create()
rendered_edges = render.attachNewNode(edge_node)
rendered_edges.setTransparency(TransparencyAttrib.MAlpha)
rendered_edges.setAlphaScale(0.5)
return 0
def draw_springs(self):
# draw springs
self.springs = []
for i, spring in enumerate(self.box.springs):
_ = spring.p1.object
_ = spring.p2.object
line = LineSegs(f"spring[{i}]")
line.setColor(0.4, 0.4, 0.4, 1)
line.moveTo((0, 0, 0))
line.drawTo((0, 1, 0))
line.setThickness(2)
node = line.create(True)
nodepath = NodePath(node)
# nodepath.reparentTo(self.render)
nodepath.reparentTo(self.boxnode)
# nodepath.setColor(0,1,0,1)
self.springs.append((nodepath, line))
def __init__(self):
ShowBase.__init__(self)
# Load the environment model.
# self.scene1 = self.loader.loadModel("models/environment")
self.models = []
self.base_textures = []
# we would like an orthographic lens
self.lens = OrthographicLens()
self.lens.setFilmSize(20, 15)
base.camNode.setLens(self.lens)
self.cam_pos = [ref[1], ref[0], -ref[2] + 1000]
self.camera.setPos(self.cam_pos[0], self.cam_pos[1], self.cam_pos[2])
self.camera.setHpr(0, -89.9, 0)
self.view_size = 100.0
# test line drawing
ls = LineSegs()
ls.setThickness(1)
ls.setColor(1.0, 0.0, 0.0, 1.0)
ls.moveTo(-100, -100, 400)
ls.drawTo(100, -100, 400)
ls.drawTo(100, 100, 400)
ls.drawTo(-100, 100, 400)
ls.drawTo(-100, -100, 400)
node = NodePath(ls.create())
node.setBin("unsorted", 0)
node.reparentTo(self.render)
# setup keyboard handlers
#self.messenger.toggleVerbose()
self.accept('arrow_left', self.cam_move, [-1, 0, 0])
self.accept('arrow_right', self.cam_move, [1, 0, 0])
self.accept('arrow_down', self.cam_move, [0, -1, 0])
self.accept('arrow_up', self.cam_move, [0, 1, 0])
self.accept('=', self.cam_zoom, [1.1])
self.accept('shift-=', self.cam_zoom, [1.1])
self.accept('-', self.cam_zoom, [1.0 / 1.1])
self.accept('escape', self.quit)
# Add the tasks to the task manager.
self.taskMgr.add(self.updateCameraTask, "updateCameraTask")
def walkJointHierarchy(self, actor, part, parentNode = None, indent = ""):
if isinstance(part, CharacterJoint):
np = actor.exposeJoint(None, 'modelRoot', part.getName())
if parentNode and parentNode.getName() != "root":
lines = LineSegs()
lines.setThickness(3.0)
lines.setColor(random.random(), random.random(), random.random())
lines.moveTo(0, 0, 0)
lines.drawTo(np.getPos(parentNode))
lnp = parentNode.attachNewNode(lines.create())
lnp.setBin("fixed", 40)
lnp.setDepthWrite(False)
lnp.setDepthTest(False)
parentNode = np
for child in part.getChildren():
self.walkJointHierarchy(actor, child, parentNode, indent + " ")
def update_avt_p(self, t_time):
avt = LineSegs()
avt.setThickness(5)
avt.setColor(self.avatar_color[0], self.avatar_color[1], self.avatar_color[2])
group_avatar = []
while self.avatar_pt[-1] < t_time:
group_avatar.append(self.avatar_pos.pop())
# print points
self.avatar_pt.pop()
if not self.avatar_pt:
break
# print('positions', group_avatar)
if group_avatar:
avt.moveTo(self.last_avt[0], self.drawing_layer, self.last_avt[1])
self.last_avt = [i * self.scale_factor for i in group_avatar[0]]
for i in group_avatar:
# print(i[0], i[1], i[2])
pos = [j * self.scale_factor for j in i]
avt.drawTo(pos[0], self.drawing_layer, pos[1])
self.avatar_node.append(self.base.render.attachNewNode(avt.create()))
def show_window(self):
# draw line around target representing how close the subject has to be looking to get reward
# print('show window around square', square_pos)
photo_window = LineSegs()
photo_window.setThickness(2.0)
photo_window.setColor(1, 0, 0, 1)
photo_window.moveTo(self.tolerance[0], 55, self.tolerance[1])
# print photo_window.getCurrentPosition()
# photo_window.drawTo(self.tolerance[0], 55, -self.tolerance[1] - 100)
photo_window.drawTo(self.tolerance[0], 55, -self.tolerance[1])
# print photo_window.getCurrentPosition()
# photo_window.drawTo(-self.tolerance[0], 55, -self.tolerance[1] - 100)
photo_window.drawTo(-self.tolerance[0], 55, -self.tolerance[1])
# print photo_window.getCurrentPosition()
photo_window.drawTo(-self.tolerance[0], 55, self.tolerance[1])
# print photo_window.getCurrentPosition()
photo_window.drawTo(self.tolerance[0], 55, self.tolerance[1])
# print photo_window.getCurrentPosition()
node = self.base.render.attachNewNode(photo_window.create(True))
node.show(BitMask32.bit(0))
node.hide(BitMask32.bit(1))
self.photo_window.append(node)
def frame_loop(self, task):
dt = task.time - task.last
task.last = task.time
plot_x = LineSegs()
plot_x.setThickness(2.0)
plot_x.setColor(Vec4(1, 1, 0, 1))
plot_x.moveTo(self.time, 55, self.old_x)
plot_y = LineSegs()
plot_y.setThickness(2.0)
plot_y.moveTo(self.time, 55, self.old_y)
self.time += dt
plot_x.drawTo(self.time, 55, self.x_mag)
plot_y.drawTo(self.time, 55, self.y_mag)
self.old_x = self.x_mag
self.old_y = self.y_mag
node = render.attachNewNode(plot_x.create())
self.plot.append(node)
node = render.attachNewNode(plot_y.create())
self.plot.append(node)
if self.time > 20:
self.clear_plot()
return task.cont
def __init__(self, parent, color, hpr, dim):
PandaNode.__init__(self, dim+'handle')
self.path = NodePath(self)
self.parent = parent
self.dim = dim
arrow = GeomNode('gnode')
arrow.addGeomsFrom(self.geomNode)
arrownp = self.path.attachNewNode(arrow)
arrownp.hide(BitMask32(1))
clickNode = ClickableNode('clicknode')
clickNode.setDepthLevel(0.5)
clickNode.addMouseListener(self)
clicknp = self.path.attachNewNode(clickNode)
clickgeom = clicknp.attachNewNode(GeomNode('clicknode'))
clickgeom.hide(BitMask32(7))
clickgeom.node().addGeomsFrom(self.clickableGeomNode)
linesegs = LineSegs()
linesegs.setColor(color)
linesegs.setThickness(2)
linesegs.moveTo(Vec3(0, 0, -30))
linesegs.drawTo(Vec3(0, 0, -0.5))
linesegs.moveTo(Vec3(0, 0, 0.5))
linesegs.drawTo(Vec3(0, 0, 30))
lines = self.path.attachNewNode(linesegs.create())
lines.show(BitMask32(1))
lines.hide(BitMask32(2|4|8|16))
lines.setBin('opaque', 30, 100)
lines.setAntialias(AntialiasAttrib.MNone)
self.path.setColor(color)
self.path.setHpr(hpr)
self.mDownPos = Vec2()
def initRaceMode(self):
self.mapScene = base.a2dTopRight.attachNewNode('MapScene')
self.mapScene.setPos(-0.2, 0, -0.2)
self.mapScene.setScale(0.25, 0.001, 0.25)
maxT = self.race.curve.getMaxT()
pt = Vec3(0, 0, 0)
ls = LineSegs('MapLines')
ls.setColor(1, 1, 1, 1)
ls.setThickness(2)
for x in xrange(101):
self.race.curve.getPoint(x / 100.0 * maxT, pt)
if x == 0:
ls.moveTo(pt[0], pt[1], pt[2])
else:
ls.drawTo(pt[0], pt[1], pt[2])
self.mapLines = self.mapScene.attachNewNode(ls.create())
self.mapLines.setScale(0.00025 * RaceGlobals.TrackDict[self.race.trackId][6])
self.mapLines.setP(90)
self.faceStartPos = Vec3(-0.8, 0, 0.93)
self.faceEndPos = Vec3(0.8, 0, 0.93)
self.placeLabelNum = DirectLabel(relief=None, pos=TTLocalizer.RGUIplaceLabelNumPos, text='1', text_scale=0.35, text_fg=(0.95, 0.95, 0, 1), text_font=ToontownGlobals.getSignFont())
self.placeLabelNum.reparentTo(base.a2dBottomLeft)
self.directObjList.append(self.placeLabelNum)
self.placeLabelStr = DirectLabel(relief=None, pos=TTLocalizer.RGUIplaceLabelStrPos, text=TTLocalizer.KartRace_FirstSuffix, text_scale=0.1, text_fg=(0.95, 0.95, 0, 1), text_font=ToontownGlobals.getSignFont())
self.placeLabelStr.reparentTo(base.a2dBottomLeft)
self.directObjList.append(self.placeLabelStr)
self.lapLabel = DirectLabel(relief=None, pos=(-0.22, 0, -0.5), text='1/' + str(self.race.lapCount), text_scale=0.1, text_fg=(0.95, 0.95, 0, 1), text_font=ToontownGlobals.getSignFont())
self.lapLabel.reparentTo(base.a2dTopRight)
self.directObjList.append(self.lapLabel)
self.photoFinishLabel = DirectLabel(relief=None, pos=(0, 0, -0.1), text=TTLocalizer.KartRace_PhotoFinish, text_scale=TTLocalizer.RGUIphotoFinish, text_fg=(0.95, 0.95, 0, 1), text_font=ToontownGlobals.getSignFont())
self.photoFinishLabel.hide()
self.directObjList.append(self.photoFinishLabel)
self.wrongWayLabel = DirectLabel(relief=None, pos=(-0.22, 0, -0.2), text=TTLocalizer.KartRace_WrongWay, text_scale=0.1, text_fg=(0.95, 0, 0, 1), text_font=ToontownGlobals.getSignFont())
self.wrongWayLabel.reparentTo(base.a2dTopRight)
self.directObjList.append(self.wrongWayLabel)
self.wrongWayLabel.setColorScale(Vec4(1, 1, 1, 0))
self.wrongWaySeq = Sequence(self.wrongWayLabel.colorScaleInterval(0.25, colorScale=Vec4(1, 1, 1, 1), startColorScale=Vec4(1, 1, 1, 0)), self.wrongWayLabel.colorScaleInterval(0.25, colorScale=Vec4(1, 1, 1, 0), startColorScale=Vec4(1, 1, 1, 1)))
interpolateFacePos = lambda x: self.faceStartPos * (1.0 - x) + self.faceEndPos * x
self.timeLabels = []
for x in xrange(self.race.lapCount):
minLabel = DirectLabel(relief=None, pos=(interpolateFacePos((2.0 * x + 1) / (self.race.lapCount * 2))[0] - 0.06, 0, 0.84), text="0'", text_scale=0.06, text_fg=(0.95, 0.95, 0, 1), text_font=ToontownGlobals.getSignFont(), text_align=TextNode.ARight)
minLabel.reparentTo(self.raceModeRoot)
self.directObjList.append(minLabel)
secLabel = DirectLabel(relief=None, pos=(interpolateFacePos((2.0 * x + 1) / (self.race.lapCount * 2))[0] + 0.06, 0, 0.84), text="00''", text_scale=0.06, text_fg=(0.95, 0.95, 0, 1), text_font=ToontownGlobals.getSignFont(), text_align=TextNode.ARight)
secLabel.reparentTo(self.raceModeRoot)
self.directObjList.append(secLabel)
fractionLabel = DirectLabel(relief=None, pos=(interpolateFacePos((2.0 * x + 1) / (self.race.lapCount * 2))[0] + 0.14, 0, 0.84), text='00', text_scale=0.06, text_fg=(0.95, 0.95, 0, 1), text_font=ToontownGlobals.getSignFont(), text_align=TextNode.ARight)
fractionLabel.reparentTo(self.raceModeRoot)
self.directObjList.append(fractionLabel)
self.timeLabels.append((minLabel, secLabel, fractionLabel))
self.cardMaker.reset()
self.cardMaker.setName('GagIndicator')
self.cardMaker.setFrame(-0.5, 0.5, -0.5, 0.5)
self.cardMaker.setColor(1, 1, 1, 1)
self.gagPanel = DirectFrame(parent=base.a2dBottomLeft, relief=None, image=loader.loadModel('phase_6/models/karting/gag_panel'), image_scale=0.25, pos=(0.2, 0, 0.55))
self.directObjList.append(self.gagPanel)
self.gag = self.gagPanel.attachNewNode('gag')
self.gag.setScale(0.2)
for gag in self.gagTextures:
gag.reparentTo(self.gag)
gag.hide()
self.cardMaker.reset()
self.cardMaker.setName('RaceProgressLine')
self.cardMaker.setFrame(-0.5, 0.5, -0.5, 0.5)
line = self.raceModeRoot.attachNewNode(self.cardMaker.generate())
line.setScale(self.faceEndPos[0] - self.faceStartPos[0], 1, 0.01)
line.setPos(0, 0, self.faceStartPos[2])
self.cardMaker.setName('RaceProgressLineHash')
for n in xrange(self.race.lapCount + 1):
hash = self.raceModeRoot.attachNewNode(self.cardMaker.generate())
hash.setScale(line.getScale()[2], 1, line.getScale()[2] * 5)
t = float(n) / self.race.lapCount
hash.setPos(self.faceStartPos[0] * (1 - t) + self.faceEndPos[0] * t, self.faceStartPos[1], self.faceStartPos[2])
self.raceModeReady = True
self.disable()
return
def __init__(self, datafile, record=True, distance_goal=None):
DirectObject.__init__(self)
# environ = 'circle'
environ = 'original'
movie_name = '../movies/frames/avatar/avatar'
data = MovieData(datafile)
# bring in data that we will use
self.avatar_pos = [[j/2 for j in i] for i in data.avatar_pos]
self.avatar_pt = data.avatar_pt
self.fruit_status = data.fruit_status
self.fruit_status_ts = data.fruit_status_ts
self.fruit_pos = data.fruit_pos
self.fruit_pos_ts = data.fruit_pos_ts
self.trial_mark = data.trial_mark
self.alpha = data.alpha
self.scale_factor = 1
# print 'alpha', self.alpha
# toggle to detect when a block of trials is finished
self.block_done = False
# print 'fruit status', self.fruit_status
self.use_alpha = False
# convoluted way to see if we are really using invisible fruit
for i in self.fruit_status:
if i[1] == 'alpha' and float(i[2]) < 1:
self.use_alpha = True
# print 'true', float(i[2])
# print 'use alpha', self.use_alpha
# really should pull this from the config file (distance_goal)
# everything is at 1/2 size
if distance_goal:
self.goal_radius = [i/2 for i in distance_goal]
else:
# total arbitrary guess
self.goal_radius = [3/2, 3/2]
# Things that can affect camera:
# options resolution resW resH
self.base = ShowBase()
props = WindowProperties()
# props.setSize(600, 600)
self.base.win.requestProperties(props)
self.drawing_layer = 25
#corner = 600/100 * 5/6
if environ == 'original':
border = LineSegs()
border.setThickness(2.0)
corner = 5.5
# print corner
# red
border.setColor(1, 0, 0)
border.moveTo(corner, 25, corner)
border.drawTo(corner, 25, -corner)
# purple
border.setColor(1, 0, 1)
border.moveTo(corner, 25, -corner)
border.drawTo(-corner, 25, -corner)
# white
border.setColor(1, 1, 1)
border.moveTo(-corner, 25, -corner)
border.drawTo(-corner, 25, corner)
# green
border.setColor(0, 1, 0)
border.moveTo(-corner, 25, corner)
border.drawTo(corner, 25, corner)
self.base.render.attachNewNode(border.create(True))
imageObject = OnscreenImage(image='textures/lightpost.png',
pos=(-0.9, 25, 0.9), scale=(0.06, 1, 0.08), color=(0.9, 0.9, 0.9, 0.8))
imageObject.setTransparency(TransparencyAttrib.MAlpha)
imageObject1 = OnscreenImage(image='textures/palm_tree.png',
pos=(0.85, 25, 0.9), scale=0.09, color=(0.9, 0.9, 0.9, 0.8))
imageObject1.setTransparency(TransparencyAttrib.MAlpha)
imageObject2 = OnscreenImage(image='textures/transamerica_thumb.png',
pos=(-0.9, 25, -0.9), scale=0.2, color=(0.9, 0.9, 0.9, 0.8))
imageObject2.setTransparency(TransparencyAttrib.MAlpha)
# background color doesn't show up anyway
#base.setBackgroundColor(115 / 255, 115 / 255, 115 / 255)
else:
# circle
# needs to be smaller
self.scale_factor = 0.7
color = Point3(0.9, 0.9, 0.9)
self.make_circle(8 * self.scale_factor, (0, 0, 0), color)
last_avt = self.avatar_pos.pop()
self.last_avt = [i * self.scale_factor for i in last_avt]
#base.cam.setPos(Point3(points[0], points[1], points[2]))
#base.cam.setH(self.avatar_h.pop(0))
#self.avatar_ht.pop(0)
self.avatar_pt.pop()
# get last time stamp (first of list) for avatar to calculate length of movie
# add half a second buffer.
movie_length = self.avatar_pt[0] + 0.5
print('movie length', movie_length)
self.avatar_node = []
self.avatar_color = [1, 1, 1]
self.alpha_circle_node = []
self.fruitModel = {}
# print('fruit', self.fruit_pos)
for k, v in self.fruit_pos.iteritems():
# print('i', i)
# print('k', k)
# print('v', v)
if 'banana' in k:
self.fruitModel[k] = self.base.loader.loadModel('models/ball')
self.fruitModel[k].setScale(0.5)
self.fruitModel[k].setColor(1, 1, 0, 1)
elif 'cherry' in k:
self.fruitModel[k] = self.base.loader.loadModel('models/ball')
self.fruitModel[k].setScale(0.5)
self.fruitModel[k].setColor(1, 0, 0, 1)
# position = self.fruit_pos[k]['position'].pop(0)
# print position
heading = v['head']
#print heading
# self.fruitModel[k].setPos(
# Point3(float(position[0]), float(position[1]), float(position[2])))
self.fruitModel[k].setH(float(heading))
self.fruitModel[k].reparentTo(self.base.render)
# assume all fruit stashed to start
self.fruitModel[k].stash()
if k in data.alpha:
# print 'set alpha', data.alpha
self.alpha_node_path = self.fruitModel[k]
self.alpha_node_path.setTransparency(TransparencyAttrib.MAlpha)
if record:
self.movie_task = self.base.movie(movie_name, movie_length, 30, 'png', 4)
#self.accept("space", base.taskMgr.add, [self.frame_loop, "frame_loop"])
self.gameTask = taskMgr.add(self.frame_loop, "frame_loop")
self.gameTask.last = 0 # Task time of the last frame
def renderCharts(facegraph, verts, vert_indices, lineset=None):
from meshtool.filters.panda_filters.pandacore import getVertexData, attachLights, ensureCameraAt
from meshtool.filters.panda_filters.pandacontrols import KeyboardMovement, MouseDrag, MouseScaleZoom, ButtonUtils
from panda3d.core import GeomTriangles, Geom, GeomNode, GeomVertexFormat, GeomVertexData, GeomVertexWriter, LineSegs
from direct.showbase.ShowBase import ShowBase
vformat = GeomVertexFormat.getV3c4()
vdata=GeomVertexData('tris', vformat, Geom.UHDynamic)
vertex=GeomVertexWriter(vdata, 'vertex')
color=GeomVertexWriter(vdata, 'color')
colors = gen_color3(len(facegraph))
numtris = 0
for chart, data in facegraph.nodes_iter(data=True):
curcolor = next(colors)
for tri in data['tris']:
triv = verts[vert_indices[tri]]
vertex.addData3f(triv[0][0], triv[0][1], triv[0][2])
vertex.addData3f(triv[1][0], triv[1][1], triv[1][2])
vertex.addData3f(triv[2][0], triv[2][1], triv[2][2])
color.addData4f(curcolor[0],curcolor[1], curcolor[2], 1)
color.addData4f(curcolor[0],curcolor[1], curcolor[2], 1)
color.addData4f(curcolor[0],curcolor[1], curcolor[2], 1)
numtris += 1
tris=GeomTriangles(Geom.UHDynamic)
tris.addConsecutiveVertices(0, 3*numtris)
tris.closePrimitive()
linenodes = []
if lineset:
for lines in lineset:
ls = LineSegs()
ls.setThickness(4)
curcolor = next(colors)
ls.setColor(curcolor[0]/256.0, curcolor[1]/256.0, curcolor[2]/256.0, 1)
tuples = False
for blah in lines:
if isinstance(blah, tuple):
tuples = True
break
if tuples:
for i, j in lines:
frompt = verts[i]
topt = verts[j]
ls.moveTo(frompt[0], frompt[1], frompt[2])
ls.drawTo(topt[0], topt[1], topt[2])
else:
for i in range(len(lines)-1):
frompt = verts[lines[i]]
topt = verts[lines[i+1]]
ls.moveTo(frompt[0], frompt[1], frompt[2])
ls.drawTo(topt[0], topt[1], topt[2])
linenodes.append(ls.create())
pgeom = Geom(vdata)
pgeom.addPrimitive(tris)
node = GeomNode("primitive")
node.addGeom(pgeom)
p3dApp = ShowBase()
#attachLights(render)
geomPath = render.attachNewNode(node)
for linenode in linenodes:
geomPath.attachNewNode(linenode)
#geomPath.setRenderModeWireframe()
ensureCameraAt(geomPath, base.cam)
boundingSphere = geomPath.getBounds()
base.cam.setPos(boundingSphere.getCenter() + boundingSphere.getRadius())
base.cam.lookAt(boundingSphere.getCenter())
KeyboardMovement()
ButtonUtils(geomPath)
MouseDrag(geomPath)
MouseScaleZoom(geomPath)
#render.setShaderAuto()
p3dApp.run()
class GolfScoreBoard:
notify = directNotify.newCategory('GolfScoreBoard')
def __init__(self, golfCourse):
self.golfCourse = golfCourse
self.numPlayas = len(golfCourse.avIdList)
self.avIdList = golfCourse.avIdList
self.playaTags = []
self.scoreTags = []
self.totalTags = []
self.scoreLabels = []
self.holeLabels = []
self.parLabels = []
self.numExited = 0
self.setup()
def setup(self):
self.scoreboard = DirectFrame(parent=aspect2d, relief=None, geom=DGG.getDefaultDialogGeom(), geom_color=ToontownGlobals.GlobalDialogColor, geom_scale=(1.9, 1, 1.05), pos=(0, 0, 0.375))
self.lines = LineSegs()
self.lines.setColor(0, 0, 0, 1)
self.lines.setThickness(2)
guiModel = loader.loadModel('phase_6/models/golf/golf_gui')
highlight = loader.loadModel('phase_6/models/golf/headPanel')
self.maximizeB = DirectButton(parent=base.a2dBottomRight, pos=(-0.15, 0, 0.15), relief=None, state=DGG.NORMAL, image=(guiModel.find('**/score_card_icon'), guiModel.find('**/score_card_icon_rollover'), guiModel.find('**/score_card_icon_rollover')), image_scale=(0.2, 1, 0.2), command=self.showBoard)
self.vertOffset = 0.13
self.playaTop = 0.12
horzOffset = 0.12
holeTop = 0.3
self.vCenter = 0.025
totScore = 0
totPar = 0
self.lineVStart = -0.465
self.lineHStart = 0.17
self.lineHorOffset = 0.13
self.lineVertOffset = 0.125
self.lineVCenter = 0.025
buttons = loader.loadModel('phase_3/models/gui/dialog_box_buttons_gui')
self.minimizeB = DirectButton(parent=self.scoreboard, pos=(0, 0, self.lineHStart - 0.59), relief=None, state=DGG.NORMAL, image=(buttons.find('**/CloseBtn_UP'), buttons.find('**/CloseBtn_DN'), buttons.find('**/CloseBtn_Rllvr')), image_scale=(1, 1, 1), command=self.hideBoard, extraArgs=[None])
self.exitCourseB = DirectButton(parent=self.scoreboard, pos=(0, 0, self.lineHStart - 0.59), relief=None, state=DGG.NORMAL, image=(buttons.find('**/CloseBtn_UP'), buttons.find('**/CloseBtn_DN'), buttons.find('**/CloseBtn_Rllvr')), image_scale=(1, 1, 1), text=TTLocalizer.GolfExitCourse, text_scale=0.04, text_pos=TTLocalizer.GSBexitCourseBPos, command=self.exitCourse)
self.exitCourseB.hide()
self.highlightCur = DirectLabel(parent=self.scoreboard, relief=None, pos=(-0.003, 0, 0.038), image=highlight, image_scale=(1.82, 1, 0.135))
self.titleBar = DirectLabel(parent=self.scoreboard, relief=None, pos=(-0.003, 0, 0.166), color=(0.7, 0.7, 0.7, 0.3), image=highlight, image_scale=(1.82, 1, 0.195))
self.titleBar.show()
self.highlightCur.show()
buttons.removeNode()
guiModel.removeNode()
title = GolfGlobals.getCourseName(self.golfCourse.courseId) + ' - ' + GolfGlobals.getHoleName(self.golfCourse.holeIds[self.golfCourse.curHoleIndex])
self.titleLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(0, 0, holeTop + 0.1), text_align=TextNode.ACenter, text=title, text_scale=TTLocalizer.GSBtitleLabel, text_font=ToontownGlobals.getSignFont(), text_fg=(0, 0.5, 0.125, 1))
self.playaLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart - 0.23, 0, holeTop), text_align=TextNode.ACenter, text=TTLocalizer.GolfHole, text_font=ToontownGlobals.getMinnieFont(), text_scale=0.05)
for holeLIndex in xrange(self.golfCourse.numHoles):
holeLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.055 + horzOffset * holeLIndex, 0, holeTop), text_align=TextNode.ACenter, text='%s' % (holeLIndex + 1), text_scale=0.05)
self.holeLabels.append(holeLabel)
self.totalLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.1 + horzOffset * 9.5, 0, holeTop), text_align=TextNode.ACenter, text=TTLocalizer.GolfTotal, text_font=ToontownGlobals.getMinnieFont(), text_scale=0.05)
self.parTitleLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart - 0.23, 0, holeTop - 0.1), text_align=TextNode.ACenter, text=TTLocalizer.GolfPar, text_font=ToontownGlobals.getMinnieFont(), text_scale=0.05)
for parHoleIndex in xrange(self.golfCourse.numHoles):
parLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.055 + horzOffset * parHoleIndex, 0, holeTop - 0.1), text_align=TextNode.ACenter, text='%s' % GolfGlobals.HoleInfo[self.golfCourse.holeIds[parHoleIndex]]['par'], text_scale=0.05, text_wordwrap=10)
totPar = totPar + GolfGlobals.HoleInfo[self.golfCourse.holeIds[parHoleIndex]]['par']
self.parLabels.append(parLabel)
parLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.1 + horzOffset * 9.5, 0, holeTop - 0.1), text_align=TextNode.ACenter, text='%s' % totPar, text_scale=0.05, text_wordwrap=10)
self.parLabels.append(parLabel)
vert = 0.0
self.numPlayas = len(self.golfCourse.avIdList)
for playaIndex in xrange(self.numPlayas):
name = TTLocalizer.GolfUnknownPlayer
av = base.cr.doId2do.get(self.golfCourse.avIdList[playaIndex])
if av:
name = av.getName()
playaLabel = DirectLabel(parent=self.scoreboard, relief=None, text_align=TextNode.ACenter, text=name, text_scale=0.05, text_wordwrap=9)
self.playaTags.append(playaLabel)
textN = playaLabel.component(playaLabel.components()[0])
if type(textN) == OnscreenText:
try:
if textN.textNode.getWordwrappedWtext() != name:
vert = self.playaTop - self.vertOffset * playaIndex
else:
vert = self.playaTop - self.vertOffset * playaIndex - self.vCenter
except:
vert = self.playaTop - self.vertOffset * playaIndex
self.playaTags[playaIndex].setPos(self.lineVStart - 0.23, 0, vert)
self.notify.debug('self.text height = %f' % self.playaTags[playaIndex].getHeight())
holeIndex = 0
for holeIndex in xrange(self.golfCourse.numHoles):
holeLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.055 + horzOffset * holeIndex, 0, self.playaTop - self.vertOffset * playaIndex - self.vCenter), text_align=TextNode.ACenter, text='-', text_scale=0.05, text_wordwrap=10)
self.scoreTags.append(holeLabel)
holeLabel = DirectLabel(parent=self.scoreboard, relief=None, pos=(self.lineVStart + 0.1 + horzOffset * 9.5, 0, self.playaTop - self.vertOffset * playaIndex - self.vCenter), text_align=TextNode.ACenter, text='-', text_scale=0.05, text_wordwrap=10)
self.totalTags.append(holeLabel)
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart + 0.19)
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart + 0.09)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart + 0.09)
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart)
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart - 0.45, 0, self.lineHStart - 4 * 0.13)
self.lines.moveTo(self.lineVStart, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart, 0, self.lineHStart - 4 * 0.13)
for x in xrange(4):
self.lines.moveTo(self.lineVStart - 0.45, 0, self.lineHStart - (x + 1) * self.lineHorOffset)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset + 0.005, 0, self.lineHStart - (x + 1) * self.lineHorOffset)
for y in xrange(10):
self.lines.moveTo(self.lineVStart + y * self.lineVertOffset, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart + y * self.lineVertOffset, 0, self.lineHStart - 4 * 0.13)
self.lines.moveTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart + 0.19)
self.lines.drawTo(self.lineVStart + 11 * self.lineVertOffset, 0, self.lineHStart - 4 * 0.13)
self.scoreboard.attachNewNode(self.lines.create())
self.hide()
return
def getScoreLabel(self, avIdorIndex, holeNum):
index = None
if avIdorIndex < 100:
index = avIdorIndex
else:
for playaIndex in xrange(self.numPlayas):
if self.golfCourse.avIdList[playaIndex] == avIdorIndex:
index = playaIndex
return self.scoreTags[index * self.golfCourse.numHoles + holeNum]
def update(self):
self.showBoard()
taskMgr.doMethodLater(AUTO_HIDE_TIMEOUT, self.hideBoard, 'hide score board')
def hideBoard(self, task):
self.hide()
def hide(self):
self.scoreboard.hide()
self.maximizeB.show()
def showBoardFinal(self, task = None):
self.exitCourseB.show()
self.minimizeB.hide()
self.showBoard()
def showBoard(self, task = None):
scoreDict = self.golfCourse.scores
x = 0
currentGolfer = self.golfCourse.getCurGolfer()
for playaIndex in xrange(self.numPlayas):
if self.golfCourse.isGameDone():
self.playaTags[playaIndex].setColor(0, 0, 0, 1)
elif currentGolfer == self.golfCourse.avIdList[playaIndex]:
self.highlightCur.setColor(*GolfGlobals.PlayerColors[playaIndex])
self.highlightCur.setAlphaScale(0.4)
self.highlightCur.setPos(-0.003, 0, 0.038 - playaIndex * (self.lineVertOffset + 0.005))
self.highlightCur.show()
else:
self.playaTags[playaIndex].setColor(0, 0, 0, 1)
for avId in self.avIdList:
holeIndex = 0
totScore = 0
playerExited = False
for y in xrange(len(self.golfCourse.exitedAvIdList)):
if self.golfCourse.exitedAvIdList[y] == avId:
self.playaTags[x].setColor(0.7, 0.7, 0.7, 1)
holeIndex = 0
for holeIndex in xrange(self.golfCourse.numHoles):
self.getScoreLabel(self.avIdList[x], holeIndex).setColor(0.7, 0.7, 0.7, 1)
self.totalTags[x].setColor(0.7, 0.7, 0.7, 1)
playerExited = True
if playerExited == False:
for holeIndex in xrange(self.golfCourse.numHoles):
if holeIndex <= self.golfCourse.curHoleIndex:
self.getScoreLabel(avId, holeIndex)['text'] = '%s' % scoreDict[avId][holeIndex]
totScore = totScore + scoreDict[avId][holeIndex]
if self.golfCourse.isGameDone() == False:
if holeIndex == self.golfCourse.curHoleIndex:
self.getScoreLabel(avId, holeIndex).setColor(1, 0, 0, 1)
self.holeLabels[holeIndex].setColor(1, 0, 0, 1)
self.parLabels[holeIndex].setColor(1, 0, 0, 1)
title = GolfGlobals.getCourseName(self.golfCourse.courseId) + ' - ' + GolfGlobals.getHoleName(self.golfCourse.holeIds[self.golfCourse.curHoleIndex])
self.titleLabel['text'] = title
else:
self.getScoreLabel(avId, holeIndex).setColor(0, 0, 0, 1)
self.holeLabels[holeIndex].setColor(0, 0, 0, 1)
self.parLabels[holeIndex].setColor(0, 0, 0, 1)
self.totalTags[x]['text'] = '%s' % totScore
if self.golfCourse.isGameDone():
self.getScoreLabel(avId, self.golfCourse.numHoles - 1).setColor(0, 0, 0, 1)
self.totalTags[x].setColor(1, 0, 0, 1)
x = x + 1
y = 0
if self.golfCourse.isGameDone():
self.parLabels[self.golfCourse.numHoles - 1].setColor(0, 0, 0, 1)
self.holeLabels[self.golfCourse.numHoles - 1].setColor(0, 0, 0, 1)
self.parLabels[self.golfCourse.numHoles].setColor(1, 0, 0, 1)
self.totalLabel.setColor(1, 0, 0, 1)
self.scoreboard.show()
self.maximizeB.hide()
def exitCourse(self):
course = self.golfCourse
self.delete()
course.exitEarly()
def delete(self):
if self.maximizeB:
self.maximizeB.destroy()
self.maximizeB = None
if self.scoreboard:
self.scoreboard.destroy()
self.scoreboard = None
self.golfCourse = None
taskMgr.remove('hide score board')
return
