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 update_room(self):
try:
if len(self.clients) <= 0: return
if self.paused: return;
map(lambda i: i.update(self), self.items)
self.gamemode.update(self)
if self.intermission_end_time is not None:
if time.time() > self.intermission_end_time:
with self.broadcastbuffer(1, True) as cds:
swh.put_mapreload(cds)
self.intermission_end_time = None
elif self.match_end_time is not None and self.gamemode.timed:
if time.time() > self.match_end_time:
with self.broadcastbuffer(1, True) as cds:
swh.put_timeup(cds, 0)
self.match_end_time = None
self.intermission_end_time = time.time() + INTERMISSIONLEN
except:
traceback.print_exc()
def writestate(self, pos_cds, msg_cds):
if self.state.position is not None:
pos_cds.write(self.state.position)
self.state.position = None
if not self.state.messages.empty():
swh.put_clientdata(msg_cds, self, self.state.messages)
self.state.messages.clear()
def __init__(self, peer):
ClientBase.__init__(self)
self.peer = peer
self.bots = {}
self.ping_buffer = PingBuffer()
with self.sendbuffer(1, True) as cds:
swh.put_servinfo(cds, self, haspwd=False, description="Test Server")
def pickup(self, room, client):
if self.spawntime != -1: return
client.state.pickup_item(self.type)
with room.broadcastbuffer(1, True) as cds:
swh.put_itemacc(cds, self, client)
playercount = len(room.clients)
self.spawntime = time.time() + Item.respawn_delay(self.type, playercount)
self.announced = False
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 paused(self, value):
if self.paused == value: return
with self.broadcastbuffer(1, True) as cds:
if value:
self.pause_start = time.time()
else:
extend = (time.time() - self.pause_start)
map(lambda i: i.extend(extend), self.items)
self.match_end_time += extend
self.pause_start = None
swh.put_pausegame(cds, self.paused)
if not value:
swh.put_timeup(cds, self.timeleft)
def update(self, room):
if self.spawntime == -1: return
if self.spawntime < time.time():
with room.broadcastbuffer(1, True) as cds:
swh.put_itemspawn(cds, self)
self.spawntime = -1
return
if self.type in [item_types.I_QUAD, item_types.I_BOOST] and (self.spawntime - time.time()) < 10 and not self.announced:
with room.broadcastbuffer(1, True) as cds:
swh.put_announce(cds, self)
self.announced = True
def change_map_mode(self, map_name, mode_num):
if not mode_num in gamemodes.keys():
return
self.gamemode = gamemodes[mode_num]()
self.hasitems = False
self.items = []
self.map_name = map_name
self.mode_num = mode_num
with self.broadcastbuffer(1, True) as cds:
swh.put_mapchange(cds, self.map_name, self.mode_num, self.hasitems)
for client in self.clients.values():
client.send_spawn_state(self.gamemode)
if self.gamemode.timed:
self.timeleft = self.gamemode.timeout
def on_client_explode(self, client, cmillis, gun, explode_id, hits):
if gun == weapon_types.GUN_RL:
if not explode_id in client.state.rockets.keys(): return
del client.state.rockets[explode_id]
elif gun == weapon_types.GUN_GL:
if not explode_id in client.state.grenades.keys(): return
del client.state.grenades[explode_id]
with self.broadcastbuffer(1, True, [client]) as cds:
swh.put_explodefx(cds, client, gun, explode_id)
if gun == weapon_types.GUN_SG:
max_rays = SGRAYS
else:
max_rays = 1
total_rays = 0
for hit in hits:
total_rays += hit['rays']
if total_rays > max_rays:
break
self.on_client_hit(client, gun, **hit)
def on_receive_event(self, channel, data):
if len(data) <= 0:
pass
try:
if channel == 0:
try:
cds = CubeDataStream(data)
message_type = cds.getint()
cn = cds.getint()
self.getclient(cn).state.position = data
except:
traceback.print_exc()
elif channel == 1:
messages = sauerbraten_stream_spec.read(data, {'aiclientnum': -1})
for message_type, message in messages:
if (not self.isconnected) and message_type != "N_CONNECT":
self.peer.disconnect(disconnect_types.DISC_TAGT) #@UndefinedVariable
return
elif self.isconnected and message_type == "N_CONNECT":
self.peer.disconnect(disconnect_types.DISC_TAGT) #@UndefinedVariable
return
elif message_type == "N_CONNECT":
self.isconnected = True
self.name = filtertext(message['name'], False, MAXNAMELEN)
self.pwdhash = message['pwdhash']
self.playermodel = message['playermodel']
self.connected.emit(self)
elif message_type == "N_SWITCHNAME":
name = filtertext(message['name'], False, MAXNAMELEN)
if len(name) <= 0:
name = "unnamed"
if name != self.name:
self.name = name
swh.put_switchname(self.state.messages, self.name)
elif message_type == "N_SWITCHTEAM":
team_name = filtertext(message['team'], False, MAXTEAMLEN)
if self.team is not None and team_name != self.team.name:
self.trysetteam.emit(self, self.cn, self.team, team_name)
elif message_type == "N_SPECTATOR":
self.setspectator.emit(self, message['target_cn'], bool(message['value']))
elif message_type == "N_PING":
with self.sendbuffer(1, False) as cds:
swh.put_pong(cds, message['cmillis'])
elif message_type == "N_CLIENTPING":
self.ping_buffer.add(message['ping'])
self.ping.emit(self)
swh.put_clientping(self.state.messages, message['ping'])
elif message_type == "N_MAPVOTE":
self.mapvote.emit(self, message['map_name'], message['mode_num'])
elif message_type == "N_MAPCHANGE":
self.mapvote.emit(self, message['map_name'], message['mode_num'])
elif message_type == "N_MAPCRC":
self.mapcrc.emit(self, message['mapcrc'])
elif message_type == "N_ITEMLIST":
self.itemlist.emit(self, message['items'])
elif message_type == "N_BASES":
self.baselist.emit(self, message['bases'])
elif message_type == "N_INITFLAGS":
self.flaglist.emit(self, message['flags'])
elif message_type == "N_SPAWN":
client = self.getclient(message['aiclientnum'])
client.state.state = client_states.CS_ALIVE
client.lifesequence = message['lifesequence']
client.gunselect = message['gunselect']
swh.put_spawn(client.state.messages, self)
elif message_type == "N_TRYSPAWN":
self.tryspawn.emit(self.getclient(message['aiclientnum']))
elif message_type == "N_SHOOT":
message['client'] = self.getclient(message['aiclientnum'])
del message['aiclientnum']
self.shoot.emit(**message)
elif message_type == "N_EXPLODE":
message['client'] = self.getclient(message['aiclientnum'])
del message['aiclientnum']
self.explode.emit(**message)
elif message_type == "N_SUICIDE":
self.suicide.emit(self.getclient(message['aiclientnum']))
elif message_type == "N_JUMPPAD":
cn = message['clientnum']
self.jumppad.emit(self.getclient(cn), message['jumppad'])
elif message_type == "N_TELEPORT":
cn = message['clientnum']
self.teleport.emit(self.getclient(cn), message['teleport'], message['teledest'])
elif message_type == "N_GUNSELECT":
mcds = self.getclient(message['aiclientnum']).state.messages
swh.put_gunselect(mcds, message['gunselect'])
self.state.gunselect = message['gunselect']
elif message_type == "N_SOUND":
mcds = self.getclient(message['aiclientnum']).state.messages
swh.put_gunselect(mcds, message['sound'])
elif message_type == "N_ITEMPICKUP":
self.pickup.emit(self.getclient(message['aiclientnum']), message['item_index'])
elif message_type == "N_REPAMMO":
self.replenishammo.emit(self.getclient(message['aiclientnum']))
elif message_type == "N_TAKEFLAG":
self.takeflag.emit(self.getclient(message['aiclientnum']), message['flag'], message['version'])
elif message_type == "N_TRYDROPFLAG":
self.trydropflag.emit(self.getclient(message['aiclientnum']))
elif message_type == "N_PAUSEGAME":
self.trypausegame.emit(self, message['value'])
else:
print message_type, message
else: #channel == 2:
pass
except InvalidClientNumberReference:
return
except:
traceback.print_exc()
def on_client_teleport(self, client, teleport, teledest):
with self.broadcastbuffer(1, True, [client]) as cds:
swh.put_teleport(cds, client, teleport, teledest)
def on_client_jumppad(self, client, jumppad):
with self.broadcastbuffer(1, True, [client]) as cds:
swh.put_jumppad(cds, client, jumppad)
def on_client_suicide(self, client):
with self.broadcastbuffer(1, True) as cds:
swh.put_died(cds, client, client)
client.state.state = client_states.CS_DEAD
def on_client_disconnected(self, client):
if client.cn in self.clients.keys():
del self.clients[client.cn]
with self.broadcastbuffer(1, True) as cds:
swh.put_cdis(cds, client)
self.gamemode.on_client_disconnected(self, client)
def timeleft(self, value):
self.match_end_time = time.time() + value
with self.broadcastbuffer(1, True) as cds:
swh.put_timeup(cds, self.timeleft)
def add_client(self, client):
try:
existing_clients = self.clients.values()
self.clients[client.cn] = client
self.gamemode.on_client_connected(self, client)
# Connect up all the client signals
client.connect_all_instance_signals(self, "on_client_")
# Tell the client about the status of the room
with client.sendbuffer(1, True) as cds:
swh.put_welcome(cds, self.hasmap)
if self.map_name != None:
swh.put_mapchange(cds, self.map_name, self.mode_num, self.hasitems)
if self.gamemode.timed and self.match_end_time is not None:
swh.put_timeup(cds, self.timeleft)
if self.gamemode.hasitems and self.hasitems:
swh.put_itemlist(cds, self.items)
swh.put_resume(cds, existing_clients)
swh.put_initclients(cds, existing_clients)
# Tell the other clients about the newcomer
with self.broadcastbuffer(1, True, [client]) as cds:
swh.put_resume(cds, [client])
swh.put_initclients(cds, [client])
if len(existing_clients) > 0:
client.send_spawn_state(self.gamemode)
except:
traceback.print_exc()
def send_spawn_state(self, gamemode):
self.state.respawn(gamemode)
with self.sendbuffer(1, True) as cds:
swh.put_spawnstate(cds, self)
