def __init__(self, protocol, entity, *arg, **kw): Vertex3.__init__(self, *arg, **kw) self.protocol = protocol self.entity = entity self.velocity = Vertex3() self.last_position = Vertex3() self.player_to_ball = Vertex3() self.distance_to_player = WeakKeyDictionary() self.send_position()
def spawn(self, pos: None = None) -> None: self.spawn_call = None if self.team is None: return spectator = self.team.spectator if not spectator: if pos is None: x, y, z = self.get_spawn_location() x += 0.5 y += 0.5 z -= 2.4 else: x, y, z = pos returned = self.on_spawn_location((x, y, z)) if returned is not None: x, y, z = returned if self.world_object is not None: self.world_object.set_position(x, y, z, True) else: position = Vertex3(x, y, z) self.world_object = self.protocol.world.create_object( world.Character, position, None, self._on_fall) self.world_object.dead = False self.tool = WEAPON_TOOL self.refill(True) create_player.x = x create_player.y = y create_player.z = z create_player.weapon = self.weapon create_player.player_id = self.player_id create_player.name = self.name create_player.team = self.team.id if self.filter_visibility_data and not spectator: self.send_contained(create_player) else: self.protocol.send_contained(create_player, save=True) if not spectator: self.on_spawn((x, y, z)) if not self.client_info: self.protocol.send_contained(handshake_init)
def spawn(self, pos=None): if self.paused: # won't catch spawning for the first time self.spawn_call = None self.paused_spawn = partial(self.spawn, pos) return if not self.spy or not self.team or self.team.spectator: return connection.spawn(self, pos) # spy: replicate ServerProtocol spawn but fork create_player packet self.spawn_call = None if pos is None: x, y, z = self.get_spawn_location() x += 0.5 y += 0.5 z -= 2.4 else: x, y, z = pos returned = self.on_spawn_location((x, y, z)) if returned is not None: x, y, z = returned if self.world_object is not None: self.world_object.set_position(x, y, z, True) else: self.world_object = self.protocol.world.create_object( Character, Vertex3(x, y, z), None, self._on_fall) self.world_object.dead = False self.tool = WEAPON_TOOL self.refill(True) fill_create_player(self, self.team) if self.filter_visibility_data: self.send_contained(create_player) else: self.protocol.send_contained(create_player, team=self.team, save=True) create_player.team = self.team.other.id self.protocol.send_contained(create_player, team=self.team.other, save=True) self.on_spawn((x, y, z))
def cluster_bomb(self, grenade): #type of bullet eta = grenade.fuse * (1 - CB_E) pos = grenade.position for i in range(CB_N - 1): X = uniform(-1 * CB_K, CB_K) Y = uniform(-1 * CB_K, CB_K) Z = uniform(-1 * CB_K, CB_K) speed = Vertex3(X, Y, Z) cluster = self.protocol.world.create_object( world.Grenade, 0.0, pos, None, speed, self.grenade_exploded) cluster.name = 'cluster' collision = cluster.get_next_collision(UPDATE_FREQUENCY) if collision: eta, x, y, z = collision cluster.fuse = eta grenade_packet.value = cluster.fuse grenade_packet.player_id = self.player_id grenade_packet.position = pos.get() grenade_packet.velocity = speed.get() self.protocol.send_contained(grenade_packet) self.grenade_exploded(grenade)
def multiple_bombs(self, grenade): #type of bullet eta = grenade.fuse * (1 - CB_E) pos = grenade.position vel = grenade.velocity vel = vel.get() for i in range(MB_N - 1): X = vel[0] * uniform(1, 1 + MB_K) Y = vel[1] * uniform(1, 1 + MB_K) Z = vel[2] * uniform(1, 1 + MB_K) speed = Vertex3(X, Y, Z) multiple = self.protocol.world.create_object( world.Grenade, 0.0, pos, None, speed, self.grenade_exploded) multiple.name = 'multiple' collision = multiple.get_next_collision(UPDATE_FREQUENCY) if collision: eta, x, y, z = collision multiple.fuse = eta * 1.1 grenade_packet.value = multiple.fuse grenade_packet.player_id = self.player_id grenade_packet.position = pos.get() grenade_packet.velocity = speed.get() self.protocol.send_contained(grenade_packet) self.grenade_exploded(grenade)
def _on_fire(self): if self.team is not None and self.world_object is not None: bullets = self.weapon_object.generate_bullet_direction( self.world_object.orientation) params = weapon_trajectory_param[self.weapon_object.id] weapon_range = params['range'] pts = [] for bullet in bullets: dummy_character = world.Character( self.world_object.world, self.world_object.position, bullet) loc = dummy_character.cast_ray(weapon_range * 2.0) if loc: x, y, z = loc if (Vertex3(x, y, z) - self.world_object.position ).length_sqr() > weapon_range * weapon_range: # out of range continue pts.append((x, y, z)) self.protocol.paint_block_by_team_splat( self, pts, self.team, params['drop_size'])
def update(self): if not self.hp: return obj = self.world_object pos = obj.position ori = obj.orientation nav = self.protocol.navigation vel = obj.velocity obj.set_position(*self.get_location()) if self.aim_at: aim_at_pos = None if type(self.aim_at) is not Territory: if self.aim_at.hp: aim_at_pos = self.aim_at.world_object.position else: aim_at_pos = Vertex3() aim_at_pos.set(*self.aim_at.get()) if aim_at_pos is not None: self.aim.set_vector(aim_at_pos) self.aim -= pos distance_to_aim = self.aim.normalize( ) # don't move this line # look at the target if it's within sight if obj.can_see(*aim_at_pos.get()): self.target_orientation.set_vector(self.aim) if distance_to_aim <= MELEE_DISTANCE: self.input.discard('sprint') current_time = seconds() if current_time - self.last_spade >= 0.25: self.input.add('primary_fire') if not self.spade_loop.running: self.last_spade = current_time self.spade_loop.start(0.25) else: self.spade_loop.stop() else: vel.x, vel.y = vel.x * 1.02, vel.y * 1.02 self.spade_loop.stop() # creeper behavior # if distance_to_aim < 16.0 and self.grenade_call is None: # self.grenade_call = callLater(3.0, self.throw_grenade, 0.0) if self.steps and not self.next_step: self.next_step = self.steps.pop() if self.next_step: self.input.add('up') self.input.add('sprint') x, y = self.next_step to_next_step = self.to_next_step to_next_step.set(x - pos.x, y - pos.y, 0.0) # strafe if the target is in front of us dot = ori.dot(to_next_step) if dot > 0.7071 and dot < 0.98: p_dot = ori.perp_dot(to_next_step) self.input.add('left' if p_dot < 0.0 else 'right') else: self.target_orientation.set_vector(to_next_step) to_next_step = self.target_orientation dist_to_next_step = to_next_step.normalize() if dist_to_next_step < 0.065: self.next_step = None # check whether we're failing to go anywhere self.last_pos -= pos self.last_pos.z = 0.0 distance_moved = self.last_pos.length_sqr() self.last_pos.set_vector(pos) if distance_moved < 0.0066: self.input.discard('sprint') self.ticks_stumped += 1 if self.ticks_stumped == TICKS_STUMPED_BEFORE_RETRYING: self.path = None if self.ticks_stumped == TICKS_STUMPED_BEFORE_WIGGLING: self.ticks_wiggling_remaining = 60 if self.ticks_stumped == TICKS_STUMPED_BEFORE_KILL: self.kill() else: self.ticks_stumped = 0 if self.ticks_wiggling_remaining > 0: # alternate strafing left and right, it might get us out self.ticks_wiggling_remaining -= 1 left = sin(self.ticks_wiggling_remaining * 0.1) < 0.0 self.input.discard('right' if left else 'left') self.input.add('left' if left else 'right') # project position and check for obstacles #~ ori_z, ori.z = ori.z, 0.0 #~ ret = player.world_object.cast_ray(PROXIMITY_RAY_LENGTH) #~ ori.z = ori_z #~ if ret: #~ x, y, z = ret x, y, z = int(pos.x + ori.x), int(pos.y + ori.y), pos.z + 2 x_i, y_i = int(pos.x), int(pos.y) diagonal = sgn(x - x_i) and sgn(y - y_i) walled = (nav.is_wall(x, y, z) if not diagonal else nav.is_wall(x, y_i, z) and nav.is_wall(x_i, y, z)) self.ticks_obstructed = self.ticks_obstructed + 1 if walled else 0 if (self.ticks_obstructed >= TICKS_BEFORE_JUMPING and (nav.is_jumpable(x, y, z) if not diagonal else nav.is_jumpable(x, y_i, z) or nav.is_jumpable(x_i, y, z))): self.input.discard('sprint') self.input.add('jump') self.jumpable = x, y, z - 4 # jump correction if self.jumpable is not None and fabs( self.jumpable[2] - pos.z) < 0.41 and sqrt( (self.jumpable[0] - pos.x)**2 + (self.jumpable[1] - pos.y)**2) <= 0.7071: self.world_object.set_position(pos.x, pos.y, self.jumpable[2]) self.jumpable = None # orientate towards target diff = ori - self.target_orientation diff.z = 0.0 diff = diff.length_sqr() if diff > 0.001: p_dot = ori.perp_dot(self.target_orientation) if p_dot > 0.0: ori.rotate(self._turn_vector) else: ori.unrotate(self._turn_vector) new_p_dot = ori.perp_dot(self.target_orientation) if new_p_dot * p_dot < 0.0: ori.set_vector(self.target_orientation) else: ori.set_vector(self.target_orientation) if self.grenade_call: self.input.add('primary_fire') obj.set_orientation(*ori.get()) self.flush_input()
def _set_turn_speed(self, value): self._turn_speed = value self._turn_vector = Vertex3(cos(value), sin(value), 0.0)
def __init__(self, entity_id, protocol, *arg, **kw): Vertex3.__init__(self, *arg, **kw) self.id = entity_id self.protocol = protocol
def dropNuke(x, y, accuracy, connectionTeam, connection=None): mapData = connection.protocol.map z = mapData.get_z(x, y) centerPosition = [x, y, z] block_action = loaders.BlockAction() block_action.value = DESTROY_BLOCK block_action.player_id = 32 radius = radiusConfig.get() upHeight = upHeightConfig.get() downHeight = downHeightConfig.get() for x in range(-1 * radius, radius): block_action.x = centerPosition[0] + x for y in range(-1 * radius, radius): block_action.y = centerPosition[1] + y for z in range(-1 * downHeight, upHeight): block_action.z = centerPosition[2] + z if (block_action.z >= 63): continue if (sqrt((block_action.x - centerPosition[0])**2 + (block_action.y - centerPosition[1])**2) <= radius): if (mapData.get_color(block_action.x, block_action.y, block_action.z) is not None): connection.protocol.broadcast_contained(block_action) mapData.remove_point(block_action.x, block_action.y, block_action.z) def killPlayers(players): for player in players: ploc = player.get_location() if (sqrt((ploc[0] - centerPosition[0])**2 + (ploc[1] - centerPosition[1])**2) <= radius and (centerPosition[2] - upHeight + 4) <= (ploc[2]) <= (centerPosition[2] + downHeight + 2)): #player.kill(kill_type=GRENADE_KILL) killGrenade = connection.protocol.world.create_object( Grenade, 0.0, Vertex3(-5, -5, -5), None, Vertex3(0, 0, 2), None) killGrenade.name = "NoStreak" player.kill(kill_type=GRENADE_KILL, by=connection, grenade=killGrenade) connection.personalSuccessNukeTime = time() if (connectionTeam.id == 0): connection.protocol.team1SuccessNukeTime = time() else: connection.protocol.team2SuccessNukeTime = time() killPlayers(connectionTeam.other.get_players()) #killPlayers((connection.protocol.team_1 if connectionTeam.id==1 else connection.protocol.team_2).get_players()) if (nukeTKConfig.get()): killPlayers(connection.team.get_players()) grenadeAmount = grenadeAmountConfig.get() for i in range(0, grenadeAmount): randomDistance = (maximumRadiusConfig.get() - radius) / (1 + exp(-flatnessConfig.get() * (i - shiftnessConfig.get()))) fuse = (propogationTimeConfig.get()) / (grenadeAmount - radius) * i randomDegrees = random() * 360 grenadeX = centerPosition[0] + (randomDistance * cos(randomDegrees)) grenadeY = centerPosition[1] + (randomDistance * sin(randomDegrees)) grenade = connection.protocol.world.create_object( Grenade, fuse, Vertex3( grenadeX, grenadeY, min( 62, mapData.get_z(grenadeX, grenadeY) + ceil( (random() - 0.25) * 1.5))), None, Vertex3(0, 0, 2), connection.nuke_grenade_exploded) grenade.team = connectionTeam grenade.name = "nadeNoStreak" + ("NukeTeamID" + str(connectionTeam.id)) if (connectionTeam.id == 0): connection.protocol.team1NukeTime = time() else: connection.protocol.team2NukeTime = time()
def nadesplode(self, hit_player): self.protocol.world.create_object(Grenade, 0.0, hit_player.world_object.position, None, Vertex3(), self.nadepl_exploded) grenade_packet.value = 0.1 grenade_packet.player_id = self.player_id grenade_packet.position = (hit_player.world_object.position.x, hit_player.world_object.position.y, hit_player.world_object.position.z) grenade_packet.velocity = (0.0, 0.0, 0.0) self.protocol.send_contained(grenade_packet)