def __init__(self):
super().__init__()
# Network Stream Connection and Queue
self._controlQueue = deque()
self._eventQueue = deque()
self._toSendQueue = deque()
# Reentrant Lock Variable, for Monitor Functions
self._RELock = threading.RLock()
# Test 'Messages'
cMessage1 = {}
cMessage1['type'] = 'Create'
cMessage1['entityType'] = 'SpaceJet'
cMessage1['entityId'] = 0
cMessage2 = {}
cMessage2['type'] = 'Update'
cMessage2['entityId'] = 0
cMessage2['position'] = vec(0, 200)
cMessage2['velocity'] = vec(-1, 1)
cMessage3 = {}
cMessage3['type'] = 'Update'
cMessage3['entityId'] = 0
cMessage3['health'] = 0
self._controlQueue.append(cMessage1)
self._controlQueue.append(cMessage2)
#self._controlQueue.append(cMessage3)
# Remote Controlled Entities
self._entities = {}
def on_client_shoot(self, client, shot_id, gun, fx, fy, fz, tx, ty, tz, hits):
if client.state.lastshot == -1:
wait = time.time() - client.state.lastshot
else:
wait = client.state.gunwait
pfrom = vec(fx, fy, fz).div(DMF)
pto = vec(tx, ty, tz).div(DMF)
if not client.state.alive or wait < client.state.gunwait: return
if gun < weapon_types.GUN_FIST or gun > weapon_types.GUN_PISTOL: return
if client.state.ammo[gun] <= 0: return
if guns[gun].range and (pfrom.dist(pto) > guns[gun].range + 1): return
if gun != weapon_types.GUN_FIST:
client.state.ammo[gun] -= 1
client.state.lastshot = time.time()
client.state.gunwait = float(guns[gun].attackdelay)/1000.0
with self.broadcastbuffer(1, True, [client]) as cds:
swh.put_shotfx(cds, client, gun, shot_id, fx, fy, fz, tx, ty, tz)
if gun == weapon_types.GUN_RL:
client.state.rockets[shot_id] = gun
elif gun == weapon_types.GUN_GL:
client.state.grenades[shot_id] = gun
else:
for hit in hits:
self.on_client_hit(client, gun, **hit)
def __initP__(self, **kwArgs):
super().__initP__(**kwArgs)
self._transform = None
self._worldPos = vec()
self._worldRot = 0.0
self._worldScale = vec(1, 1)
self._lastTransformation = [False, [0, 0, 0]]
''' Temporary Fix '''
self.isDrawn = True
def removeTransform(self):
t = self._transform
self._transform._removeTransformable(self)
self._transform = None
self._worldPos = vec()
self._worldRot = 0.0
self._worldScale = vec(1, 1)
return t
def removeTransform(self): t = self._transform self._transform._removeTransformable(self) self._transform = None self._worldPos = vec() self._worldRot = 0.0 self._worldScale = vec(1,1) return t
def __initP__(self, **kwArgs): super().__initP__(**kwArgs) self._transform = None self._worldPos = vec() self._worldRot = 0.0 self._worldScale = vec(1, 1) self._lastTransformation = [False, [0,0,0]] ''' Temporary Fix ''' self.isDrawn = True
def __initC__(self, **kwArgs): self._localPos = getDictValue(kwArgs, vec(), ['lp', 'localPos']) self._localRot = getDictValue(kwArgs, 0.0, ['lr', 'localRot']) self._localScale = getDictValue(kwArgs, vec(1, 1), ['ls', 'localScale']) t = getDictValue(kwArgs, None, ['t', 'transform']) if(t): self.setTransform(t) self._onTransformation(self._lastTransformation[1]) super().__initC__(**kwArgs)
def __initC__(self, **kwArgs):
self._localPos = getDictValue(kwArgs, vec(), ['lp', 'localPos'])
self._localRot = getDictValue(kwArgs, 0.0, ['lr', 'localRot'])
self._localScale = getDictValue(kwArgs, vec(1, 1),
['ls', 'localScale'])
t = getDictValue(kwArgs, None, ['t', 'transform'])
if (t):
self.setTransform(t)
self._onTransformation(self._lastTransformation[1])
super().__initC__(**kwArgs)
def __initP__(self, **kwArgs):
super().__initP__(**kwArgs)
''' Node and Update Values '''
self._parent = None
self._children = []
''' Transform Data '''
self._translate = getDictValue(kwArgs, vec(), ['t', 'translate'])
self._rotateRads = getDictValue(kwArgs, 0.0, ['r', 'rotate'])
self._scale = getDictValue(kwArgs, vec(1, 1), ['s', 'scale'])
self._gTrans = self._translate.copy()
self._gRotRads = self._rotateRads
self._gScale = self._scale.copy()
''' Transformable Data '''
self._transformables = []
def damage_client(self, target, client, damage, gun, dx, dy, dz):
v = vec(dx, dy, dz).div(DMF).rescale(DNF)
target.state.receive_damage(damage)
with self.broadcastbuffer(1, True) as cds:
swh.put_damage(cds, target, client, damage)
if target == client:
#target.state.setpushed()
pass
elif not v.iszero():
if target.state.health <= 0:
swh.put_hitpush(cds, target, gun, damage, v)
else:
with target.sendbuffer(1, True) as cds:
swh.put_hitpush(cds, target, gun, damage, v)
#target.state.setpushed()
if target.state.health < 1:
target.state.state = client_states.CS_DEAD
target.state.deaths += 1
if self.gamemode.hasteams and client.team == target.team:
client.state.frags -= 1
else:
client.state.frags += 1
swh.put_died(cds, target, client)
def __initP__(self, **kwArgs):
super().__initP__(**kwArgs)
""" Node and Update Values """
self._parent = None
self._children = []
""" Transform Data """
self._translate = getDictValue(kwArgs, vec(), ["t", "translate"])
self._rotateRads = getDictValue(kwArgs, 0.0, ["r", "rotate"])
self._scale = getDictValue(kwArgs, vec(1, 1), ["s", "scale"])
self._gTrans = self._translate.copy()
self._gRotRads = self._rotateRads
self._gScale = self._scale.copy()
""" Transformable Data """
self._transformables = []
def __initP__(self, **kwArgs): super().__initP__(**kwArgs) ''' Node and Update Values ''' self._parent = None self._children = [] ''' Transform Data ''' self._translate = getDictValue(kwArgs, vec(), ['t', 'translate']) self._rotateRads = getDictValue(kwArgs, 0.0, ['r', 'rotate']) self._scale = getDictValue(kwArgs, vec(1,1), ['s', 'scale']) self._gTrans = self._translate.copy() self._gRotRads = self._rotateRads self._gScale = self._scale.copy() ''' Transformable Data ''' self._transformables = []
def __init__(self, yFaceDirection, **kwArgs):
super().__init__(**kwArgs)
rm = ResourceManager.activeManager
# Set Systems
self._yFaceDirection = yFaceDirection
# Set Characteristics
self._alive = True
self._armor = 3
self._health = 1000
self._speed = 550
self._velocity = vec(0,0)
# Set Rendering and Physics Data
self._sprite = Sprite(rm.request("SpaceJet.anim"), t=self.getTransform().createChild())
self._sprite.setFrame(1+3)
self._explosionSprite = Sprite(rm.request("Explosion.anim"), t=self.getTransform().createChild())
self._explosionSprite.isDrawn = False
self._explosionSound = rm.request("Explosion.mp3")
self._bounds = CollisionRect(self._sprite.getWidth(), self._sprite.getHeight(), t=self.getTransform().createChild())
self._bounds.addEntity(self)
#self._boundsDisplay = SceneObject(dataSrc = self._bounds, t=self._bounds.getTransform(), color=Color.Green, \
# batch=pyglet.graphics.Batch(), group=LinePolygonMode)
# Set Flight Area
self._flightAreaEdges = [-400+self._sprite.getWidth()/2, 400-self._sprite.getWidth()/2, \
yFaceDirection*(-300+self._sprite.getHeight()/2), -100*yFaceDirection]
if yFaceDirection == -1:
s = self._flightAreaEdges[2]
self._flightAreaEdges[2] = self._flightAreaEdges[3]
self._flightAreaEdges[3] = s
# Create the default weapon
from Weapon import LaserGun
from Weapon import MissleLauncher
self._velocity = vec(0,0)
self._weapon = LaserGun(self, t=self.getTransform().createChild())
self._secondaryWep = MissleLauncher(self, t=self.getTransform().createChild())
def __init__(self, ship, **kwArgs):
super().__init__(ship, **kwArgs)
# General Stats
self._firePoints = [self.getTransform().createChild()]
# Firing Statistics
self._capacity = 5
self._fireRate = 0.25
self._cooldown = 0
# Bullet Statistics
self._deltaAccel = vec(0, 300)
self._bulletAccel = vec(0, 0)
self._bulletVel = vec(0, 30)
self._maxBulletVel = vec(0, 1500)
self._bulletDamage = 200
self._bulletAnimation = rm.activeManager.request("Missle.anim")
self._fireSound = rm.activeManager.request("MissileLauncherLaunch.wav")
def __init__(self, ship, **kwArgs):
super().__init__(**kwArgs)
# General Stats
self._ship = ship
self._firePoints = []
# Firing Statistics
self._capacity = None
self._fireRate = 0
self._cooldown = 0
# Bullet Statistics
self._deltaAccel = vec()
self._bulletAccel = vec()
self._bulletVel = vec(0, 0)
self._maxBulletVel = vec(0, 0)
self._bulletDamage = 0
self._bulletAnimation = None
def update(self, dt): if self._alive: # Move according to last received velocity (aka 'Dead Reckoning') self.translate(self._velocity*dt) # Check Flight Area p = self.getPosition(); np = p.copy() fa = self._flightAreaEdges if p.x < fa[0]: np.x = fa[0] if p.x > fa[1]: np.x = fa[1] if p.y < fa[2]: np.y = fa[2] if p.y > fa[3]: np.y = fa[3] if p != np: self.setTranslation(np) # Update Sprite Data moving = False; direc = vec(0, 0) if(self._velocity != vec(0,0)): moving = True if(self._velocity.x != 0): direc.x = math.copysign(1, self._velocity.x) if(self._velocity.y != 0): direc.y = math.copysign(1, self._velocity.y) # Draw Sprite Accordingly self._sprite.setFrame(self._frameMap[vec(direc.x if self._yFaceDirection==1 else -direc.x, direc.y*self._yFaceDirection)]) if not moving and self._sprite.getFrame() != 4: self._sprite.setFrame(4) # Update Sprite and Bounds if self._sprite.update(dt): self._updateDimensions() self._bounds.update(dt) self._checkDeath(dt)
def __init__(self, ship, **kwArgs):
super().__init__(ship, **kwArgs)
# General Stats
self._powerLevel = 0
# Firing Statistics
self._fireRate = 0.1
self._cooldown = 0
# Bullet Statistics
self._bulletVel = vec(0, 800)
self._maxBulletVel = vec(0, 1000)
self._bulletDamage = 30
self._bulletAnimation = rm.activeManager.request("LaserGunBullet.anim")
self._fireSound = rm.activeManager.request("LaserGunLaunch.wav")
# Set Power to Lvl3
self.increasePower()
self.increasePower()
self.increasePower()
def readKeyboardInput(self, dt): if not self._alive: return actions = Keyboard.localKeyboard.getActions() moving = False for action in actions: if action.name == "Move": direc = action.params[0] direc = direc*self._yFaceDirection self._sprite.setFrame(self._frameMap[vec(direc.x if self._yFaceDirection==1 else -direc.x, direc.y*self._yFaceDirection)]) self.translate(direc*self._speed*dt) self._velocity = direc*self._speed # Check Flight Area p = self.getPosition(); np = p.copy() fa = self._flightAreaEdges if p.x < fa[0]: np.x = fa[0] if p.x > fa[1]: np.x = fa[1] if p.y < fa[2]: np.y = fa[2] if p.y > fa[3]: np.y = fa[3] if p != np: self.setTranslation(np) moving = True elif action.name == "FirePrimary": self._weapon.fire(vec(0, self._yFaceDirection)) elif action.name == "FireSecondary": self._secondaryWep.fire(vec(0, self._yFaceDirection)) if not moving and self._sprite.getFrame() != 4: self._sprite.setFrame(4)
def __init__(self, ship, screenPos): super().__init__() sg = Renderer.activeRenderer.getSceneGraph() self._ship = ship self._maxHealth = ship._health self._screenPos = screenPos tNode = sg.newTransform(t=vec(-280, screenPos*(-300+25))) self._barFill = SceneObject(dataSrc = DiscreteRect(200, h=20), t=tNode, color = Color.Green) self._border = SceneObject(dataSrc = DiscreteRect(w=200, h=20), t=tNode, \ color = Color.Grey, batch=pyglet.graphics.Batch(), group = LinePolygonMode)
def initGame(self): # Get Scene Graph sg = Renderer.getRenderer().getSceneGraph() # Create the Player at 0, -200 self._player = Player(Keyboard.localKeyboard, 1, t=sg.newTransform(t=vec(0, -200))) # Create Entities self._entities = [] self.addEntity(self._player.getShip()) # Create End-Text Display self._endText = None self._endText2 = None
def _translateDependents(self):
pTrans = vec()
if (self._parent):
pTrans = self._parent.getTranslation()
newTranslate = self._translate + pTrans
oldTranslate = self._gTrans.copy()
if (newTranslate != oldTranslate):
self._gTrans = newTranslate
for transformable in self._transformables:
transformable._onTranslation(newTranslate - oldTranslate)
for child in self._children:
child._translateDependents()
def _translateDependents(self): pTrans = vec() if(self._parent): pTrans = self._parent.getTranslation() newTranslate = self._translate + pTrans oldTranslate = self._gTrans.copy() if(newTranslate != oldTranslate): self._gTrans = newTranslate for transformable in self._transformables: transformable._onTranslation(newTranslate-oldTranslate) for child in self._children: child._translateDependents()
def _scaleDependents(self):
pScale = vec(1.0, 1.0)
if self._parent:
pScale = self._parent.getScale()
newScale = self._scale * pScale
oldScale = self._gScale
if newScale != oldScale:
self._gScale = newScale
for transformable in self._transformables:
transformable._onScale(newScale / oldScale)
for child in self._children:
child._scaleDependents()
def _scaleDependents(self):
pScale = vec(1.0, 1.0)
if (self._parent):
pScale = self._parent.getScale()
newScale = self._scale * pScale
oldScale = self._gScale
if (newScale != oldScale):
self._gScale = newScale
for transformable in self._transformables:
transformable._onScale(newScale / oldScale)
for child in self._children:
child._scaleDependents()
def remoteUpdate(self, controlStruc):
if(controlStruc):
# Read Data From Control Structure
health = controlStruc.get('health', self._health)
position = controlStruc.get('position', self.getPosition())
velocity = controlStruc.get('velocity', self._velocity)
frameNum = controlStruc.get('frame', self._sprite.getFrame())
# Set Alive and Position
self._health = health
self.setTranslation(position)
# Set Velocity and Check for Movement
self._velocity = velocity*self._yFaceDirection
if(self._health > 0 and self._velocity != vec(0,0)):
self._sprite.setFrame(frameNum)
def __init__(self, background, pImgs, pSpeeds):
super().__init__()
sg = Renderer.activeRenderer.getSceneGraph()
self._background = Sprite(background, t=sg.newTransform())
self._pSprites = []
for i in range(len(pImgs)):
img = pImgs[i]
sspeed = pSpeeds[i]
# Create Two for Seamless - Parallax Movement
s1 = Sprite(img, t=sg.newTransform())
s2 = Sprite(img, t=sg.newTransform(t=vec(0, img.height)))
self._pSprites.append([s1, sspeed])
self._pSprites.append([s2, sspeed])
def _buildActions(self):
# Check Movement Action
moveDirec = vec()
if self._activeKeys[key.LEFT] or self._activeKeys[key.A]:
moveDirec.x = -1
if self._activeKeys[key.RIGHT] or self._activeKeys[key.D]:
moveDirec.x = 1
if self._activeKeys[key.DOWN] or self._activeKeys[key.S]:
moveDirec.y = -1
if self._activeKeys[key.UP] or self._activeKeys[key.W]:
moveDirec.y = 1
# Build Actions
if self._releasedKeys[key.SPACE]:
self._actionQueue.put(Action("FirePrimary"))
if self._releasedKeys[key.LCTRL] or self._releasedKeys[key.RCTRL]:
self._actionQueue.put(Action("FireSecondary"))
if moveDirec.x or moveDirec.y:
self._actionQueue.put(Action("Move", moveDirec))
cw = CollisionWorld()
rm = ResourceManager("Tests\\data")
ResourceManager.activeManager = rm
rm.registerExtension(".jpg", "img", ["img"], pyglet.image.load)
rm.registerExtension(".bmp", "img", ["img"], pyglet.image.load)
rm.registerExtension(".png", "img", ["img"], pyglet.image.load)
rm.registerExtension(".anim", "anim", ["anim"], Animation)
anim1 = rm.request("CharizardEvolve.anim")
anim2 = rm.request("PShip.anim")
s1 = Sprite(anim1); s1.setAnimation("Alternating")
s2 = Sprite(anim2); s2.setAnimation("Looping")
e1 = Entity(s1, t=sg.newTransform(t=vec(-100,100))); e2 = Entity(s2, t=sg.newTransform(t=vec(100,-30)))
cw.addPrimitive(e1._collider)
cw.addPrimitive(e2._collider)
print("")
rm.debugDisplay()
print("")
def update(dt):
cw.update(dt)
e1.update(dt)
e2.update(dt)
from Renderer import Renderer
from TransformationGraph import Transform
from SceneObject import SceneObject
from DiscretePrimitives import *
from Vector import vec
#-------------------------------------------------------#
window = pyglet.window.Window(800, 600)
winDimensions = [800, 600]
rendMan = Renderer(winSize=winDimensions)
sg = rendMan.getSceneGraph()
so1 = SceneObject(t=sg.newTransform(t=vec(150,0)), vs=[vec(-100,-100), vec(100,-100), vec(100,100), vec(-100,100)], ds=GL_LINES,
vis = (0, 1, 1, 2, 2, 3, 3, 0), cs = Color.Purple+Color.Blue+Color.Orange+Color.Green)
so2 = SceneObject(t=so1.getTransform().createChild(), dataSrc=DiscreteRect(10, 50))
so3 = SceneObject(t=sg.newTransform(), numVerts=3, drawStyle=GL_TRIANGLES, explicitData=[('v2f/static', [-30, -30, 30, -30, 0, 30])])
def update(dt):
so2.rotate(.005)
@window.event
def on_draw():
window.clear()
rendMan.render()
pyglet.clock.schedule(update)
pyglet.app.run()
def translate2f(self, x, y):
self._translate += vec(x, y)
self._translateDependents()
def setTranslation2f(self, x, y):
self._translate = vec(x, y)
self._translateDependents()
def setTranslation2f(self, x, y):
self._translate = vec(x, y)
self._translateDependents()
def setScale2f(self, x, y):
self._scale = vec(x, y)
self._scaleDependents()
def scale2f(self, x, y):
self._scale *= vec(x, y)
self._scaleDependents()
def __init__(self, a, b, **kwArgs): self._a = vec(a, 0) self._b = vec(0, b) super().__init__(**kwArgs)
def translate2f(self, x, y):
self._translate += vec(x, y)
self._translateDependents()
def setScale2f(self, x, y):
self._scale = vec(x, y)
self._scaleDependents()
def __init__(self, w, h, **kwArgs): self._width = w self._height = h self._diagonal = vec(w/2, h/2) super().__init__(**kwArgs)
from TransformationGraph import Transform
from SceneObject import SceneObject
from DiscretePrimitives import *
from Vector import vec
#-------------------------------------------------------#
window = pyglet.window.Window(800, 600)
winDimensions = [800, 600]
rendMan = Renderer(winSize=winDimensions)
sg = rendMan.getSceneGraph()
so1 = SceneObject(
t=sg.newTransform(t=vec(150, 0)),
vs=[vec(-100, -100),
vec(100, -100),
vec(100, 100),
vec(-100, 100)],
ds=GL_LINES,
vis=(0, 1, 1, 2, 2, 3, 3, 0),
cs=Color.Purple + Color.Blue + Color.Orange + Color.Green)
so2 = SceneObject(t=so1.getTransform().createChild(),
dataSrc=DiscreteRect(10, 50))
so3 = SceneObject(t=sg.newTransform(),
numVerts=3,
drawStyle=GL_TRIANGLES,
explicitData=[('v2f/static', [-30, -30, 30, -30, 0, 30])])
Renderer.activeRenderer = rendMan
sg = rendMan.getSceneGraph()
rm = ResourceManager("Tests\\data")
ResourceManager.activeManager = rm
rm.registerExtension(".jpg", "img", ["img"], pyglet.image.load)
rm.registerExtension(".bmp", "img", ["img"], pyglet.image.load)
rm.registerExtension(".png", "img", ["img"], pyglet.image.load)
rm.registerExtension(".anim", "anim", ["anim"], Animation)
anim1 = rm.request("CharizardEvolve.anim")
anim2 = rm.request("PShip.anim")
s1 = Sprite(anim1, t=sg.newTransform())
s2 = Sprite(anim2, t=sg.newTransform(t=vec(-200,100)))
s1.setAnimation("Alternating")
s2.setAnimation("Looping")
print("")
rm.debugDisplay()
print("")
def update(dt):
s1.update(dt)
s2.update(dt)
def __init__(self, a, b, **kwArgs):
self._a = vec(a, 0)
self._b = vec(0, b)
super().__init__(**kwArgs)
def __init__(self, w, h, **kwArgs):
self._width = w
self._height = h
self._diagonal = vec(w / 2, h / 2)
super().__init__(**kwArgs)
Renderer.activeRenderer = rendMan
sg = rendMan.getSceneGraph()
rm = ResourceManager("Tests\\data")
ResourceManager.activeManager = rm
rm.registerExtension(".jpg", "img", ["img"], pyglet.image.load)
rm.registerExtension(".bmp", "img", ["img"], pyglet.image.load)
rm.registerExtension(".png", "img", ["img"], pyglet.image.load)
rm.registerExtension(".anim", "anim", ["anim"], Animation)
anim1 = rm.request("CharizardEvolve.anim")
anim2 = rm.request("PShip.anim")
s1 = Sprite(anim1, t=sg.newTransform())
s2 = Sprite(anim2, t=sg.newTransform(t=vec(-200, 100)))
s1.setAnimation("Alternating")
s2.setAnimation("Looping")
print("")
rm.debugDisplay()
print("")
def update(dt):
s1.update(dt)
s2.update(dt)
@window.event
def scale2f(self, x, y):
self._scale *= vec(x, y)
self._scaleDependents()
