def on_position_update(self):
if not self.local:
return connection.on_position_update(self)
pos = self.world_object.position
if self.protocol.game_mode == CTF_MODE:
other_flag = self.team.other.flag
if vector_collision(pos, self.team.base):
if other_flag.player is self:
self.capture_flag()
if not other_flag.player and vector_collision(pos, other_flag):
self.take_flag()
# go home and ignore enemies
self.go_to(self.team.base.get())
self.acquire_targets = False
if self.grenade_call and self.grenade_call.active():
self.grenade_call.cancel()
self.grenade_call = None
elif self.protocol.game_mode == TC_MODE:
for entity in self.protocol.entities:
collides = vector_collision(entity,
self.world_object.position,
TC_CAPTURE_DISTANCE)
if self in entity.players:
if not collides:
entity.remove_player(self)
else:
if collides:
entity.add_player(self)
return connection.on_position_update(self)
def on_position_update(self, player):
target_flag = self.get_target_flag(player)
if vector_collision(player.world_object.position, player.team.base):
if target_flag.player is self:
player.capture_flag()
player.check_refill()
if target_flag.player is None and vector_collision(
player.position, target_flag):
player.take_flag()
def on_position_update(self, connection):
for entity in self.protocol.entities:
collides = vector_collision(
entity, connection.world_object.position, TC_CAPTURE_DISTANCE)
if self in entity.players:
if not collides:
entity.remove_player(self)
else:
if collides:
entity.add_player(self)
if collides and vector_collision(entity,
connection.world_object.position):
connection.check_refill()
def on_position_update_recieved(self, contained):
if not self.hp:
return
current_time = reactor.seconds()
last_update = self.last_position_update
self.last_position_update = current_time
if last_update is not None:
dt = current_time - last_update
if dt < MAX_POSITION_RATE:
self.set_location()
return
x, y, z = contained.x, contained.y, contained.z
if check_nan(x, y, z):
self.on_hack_attempt(
'Invalid position data received')
return
if not self.is_valid_position(x, y, z):
# vanilla behaviour
self.set_location()
return
if not self.freeze_animation:
self.world_object.set_position(x, y, z)
self.on_position_update()
if self.filter_visibility_data:
return
game_mode = self.protocol.game_mode
if game_mode == CTF_MODE:
other_flag = self.team.other.flag
if vector_collision(self.world_object.position,
self.team.base):
if other_flag.player is self:
self.capture_flag()
self.check_refill()
if other_flag.player is None and vector_collision(
self.world_object.position, other_flag):
self.take_flag()
elif game_mode == TC_MODE:
for entity in self.protocol.entities:
collides = vector_collision(
entity, self.world_object.position, TC_CAPTURE_DISTANCE)
if self in entity.players:
if not collides:
entity.remove_player(self)
else:
if collides:
entity.add_player(self)
if collides and vector_collision(entity,
self.world_object.position):
self.check_refill()
def on_position_update(self):
if self.protocol.reverse_one_ctf:
if vector_collision(self.world_object.position, self.team.other.base):
other_flag = self.team.other.flag
if other_flag.player is self:
connection.capture_flag(self)
return connection.on_position_update(self)
def on_position_update(self):
if self.protocol.reverse_one_ctf:
if vector_collision(self.world_object.position, self.team.other.base):
other_flag = self.team.other.flag
if other_flag.player is self:
connection.capture_flag(self)
return connection.on_position_update(self)
def on_position_update(self):
flag = self.team.flag
if vector_collision(self.world_object.position, flag):
if not flag.at_start_pos:
flag.set(*flag.start_pos)
flag.update()
flag.at_start_pos = True
self.protocol.send_chat('%s intel was returned to the initial position by %s!' % (self.team.name, self.name))
return connection.on_position_update(self)
def on_position_update(self):
flag = self.team.flag
if flag.player is None and flag.out:
if vector_collision(self.world_object.position, flag):
flag.out = False
flag.set(*flag.start)
flag.update()
self.protocol.send_chat('%s intel was returned by %s!' %
(self.team.name, self.name),
global_message=None)
return connection.on_position_update(self)
def think(self):
obj = self.world_object
pos = obj.position
# find nearby foes
if self.acquire_targets:
for player in self.team.other.get_players():
if vector_collision(pos, player.world_object.position,
32.0):
self.aim_at = player
break
# replicate player functionality
if self.protocol.game_mode == CTF_MODE:
other_flag = self.team.other.flag
if vector_collision(pos, self.team.base):
if other_flag.player is self:
self.capture_flag()
self.check_refill()
if not other_flag.player and vector_collision(pos, other_flag):
self.take_flag()
def wield_spade(self):
for player in self.protocol.players.values():
if player.hp <= 0:
continue
position1 = self.world_object.position
position2 = player.world_object.position
if not vector_collision(position1, position2, MELEE_DISTANCE):
continue
valid_hit = self.world_object.validate_hit(
player.world_object, MELEE, HIT_TOLERANCE)
if not valid_hit:
continue
if player.team is not self.team:
speed = self.world_object.velocity.length()
hit_amount = 20 * speed + 15
type = MELEE_KILL
returned = self.on_hit(hit_amount, player, type, None)
if returned == False:
continue
elif returned is not None:
hit_amount = returned
player.hit(hit_amount, self, type)
return
loc = self.world_object.cast_ray(6) # 6 = MAX_DIG_DISTANCE
if loc:
map = self.protocol.map
x, y, z = loc
if z >= 62:
return
if not map.get_solid(x, y, z):
return
pos = position1
if not collision_3d(pos.x, pos.y, pos.z, x, y, z, 6):
return
value = DESTROY_BLOCK
if self.on_block_destroy(x, y, z, value) == False:
return
if map.destroy_point(x, y, z):
self.on_block_removed(x, y, z)
block_action.x = x
block_action.y = y
block_action.z = z
block_action.value = value
block_action.player_id = self.player_id
self.protocol.send_contained(block_action, save=True)
self.protocol.update_entities()
def on_hit_recieved(self, contained):
if not self.hp:
return
world_object = self.world_object
value = contained.value
is_melee = value == MELEE
if not is_melee and self.weapon_object.is_empty():
return
try:
player = self.protocol.players[contained.player_id]
except KeyError:
return
valid_hit = world_object.validate_hit(player.world_object,
value, HIT_TOLERANCE)
if not valid_hit:
return
position1 = world_object.position
position2 = player.world_object.position
if is_melee:
if not vector_collision(position1, position2,
MELEE_DISTANCE):
return
hit_amount = self.protocol.melee_damage
else:
hit_amount = self.weapon_object.get_damage(
value, position1, position2)
if is_melee:
kill_type = MELEE_KILL
elif contained.value == HEAD:
kill_type = HEADSHOT_KILL
else:
kill_type = WEAPON_KILL
returned = self.on_hit(hit_amount, player, kill_type, None)
if returned == False:
return
elif returned is not None:
hit_amount = returned
player.hit(hit_amount, self, kill_type)
def think(self):
obj = self.world_object
pos = obj.position
found = ()
# find nearby foes
if self.acquire_targets:
for player in self.team.other.get_players():
if vector_collision(pos, player.world_object.position, 108.0):
if not self.aim_at:
if obj.can_see(*player.world_object.position.get()):
self.aim_at = player
else:
if point_distance2(self, player) < point_distance2(self, self.aim_at):
if obj.can_see(*player.world_object.position.get()) and self.aim_at is not player:
self.aim_at = player
if self.aim_at:
self.acquire_targets = False
dist = point_distance2(self, self.aim_at )
if self.target_orientation.z < -0.25:
cont = block_line
cont.player_id = self.player_id
cont.x1 = (pos.x)
cont.y1 = (pos.y)
cont.z1 = (pos.z)
cont.x2 = (pos.x)
cont.y2 = (pos.y)
cont.z2 = (pos.z+2)
self.input.add("secondary_fire")
if random.random() > 0.95 or self.aim_at is None:
if self.team.other.flag.player is not self:
self.acquire_targets = True
if self.aim_at and not obj.can_see(*self.aim_at.world_object.position.get()) and not self.terminator:
self.aim_at = None
# replicate player functionality
if self.protocol.game_mode == CTF_MODE:
other_flag = self.team.other.flag
our_flag = self.team.flag
if self.aim_at is None and our_flag.player and other_flag.player is not self:
self.aim_at = our_flag.player
if self.aim_at is None and other_flag.player is self:
self.aim.set_vector( self.team.base )
self.aim -= pos
distance_to_aim = self.aim.normalize() # don't move this line
self.target_orientation.set_vector(self.aim )
self.input.add("up")
elif other_flag.player is not self:
self.aim.set_vector( other_flag )
self.aim -= pos
distance_to_aim = self.aim.normalize() # don't move this line
self.target_orientation.set_vector(self.aim )
self.input.add("up")
if vector_collision(pos, self.team.base):
if other_flag.player is self:
self.capture_flag()
self.check_refill()
if not other_flag.player and vector_collision(pos, other_flag):
self.take_flag()
if self.hp < 30 and self.hp > 0 and self.terminator:
if self.suicide_call is None:
self.set_tool( GRENADE_TOOL )
self.suicide_call = callLater(.2, self.suicide_grenade,
1.0)
if random.random() >=0.15:
self.input.add("secondary_fire")
if random.random() >=0.92 or self.target_orientation.z < -0.25:
self.input.add("jump")
if random.random() >=0.995:
self.on_block_destroy( pos.x, pos.y, pos.z, DESTROY_BLOCK )
player = self
location = player.world_object.cast_ray( 3 )
if location:
px, py, pz = player.get_location()
x, y, z = location
map = player.protocol.map
if not collision_3d(px, py, pz, x, y, z, 3):
return
self.input.add("primary_fire")
if player.on_block_destroy(x, y, z, DESTROY_BLOCK) == False:
return
if z > 62 or not destroy_block(player.protocol, x, y, z):
return
if map.get_solid(x, y, z):
map.remove_point(x, y, z)
map.check_node(x, y, z, True)
player.on_block_removed(x, y, z)
def on_position_update(self):
if vector_collision(self.world_object.position, self.team.other.base):
self.refill()
return connection.on_position_update(self)
"""
"""
