def serverUpdate(self, aiWorld, entityGroup, packetUpdate):
p = Weapon.serverUpdate(self, aiWorld, entityGroup, packetUpdate)
if self.reloadStarted:
self.addCriticalPacket(p, packetUpdate)
self.reloadStarted = False
self.reloadActive = self.newReloadActive
self.activeSound = 0 # No sound
if self.reloadActive:
if engine.clock.time - self.lastReload < self.reloadTime:
self.activeSound = 1 # Reload beep sound
else:
self.ammo = self.clipSize
self.reloadActive = False
self.newReloadActive = False
self.activeSound = 2 # Reload ready sound
self.addCriticalPacket(p, packetUpdate)
p.add(net.Uint8(self.activeSound))
p.add(net.Boolean(self.selected))
self.ammo += self.ammoAdditions
self.ammoAdditions = 0
if self.selected:
p.add(net.Uint8(self.ammo))
return p
def registerHost(username, map, players, playerSlots):
p = net.Packet()
p.add(net.Uint8(net.PACKET_REGISTERHOST))
p.add(net.String(username))
p.add(net.String(map))
p.add(net.Uint8(players))
p.add(net.Uint8(playerSlots))
net.context.send(p, address)
def serverUpdate(self, aiWorld, entityGroup, packetUpdate):
p = Gun.serverUpdate(self, aiWorld, entityGroup, packetUpdate)
if self.active and self.firing:
self.addCriticalPacket(p, packetUpdate)
p.add(net.Boolean(True))
vector = self.actor.controller.targetPos - self.actor.getPosition()
pos = vector.cross(Vec3(0, 0, 1))
pos.normalize()
origin = self.actor.getPosition() + (pos *
(self.actor.radius + 0.1))
direction = self.actor.controller.targetPos - origin
direction.normalize()
if self.zoomed:
angleX = uniform(-0.5, 0.5)
angleY = uniform(-0.5, 0.5)
else:
angleX = uniform(-2, 2)
angleY = uniform(-2, 2)
mat = Mat3()
mat.setRotateMatNormaxis(
angleX, render.getRelativeVector(self.node, Vec3(0, 0, 1)))
direction = mat.xformVec(direction)
mat = Mat3()
mat.setRotateMatNormaxis(
angleY, render.getRelativeVector(self.node, Vec3(1, 0, 0)))
direction = mat.xformVec(direction)
p.add(net2.StandardVec3(direction))
entity = None
hitPos = None
if direction.length() > 0:
entity, hitPos, normal, queue = self.bulletTest(
aiWorld, entityGroup, origin, direction)
if hitPos == None:
p.add(net.Boolean(False)) # Bullet didn't hit anything
else:
p.add(net.Boolean(True)) # Bullet hit something
p.add(net2.StandardVec3(hitPos))
if entity != None:
p.add(net.Boolean(True))
p.add(net.Uint8(entity.getId()))
p.add(
net.Uint16(self.damage *
max(0, 1 - (vector.length() / 70)) *
max(0,
normal.dot(-direction) + 0.1)))
else:
p.add(net.Boolean(False))
else:
p.add(net.Boolean(False))
self.firing = False
return p
def serverUpdate(self, aiWorld, entityGroup, packetUpdate):
p = Weapon.serverUpdate(self, aiWorld, entityGroup, packetUpdate)
if self.firing and self.active:
self.addCriticalPacket(p, packetUpdate)
p.add(net.Uint8(1)) # 1 = We're starting to impale an entity
enemy = aiWorld.getNearestEnemy(entityGroup,
self.actor.getPosition(),
self.actor.getTeam(),
includeCloakedUnits=True)
if enemy != None:
vector = self.actor.controller.targetPos - base.camera.getPos()
vector2 = enemy.getPosition() - base.camera.getPos()
vector3 = enemy.getPosition() - self.actor.getPosition()
vector.normalize()
vector2.normalize()
if math.acos(vector.getX() * vector2.getX() + vector.getY() *
vector2.getY() + vector.getZ() * vector2.getZ()
) < math.pi / 5 and vector3.length() < 8:
p.add(net.Boolean(True))
vector3.normalize()
self.actor.addForce(engine.impulseToForce(vector3 * 1000))
self.impulseVector = vector3
self.impaleTarget = enemy
else:
p.add(net.Boolean(False))
else:
p.add(net.Boolean(False))
self.firing = False
elif self.active and self.impaleStart != -1 and self.impaleTarget != None and self.impaleTarget.active and (
self.actor.getPosition() - self.impaleTarget.getPosition()
).length() < self.actor.radius + self.impaleTarget.radius + 0.5:
self.addCriticalPacket(p, packetUpdate)
# At this point, the blade is actually in the target.
p.add(net.Uint8(2)) # 2 = We're now actually damaging the entity
p.add(net.Uint8(self.impaleTarget.getId()))
# Stop the player from flying past the target.
if self.impaleTarget.health > self.damage: # Only add force if we don't kill the target. If the target dies, the explosion will already push us away.
self.actor.addForce(
engine.impulseToForce(self.impulseVector * -800))
self.impaleTarget = None
else:
p.add(net.Uint8(0)) # 0 = Nothing's happening
return p
def serverUpdate(self, aiWorld, entityGroup, packetUpdate):
p = net.Packet()
if packetUpdate:
self.criticalUpdate = len(self.criticalPackets) > 0
for packet in self.criticalPackets:
p.add(packet)
del self.criticalPackets[:]
else:
self.criticalUpdate = False
p.add(net.Uint8(self.id))
return p
def connectTo(ip, port=None):
if port == None:
if ip.find(":") != -1:
ip, port = ip.split(":")
else:
port = 1337
port = int(port)
engine.log.info("Notifying lobby server of intention to connect to " + ip +
":" + str(port))
p = net.Packet()
p.add(net.Uint8(net.PACKET_CLIENTCONNECTNOTIFICATION))
p.add(net.String(ip))
p.add(net.Uint16(port))
net.context.send(p, address)
def serverUpdate(self, aiWorld, entityGroup, packetUpdate):
p = Gun.serverUpdate(self, aiWorld, entityGroup, packetUpdate)
if self.active and self.firing:
self.addCriticalPacket(p, packetUpdate)
p.add(net.Boolean(True))
vector = self.actor.controller.targetPos - self.actor.getPosition()
pos = vector.cross(Vec3(0, 0, 1))
pos.normalize()
origin = self.actor.getPosition() + (pos *
(self.actor.radius + 0.1))
direction = self.actor.controller.targetPos - origin
direction.normalize()
p.add(net2.StandardVec3(direction))
entity = None
hitPos = None
if direction.length() > 0:
entity, hitPos, normal, queue = self.bulletTest(
aiWorld, entityGroup, origin, direction)
if hitPos == None:
p.add(net.Boolean(False)) # Bullet didn't hit anything
else:
p.add(net.Boolean(True)) # Bullet hit something
p.add(net2.StandardVec3(hitPos))
if entity != None:
p.add(net.Boolean(True))
p.add(net.Uint8(entity.getId()))
vector = entity.getPosition() - self.getPosition()
range = self.range
if self.zoomed:
range *= 1.5
p.add(
net.Uint16(self.damage * max(
0, 1 - (vector.length() / range) *
max(0,
normal.dot(-direction) * 1.25))))
else:
p.add(net.Boolean(False))
else:
p.add(net.Boolean(False))
self.firing = False
return p
def serverUpdate(self, aiWorld, entityGroup, packetUpdate):
p = Weapon.serverUpdate(self, aiWorld, entityGroup, packetUpdate)
p.add(net.Boolean(self.firing))
if self.firing:
self.addCriticalPacket(p, packetUpdate)
direction = self.actor.controller.targetPos - self.actor.getPosition(
)
direction.normalize()
direction.setZ(direction.getZ() + 0.5)
direction.normalize()
origin = self.actor.getPosition() + (direction *
(self.actor.radius + 0.1))
grenade = entities.Molotov(aiWorld.world, aiWorld.space)
grenade.setTeam(self.actor.getTeam())
grenade.setActor(self.actor)
grenade.setPosition(origin)
grenade.setLinearVelocity(direction * 40)
entityGroup.spawnEntity(grenade)
p.add(net.Uint8(grenade.getId()))
self.firing = False
return p
def update(self, backend):
# Only send out an update packet if we need to
packetUpdate = False
if engine.clock.time - self.lastPacketUpdate >= net.SERVER_TICK:
packetUpdate = True
self.lastPacketUpdate = engine.clock.time # Reset packet update timer
sendSpawn = False
spawnPacket = net.Packet()
if len(self.spawnPackets) > 0 and packetUpdate:
sendSpawn = True
for p in self.spawnPackets:
spawnPacket.add(p)
del self.spawnPackets[:]
entityList = backend.entityGroup.entities.values()
updatedEntities = []
controllerPacket = net.Packet()
for entity in (x for x in entityList if x.active and x.isLocal):
# Do a server update for local entities.
# The controller packet is only sent if we've exceeded the regular packet update interval.
p = entity.controller.serverUpdate(backend.aiWorld,
backend.entityGroup,
packetUpdate)
if p != None and entity.controller.needsToSendUpdate():
controllerPacket.add(p)
updatedEntities.append(entity)
# Make sure we update our own copy of the entities.
sendController = False
if len(controllerPacket.dataObjects) > 0:
sendController = True
data = PyDatagram()
controllerPacket.addTo(data)
self.processPacket(data, backend)
deletePacket = net.Packet()
sendDelete = False
if len(self.deletePackets) > 0 and packetUpdate:
sendDelete = True
for p in self.deletePackets:
deletePacket.add(p)
del self.deletePackets[:]
if packetUpdate:
outboundPacket = net.Packet()
outboundPacket.add(spawnPacket)
outboundPacket.add(controllerPacket)
outboundPacket.add(deletePacket)
for chat in self.chatPackets:
outboundPacket.add(chat)
sendChat = len(self.chatPackets) > 0
del self.chatPackets[:]
for request in self.clientSpawnPacketRequests:
entity = backend.entityGroup.getEntity(request[0])
if entity != None:
if net.netMode == net.MODE_CLIENT:
outboundPacket.add(
entity.controller.buildSpawnPacket())
else:
temp = net.Packet()
temp.add(entity.controller.buildSpawnPacket())
net.context.send(temp, request[1])
engine.log.info("Sending missed spawn packet (ID " +
str(request[0]) + ") to client " +
net.addressToString(request[1]))
else:
engine.log.warning(
"Client requested spawn packet for non-existent entity."
)
del self.clientSpawnPacketRequests[:]
sendCheckSum = False
if net.netMode == net.MODE_SERVER and engine.clock.time - self.lastCheckSumSent > 5.0:
self.lastCheckSumSent = engine.clock.time
checkSumPacket = net.Packet()
checkSumPacket.add(net.Uint8(net.PACKET_ENTITYCHECKSUM))
checkSumPacket.add(
net.Uint8(
len([
x for x in entityList
if x.active and x.getId() < 256
])))
outboundPacket.add(checkSumPacket)
sendCheckSum = True
if sendSpawn or sendController or sendDelete or sendCheckSum or sendChat:
net.context.broadcast(outboundPacket)
packets = net.context.readTick()
for packet in packets:
data = PyDatagram(packet[0])
rebroadcast = self.processPacket(data, backend, packet[1])
self.incomingPackets += 1
self.totalIncomingPacketSize += len(packet[0])
if net.netMode == net.MODE_SERVER and rebroadcast:
net.context.broadcastDatagramExcept(data, packet[1])
del packets
if len(entityList) > len(updatedEntities):
for entity in (x for x in entityList
if x.active and not x in updatedEntities):
entity.controller.clientUpdate(backend.aiWorld,
backend.entityGroup)
clientAddress = [] if net.netMode == net.MODE_SERVER else [
net.context.hostConnection
]
emptyPacket = net.Packet()
emptyPacket.add(net.Uint8(net.PACKET_EMPTY))
for client in (x for x in net.context.activeConnections.values() +
clientAddress if net.timeFunction() -
x.lastSentPacketTime > 0.5 and x.ready):
net.context.send(emptyPacket, client.address)
net.context.writeTick()
def processPacket(self, packet, backend, sender=None):
iterator = PyDatagramIterator(packet)
lastId = "None"
lastController = "None"
try:
rebroadcast = True
while iterator.getRemainingSize() > 0:
type = net.Uint8.getFrom(iterator)
if type == net.PACKET_CONTROLLER:
rebroadcast = True
id = net.Uint8.getFrom(iterator)
entity = backend.entityGroup.getEntity(id)
if entity != None:
lastId = str(id)
lastController = entity.controller
entity.controller.clientUpdate(backend.aiWorld,
backend.entityGroup,
iterator)
else:
engine.log.warning(
"Received controller packet with no matching entity. ID: "
+ str(id) + " Last entity updated: " + lastId +
" - controller: " + str(lastController))
if sender != None and (
(not id in self.requestedEntitySpawns.keys()) or
(engine.clock.time - self.requestedEntitySpawns[id]
> 2.0)
): # Only send a request once every two seconds
p = net.Packet()
p.add(net.Uint8(net.PACKET_REQUESTSPAWNPACKET))
p.add(net.Uint8(id))
net.context.send(p, sender)
self.requestedEntitySpawns[id] = engine.clock.time
engine.log.info(
"Sending request for missing entity spawn packet. Entity ID: "
+ str(id))
return rebroadcast
elif type == net.PACKET_SPAWN:
controllerType = net.Uint8.getFrom(iterator)
entity = controllers.types[controllerType].readSpawnPacket(
backend.aiWorld, backend.entityGroup, iterator)
if entity.getId() in self.requestedEntitySpawns.keys():
del self.requestedEntitySpawns[entity.getId()]
if entity != None and backend.entityGroup.getEntity(
entity.getId()) == None:
backend.entityGroup.addEntity(entity)
elif entity != None:
engine.log.warning(
"Spawned entity " + str(entity.getId()) +
" already exists. Cancelling spawn.")
entity.delete(backend.entityGroup,
killed=False,
localDelete=False)
rebroadcast = True
elif type == net.PACKET_DELETE:
id = net.Uint8.getFrom(iterator)
entity = backend.entityGroup.getEntity(id)
killed = net.Boolean.getFrom(iterator)
if entity != None:
if killed: # The boolean indicates that the entity was not only deleted, it was killed. Also, let the entity know this was a remote delete packet.
entity.kill(backend.aiWorld, backend.entityGroup,
False)
else:
entity.delete(backend.entityGroup, False, False)
rebroadcast = True
elif type == net.PACKET_REQUESTSPAWNPACKET:
self.clientSpawnPacketRequests.append(
(net.Uint8.getFrom(iterator), sender))
rebroadcast = False
elif type == net.PACKET_SETUP:
if net.netMode == net.MODE_CLIENT:
messenger.send("client-setup", [iterator])
else:
return False
rebroadcast = False
elif type == net.PACKET_CHAT:
messenger.send("chat-incoming", [
net.String.getFrom(iterator),
net.String.getFrom(iterator)
]) # Username and message
rebroadcast = True
elif type == net.PACKET_ENDMATCH:
engine.log.info("Received match end packet.")
messenger.send("end-match", [iterator])
rebroadcast = True
elif type == net.PACKET_NEWCLIENT:
messenger.send(
"server-new-connection",
[sender, net.String.getFrom(iterator)
]) # Sender address and username
rebroadcast = False
elif type == net.PACKET_DISCONNECT:
engine.log.info(
net.addressToString(sender) + " disconnected.")
messenger.send("disconnect", [sender])
rebroadcast = False
elif type == net.PACKET_SERVERFULL:
messenger.send("server-full")
elif type == net.PACKET_CONFIRMREGISTER:
messenger.send("lobby-confirm-register")
rebroadcast = False
elif type == net.PACKET_EMPTY:
rebroadcast = False
elif type == net.PACKET_CLIENTREADY:
rebroadcast = False
messenger.send("client-ready", [sender])
elif type == net.PACKET_NEWCLIENTNOTIFICATION:
address = net.String.getFrom(iterator)
port = net.Uint16.getFrom(iterator)
# Make sure we get all the data out of the packet to ensure proper processing.
# This packet has already been handled by the NetContext.
rebroadcast = False
elif type == net.PACKET_ENTITYCHECKSUM:
checksum = net.Uint8.getFrom(
iterator
) # Number of active entities we're supposed to have
if net.netMode == net.MODE_CLIENT and checksum != len([
x for x in backend.entityGroup.entities.values()
if x.active and x.getId() < 256
]):
# We don't have the right number of entities
p = net.Packet()
p.add(net.Uint8(net.PACKET_REQUESTENTITYLIST))
net.context.send(p, sender)
engine.log.info(
"Entity checksum failed. Requesting full entity list."
)
rebroadcast = False
elif type == net.PACKET_REQUESTENTITYLIST:
p = net.Packet()
p.add(net.Uint8(net.PACKET_ENTITYLIST))
entityList = [
x for x in backend.entityGroup.entities.values()
if x.active and x.getId() < 256
]
p.add(net.Uint8(len(entityList)))
for entity in entityList:
p.add(net.Uint8(entity.getId()))
net.context.send(p, sender)
engine.log.info("Sending entity list to " +
net.addressToString(sender))
rebroadcast = False
elif type == net.PACKET_ENTITYLIST:
total = net.Uint8.getFrom(iterator)
entities = []
missingEntities = []
for _ in range(total):
id = net.Uint8.getFrom(iterator)
if id not in backend.entityGroup.entities.keys():
missingEntities.append(id)
entities.append(id)
# Delete any extra entities, assuming they aren't ones that we just spawned on our end.
for entity in (
x for x in backend.entityGroup.entities.values()
if x.active and x.getId() < 256):
if entity.getId(
) not in entities and engine.clock.time - entity.spawnTime > 5.0:
entity.delete(backend.entityGroup, False, False)
if len(missingEntities) > 0:
# Request spawn packets for any missing entities
p = net.Packet()
for id in missingEntities:
p.add(net.Uint8(net.PACKET_REQUESTSPAWNPACKET))
p.add(net.Uint8(id))
self.requestedEntitySpawns[id] = engine.clock.time
engine.log.info(
"Sending request for missing entity spawn packet. Entity ID: "
+ str(id))
net.context.send(p, sender)
rebroadcast = False
else:
rebroadcast = False
except AssertionError:
engine.log.warning("Packet iteration failed. Discarding packet.")
rebroadcast = False
return rebroadcast
def chatHandler(self, username, message):
p = net.Packet()
p.add(net.Uint8(net.PACKET_CHAT))
p.add(net.String(username))
p.add(net.String(message))
self.chatPackets.append(p)
def getHosts():
engine.log.info("Requesting host list from lobby server")
p = net.Packet()
p.add(net.Uint8(net.PACKET_REQUESTHOSTLIST))
net.context.send(p, address)
def serverUpdate(self, aiWorld, entityGroup, packetUpdate):
p = Gun.serverUpdate(self, aiWorld, entityGroup, packetUpdate)
if self.active and self.firing:
self.addCriticalPacket(p, packetUpdate)
p.add(net.Boolean(True))
vector = self.actor.controller.targetPos - self.actor.getPosition()
pos = vector.cross(Vec3(0, 0, 1))
pos.normalize()
origin = self.actor.getPosition() + (pos *
(self.actor.radius + 0.1))
direction = self.actor.controller.targetPos - origin
direction.normalize()
inaccuracy = 0.5 if self.zoomed else 1.5
angleX = uniform(-inaccuracy, inaccuracy)
angleY = uniform(-inaccuracy, inaccuracy)
mat = Mat3()
mat.setRotateMatNormaxis(
angleX, render.getRelativeVector(self.node, Vec3(0, 0, 1)))
direction = mat.xformVec(direction)
mat = Mat3()
mat.setRotateMatNormaxis(
angleY, render.getRelativeVector(self.node, Vec3(1, 0, 0)))
direction = mat.xformVec(direction)
p.add(net2.StandardVec3(direction))
entity = None
hitPos = None
if direction.length() > 0:
entity, hitPos, normal, queue = self.bulletTest(
aiWorld, entityGroup, origin, direction)
if hitPos == None:
p.add(net.Boolean(False)) # Bullet didn't hit anything
else:
p.add(net.Boolean(True)) # Bullet hit something
p.add(net2.StandardVec3(hitPos))
if entity != None:
p.add(net.Boolean(True))
p.add(net.Uint8(entity.getId()))
totalDamage = self.damage * max(
0, 1 - (vector.length() / 200)) * max(
0,
normal.dot(-direction) + 0.1)
p.add(net.Uint16(totalDamage))
pinned = False
if isinstance(entity, entities.BasicDroid):
for i in range(queue.getNumEntries()):
entry = queue.getEntry(i)
pos = entry.getSurfacePoint(render)
testEntity = entityGroup.getEntityFromEntry(entry)
if testEntity == None and (pos -
hitPos).length() < 5:
p.add(net.Boolean(True))
p.add(net2.HighResVec3(pos))
pinned = True
break
if not pinned:
p.add(net.Boolean(False))
p.add(net2.HighResVec3(hitPos))
else:
p.add(net.Boolean(False))
else:
p.add(net.Boolean(False))
self.firing = False
return p
