def get_action(self, unit, game, debug): # Replace this code with your own self.game = game self.unit = unit self.debug = debug def distance_sqr(a, b): return (a.x - b.x) ** 2 + (a.y - b.y) ** 2 nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, self.game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = min( filter(lambda box: isinstance( box.item, model.Item.Weapon), self.game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) target_pos = nearest_enemy.position action = self.RRT(unit.position, nearest_weapon.position) aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double( nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) jump = target_pos.y > unit.position.y if target_pos.x > unit.position.x and self.game.level.tiles[int(unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: jump = True if target_pos.x < unit.position.x and self.game.level.tiles[int(unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: jump = True debug.draw(model.CustomData.Log(f"{action}")) if action != None: return model.UnitAction( velocity=action[0], jump=action[1], jump_down=action[2], aim=aim, shoot=False, reload=False, swap_weapon=False, plant_mine=False) else: return model.UnitAction( velocity=0, jump=False, jump_down=False, aim=aim, shoot=False, reload=False, swap_weapon=False, plant_mine=False)
def get_action(self, unit, game, debug): # Replace this code with your own def distance_sqr(a, b): return (a.x - b.x)**2 + (a.y - b.y)**2 nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) print(nearest_enemy.position) target_pos = unit.position if unit.weapon is None and nearest_weapon is not None: target_pos = nearest_weapon.position elif nearest_enemy is not None: target_pos = nearest_enemy.position target_pos.x, target_pos.y = self.findtarget(game, 29) debug.draw(model.CustomData.Log("Target pos: {}".format(target_pos))) aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) jump = target_pos.y > unit.position.y and self.checkifjumpvalid( game, unit.position, target_pos) if target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: jump = True elif target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: jump = True if target_pos.x > unit.position.x and game.level.tiles[ int(unit.position.x) + 1][int(unit.position.y - 1)] == model.Tile.EMPTY: jump = True elif target_pos.x < unit.position.x and game.level.tiles[ int(unit.position.x) - 1][int(unit.position.y - 1)] == model.Tile.EMPTY: jump = True #print(unit.position) #self.findnodes(game) #self.findnodes_wall(game) #cspace=np.zeros([40,30],dtype=int) #cspace=self.createcspace(game,cspace,int(unit.position.x),int(unit.position.y)) #for row in cspace: #for val in row: #print(val,end='') #print() return model.UnitAction(velocity=target_pos.x - unit.position.x, jump=jump, jump_down=False, aim=aim, shoot=True, reload=False, swap_weapon=False, plant_mine=False)
def get_action(self, unit, game, debug): nearest_enemy, nearest_weapon, nearest_hpbox, nearest_mine, expected_enemy_pos = self.calc_objects( unit, game) target_pos, velocity = self.calc_move(unit, nearest_weapon, nearest_enemy, nearest_hpbox, nearest_mine) aim, los = self.calc_aim(nearest_enemy, unit, game) shoot = self.calc_shoot(los) jump = self.calc_jump(unit, game, target_pos) plant_mine = self.calc_plant_mine(unit, nearest_enemy, velocity) self.prev_enemy_pos = nearest_enemy.position return model.UnitAction(velocity=velocity, jump=jump, jump_down=not jump, aim=aim, shoot=shoot, reload=False, swap_weapon=self.swap_weapon, plant_mine=plant_mine and not shoot)
def do_nothing(self): self.shoot.can_shoot(self.actions_stack) self.shoot.who("nearest_enemy") return model.UnitAction(velocity=0, jump=False, jump_down=False, aim=self.shoot.aim, shoot=self.shoot.shoot, reload=self.shoot.reload, swap_weapon=self.swap, plant_mine=self.plant)
def down(self): self.shoot.can_shoot(self.actions_stack) self.shoot.who("nearest_enemy") #pop action to execute self.which_unit() ac = self.pop() self.should_push_back(ac) return model.UnitAction(velocity=self.speed * (ac[1].x - self.unit.position.x), jump=False, jump_down=True, aim=self.shoot.aim, shoot=self.shoot.shoot, reload=self.shoot.reload, swap_weapon=self.swap, plant_mine=self.plant)
def get_action(self, unit, game, debug): # Replace this code with your own def distance_sqr(a, b): return (a.x - b.x)**2 + (a.y - b.y)**2 nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) target_pos = unit.position if unit.weapon is None and nearest_weapon is not None: target_pos = nearest_weapon.position elif nearest_enemy is not None: target_pos = nearest_enemy.position debug.draw(model.CustomData.Log("Target pos: {}".format(target_pos))) aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) jump = target_pos.y > unit.position.y print("target_pos.y", target_pos.y) print("unit_pos.y", unit.position.y) print("jump", jump) if target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: jump = True if target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: jump = True jump = True #The unit all need JUMP return model.UnitAction(velocity=target_pos.x - unit.position.x, jump=jump, jump_down=not jump, aim=aim, shoot=True, reload=False, swap_weapon=False, plant_mine=False)
def get_action(self, unit, game, debug): nearest_enemy, nearest_weapon, nearest_hpbox, expected_enemy_pos = self.calc_objects( unit, game) target_pos = self.calc_move(unit, nearest_weapon, nearest_enemy, nearest_hpbox) aim, shoot = self.calc_aim(nearest_enemy, unit, game) jump = self.calc_jump() self.prev_enemy_pos = nearest_enemy.position return model.UnitAction(velocity=(target_pos.x - unit.position.x) * 10, jump=jump, jump_down=not jump, aim=aim, shoot=shoot, reload=False, swap_weapon=False, plant_mine=False)
def get_action(self, unit, game, debug): # Replace this code with your own if len(game.units) > 2: nearest_friend = max( filter(lambda u: u.player_id == unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) else: nearest_friend = None nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_enemy2 = max( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = None if nearest_friend: if nearest_friend.id > unit.id: nearest_weapon = min(filter( lambda box: isinstance(box.item, model.Item.Weapon) and box .item.weapon_type != model.WeaponType.ROCKET_LAUNCHER, game.loot_boxes), key=lambda box: distance_sqr( box.position, unit.position), default=None) else: nearest_weapon = min(filter( lambda box: isinstance(box.item, model.Item.Weapon) and box .item.weapon_type == model.WeaponType.ROCKET_LAUNCHER, game.loot_boxes), key=lambda box: distance_sqr( box.position, unit.position), default=None) if not nearest_weapon: nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) nearest_hp = min( filter(lambda box: isinstance(box.item, model.Item.HealthPack), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) nearest_hp2 = max( filter(lambda box: isinstance(box.item, model.Item.HealthPack), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) target_pos = unit.position if unit.health < 80 and nearest_hp: debug.draw(model.CustomData.Log("target: xp")) target_pos = nearest_hp.position if nearest_enemy: d1 = distance_sqr_u(unit, nearest_hp) d2 = distance_sqr_u(nearest_enemy, nearest_hp) if d2 < d1: target_pos = nearest_hp2.position debug.draw(model.CustomData.Log("target: xp2")) elif unit.weapon is None: debug.draw(model.CustomData.Log("target: initial weapon")) target_pos = nearest_weapon.position elif nearest_weapon and unit.weapon and unit.weapon.typ == model.WeaponType.ROCKET_LAUNCHER: debug.draw(model.CustomData.Log("target: weapon")) target_pos = nearest_weapon.position elif nearest_enemy: debug.draw(model.CustomData.Log("target: enemy")) target_pos = nearest_enemy.position pos = one_step_to(game, unit, target_pos) if pos: target_pos = pos debug.draw(model.CustomData.Log("Target pos: {}".format(target_pos))) debug.draw(model.CustomData.Log("Unit pos: {}".format(unit.position))) jump = target_pos.y > unit.position.y dx = target_pos.x - unit.position.x if dx > 0.5 and game.level.tiles[int(unit.position.x + 1)][int( unit.position.y)] == model.Tile.WALL: jump = True if dx < -0.5 and game.level.tiles[int(unit.position.x - 1)][int( unit.position.y)] == model.Tile.WALL: jump = True if nearest_enemy: dx = (nearest_enemy.position.x - unit.position.x - math.copysign(1, target_pos.x - unit.position.x)) print(dx) if abs(dx) < 1: jump = True if nearest_friend and nearest_friend.id < unit.id: jump = False if nearest_friend and nearest_friend.id > unit.id: dx = (nearest_friend.position.x - unit.position.x - math.copysign(1, target_pos.x - unit.position.x)) dy = (nearest_friend.position.y - unit.position.y) if abs(dx) < 1.5 and abs(dy) < 1.5: jump = True shoot = True if nearest_friend: if nearest_enemy and on_fire_line(unit, nearest_enemy, nearest_friend, game): nearest_enemy = nearest_enemy2 if nearest_enemy and on_fire_line(unit, nearest_enemy, nearest_friend, game): shoot = False else: if on_fire_line(unit, nearest_enemy, unit, game): nearest_enemy = nearest_enemy2 if on_fire_line(unit, nearest_enemy, unit, game): shoot = False aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) direction = 1 for u in game.units: if u.player_id != unit.player_id or True: if u.weapon and u.weapon.typ == model.WeaponType.ROCKET_LAUNCHER: if distance_sqr(u.position, unit.position) < 150: direction = -1 if nearest_friend and nearest_friend.id < unit.id: direction = 1 break velocity = direction * 20 * (target_pos.x - unit.position.x) print('vel', velocity, random.randint(-10, 10) / 10) return model.UnitAction( velocity=direction * 20 * (target_pos.x - unit.position.x) + random.randint(-10, 10) / 10, jump=jump, jump_down=not jump, aim=aim, shoot=shoot, reload=False, swap_weapon=(unit.weapon and (unit.weapon.typ == model.WeaponType.ROCKET_LAUNCHER)), plant_mine=(nearest_friend and unit.health < 20))
def get_action(self, unit, game, debug): # Replace this code with your own def distance_sqr(a, b): return (a.x - b.x) ** 2 + (a.y - b.y) ** 2 def help(approach): if(approach is not None and (unit.health>80 or nearest_health is None))and unit.weapon is not None: #debug.draw(model.CustomData.Log("Nearest bullet velocity: {}".format(nearest_bullet.velocity))) #debug.draw(model.CustomData.Log("Nearest bullet position: {}".format(nearest_bullet.position))) #debug.draw(model.CustomData.Log("Nearest bullet distance: {}".format(distance_sqr(nearest_bullet.position,unit.position)))) if(distance_sqr(approach.position,unit.position)<25): ''' ind=0 yind=0 #target_pos.x=unit.position.x+2*nearest_bullet.position.x//abs(nearest_bullet.position.x) for i in range(nearest_bullet.position.x,50*(nearest_bullet.velocity.x),nearest_bullet.velocity.x//abs(nearest_bullet.velocity.x)): ind=i yind=nearest_bullet.y/nearest_bullet.x() if(game.level.tiles[int(i)][int((nearest_enemy.position.y-unit.position.y)*(i-unit.position.x)/(nearest_enemy.position.x-unit.position.x)+unit.position.y)]==model.Tile.WALL): ''' if(approach.velocity.x>0): left=approach.velocity.y/approach.velocity.x*(unit.position.x-.9-approach.position.x)+approach.position.y if(left-(unit.position.y+1.8)>0): jump=False else: #target_pos.y=32 ''' if(game.level.tiles[int(unit.position.x)][int(unit.position.y-3.8)] == model.Tile.EMPTY): jump=False else: ''' jump=True else: right=approach.velocity.y/approach.velocity.x*(unit.position.x+.9-approach.position.x)+approach.position.y if(right-(unit.position.y+1.8)>0): jump=False else: #target_pos.y=32 ''' if(game.level.tiles[int(unit.position.x )][int(unit.position.y-3.8)] == model.Tile.EMPTY): jump=False else: ''' jump=True if(approach.velocity.y<0): up=((unit.position.y+1.8-approach.position.y)/(approach.velocity.y/approach.velocity.x)+approach.position.x) if(abs(up-(unit.position.x-.9))>abs(up-(unit.position.x+.9))): velocity=-50 else: velocity=50 else: down=((unit.position.y-approach.position.y)/(approach.velocity.y/approach.velocity.x)+approach.position.x) if(abs(down-(unit.position.x-.9))>abs(down-(unit.position.x+.9))): velocity=-50 else: velocity=50 return jump,velocity nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units),key=lambda u: distance_sqr(u.position, unit.position),default=None) nearest_weapon = min(filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes),key=lambda box: distance_sqr(box.position, unit.position),default=None) nearest_health = min( filter(lambda box: isinstance(box.item, model.Item.HealthPack), game.loot_boxes),key=lambda box: distance_sqr(box.position, unit.position),default=None) f = sorted(filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes),key=lambda box: distance_sqr(box.position, nearest_enemy.position),reverse=True) farthest_weapon=nearest_enemy for i in f: if(distance_sqr(unit.position,i.position)<=distance_sqr(i.position,nearest_enemy.position)): farthest_weapon=i break nearest_bullet=min( filter(lambda u: u.player_id != unit.player_id, game.bullets),key=lambda u: distance_sqr(u.position, unit.position),default=None) def approachingbullet(): nearest=sorted(game.bullets,key=lambda u: distance_sqr(u.position, unit.position)) for bull in nearest: vec2=model.Vec2Double(0, 0) vec2.x=unit.position.x-bull.position.x vec2.y=unit.position.y-bull.position.y if vec2.x*bull.velocity.x+vec2.y*bull.velocity.y>0: return bull return None target_pos =model.Vec2Double(0, 0) target_pos.x=unit.position.x target_pos.y=unit.position.y if unit.weapon is None and nearest_weapon is not None: target_pos = nearest_weapon.position #debug.draw(model.CustomData.Log("unit pos: {}".format(unit.position))) #debug.draw(model.CustomData.Log("approaching bullet: {}".format(approachingbullet()))) aim = model.Vec2Double(0, 0) reloadweapon=False shoot=True #jump=False swap=False plant=False trick=1 #print('Walked_right=',unit.walked_right) #print('shoot=',unit.shoot) ''' if(len(game.bullets)!=0): print(game.bullets[0].player_id) ''' if unit.weapon is not None and (nearest_health is None ): if(str(unit.weapon.typ)!='WeaponType.ROCKET_LAUNCHER' ): target_pos=farthest_weapon.position jump=True else: target_pos=nearest_enemy.position #print(unit.size) #gap=1 if nearest_health is not None and unit.weapon is not None and nearest_enemy.position.x-nearest_health.position.x!=0 and unit.health>=90: #print('bhai') target_pos=nearest_health.position trick=(nearest_enemy.position.x-nearest_health.position.x)//abs((nearest_enemy.position.x-nearest_health.position.x)) if(unit.position.y!=target_pos.y): trick*=-1 target_pos.x+=trick if(unit.health<90 and nearest_health is not None and unit.weapon is not None): #velocity=(target_pos.x - unit.position.x) target_pos=nearest_health.position #debug.draw(model.CustomData.Log("Health: {}".format(nearest_health.position))) #print(nearest_weapon.item.weapon_type) if nearest_weapon is not None and unit.weapon is not None and (unit.health>80 or nearest_health is None): if (str(nearest_weapon.item.weapon_type)=='WeaponType.ROCKET_LAUNCHER' and str(unit.weapon.typ)!='WeaponType.ROCKET_LAUNCHER' ): target_pos=nearest_weapon.position swap=True elif(str(nearest_weapon.item.weapon_type)!='WeaponType.PISTOL' and str(unit.weapon.typ)=='WeaponType.PISTOL' ): target_pos=nearest_weapon.position swap=True if(unit.weapon is not None): if str(unit.weapon.typ)=='WeaponType.ROCKET_LAUNCHER' and unit.health==100: target_pos=nearest_enemy.position flag=0 mini=min(int(unit.position.x),int(nearest_enemy.position.x)) maxi=max(int(unit.position.x),int(nearest_enemy.position.x)) for i in range(mini+1,maxi): if(game.level.tiles[int(i)][int((nearest_enemy.position.y-unit.position.y)*(i-unit.position.x)/(nearest_enemy.position.x-unit.position.x)+unit.position.y)]==model.Tile.WALL): #print('wall') flag=1 break if(flag==1): shoot=False reloadweapon=True #l=[i.player_id for i in game.units] #print(l) for i in game.units: if(i.player_id==unit.player_id and (unit.position.x!=i.position.x or unit.position.y!=i.position.y) and nearest_enemy.position.x!=unit.position.x): if(((nearest_enemy.position.y-unit.position.y)*(i.position.x-unit.position.x)/(nearest_enemy.position.x-unit.position.x)+unit.position.y)>=i.position.y and ((nearest_enemy.position.y-unit.position.y)*(i.position.x-unit.position.x)/(nearest_enemy.position.x-unit.position.x)+unit.position.y)<=i.position.y+2): if(distance_sqr(unit.position,i.position)<distance_sqr(unit.position,nearest_enemy.position)): shoot=False debug.draw(model.CustomData.Log("Health{}".format(shoot))) reloadweapon=True elif(i.player_id==unit.player_id and (unit.position.y!=i.position.y) and i.position.x==unit.position.x and nearest_enemy.position.x==unit.position.x): if(distance_sqr(unit.position,i.position)<distance_sqr(unit.position,nearest_enemy.position)): shoot=False debug.draw(model.CustomData.Log("Health{}".format(shoot))) reloadweapon=True #print(target_pos) ''' if nearest_enemy.weapon is not None and unit.weapon is not None: if str(nearest_enemy.weapon.typ)=='WeaponType.ROCKET_LAUNCHER' or str(unit.weapon.typ)=='WeaponType.ROCKET_LAUNCHER': if distance_sqr(nearest_enemy,unit)<5: target_pos=(nearest_enemy.position+unit.position)%25 ''' #print(game.level.tiles) jump = (target_pos.y != unit.position.y) velocity=(target_pos.x - unit.position.x) if target_pos.x > unit.position.x and game.level.tiles[int(unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: jump = True elif target_pos.x < unit.position.x and game.level.tiles[int(unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: jump = True elif(abs(velocity)<5): velocity=(velocity)*5 if(abs(target_pos.x-unit.position.x)<=2 and target_pos.y+1<unit.position.y): jump=False if(velocity>0 ): for i in game.units: if((unit.position.x<i.position.x and unit.position.x+2>i.position.x )and ( abs(unit.position.y-i.position.y)<=3)): if(game.level.tiles[int(i.position.x )][int(i.position.y-3.8)] == model.Tile.EMPTY): debug.draw(model.CustomData.Log("jump")) jump=True else: jump=False else: for i in game.units: if((unit.position.x>i.position.x and unit.position.x-1.5<i.position.x )and abs(unit.position.y-i.position.y)<=3): if(game.level.tiles[int(i.position.x )][int(i.position.y-3.8)] == model.Tile.EMPTY): debug.draw(model.CustomData.Log("jump")) jump=True else: jump=False #print(len(game.units)) approach=approachingbullet() if approach is not None: if(help(approach) is not None): jump,velocity=help(approach) debug.draw(model.CustomData.Log("approach")) elif(nearest_bullet is not None): if(help(nearest_bullet) is not None): jump,velocity=help(nearest_bullet) debug.draw(model.CustomData.Log("NearestBullet")) debug.draw(model.CustomData.Log("Velocity: {}".format(velocity))) #debug.draw(model.CustomData.Log("Target: {}".format(target_pos))) if nearest_enemy is not None: #if(nearest_enemy.walked_right==True): if velocity!=0: aim = model.Vec2Double(nearest_enemy.position.x- unit.position.x,nearest_enemy.position.y - unit.position.y) else: aim = model.Vec2Double(nearest_enemy.position.x- unit.position.x,nearest_enemy.position.y - unit.position.y) return model.UnitAction( velocity=velocity, jump=jump, jump_down=not jump, aim=aim, shoot=shoot, reload=reloadweapon, swap_weapon=swap, plant_mine=plant)
def get_action(self, unit, game, debug): def distance_sqr(a, b): return (a.x - b.x)**2 + (a.y - b.y)**2 # Find the nearest enemy unit nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) # Find the best weapon: the nearest one best_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) # Calculate the position in the next tick if unit.weapon is None and best_weapon is not None: target_pos = best_weapon.position elif nearest_enemy is not None: target_pos = nearest_enemy.position else: target_pos = unit.position ''' if unit.weapon is None and best_weapon is not None: target_pos = best_weapon.position elif nearest_enemy is not None: target_pos = nearest_enemy.position ''' debug.draw(model.CustomData.Log("Target pos: {}".format(target_pos))) # Calculate the aiming direction aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) # Decide whether the unit should jump jump = target_pos.y > unit.position.y if target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: jump = True if target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: jump = True # Decide whether the unit should shoot vector_len = (aim.x**2 + aim.y**2)**0.5 unit_aim = model.Vec2Double(aim.x / vector_len, aim.y / vector_len) start_x = min(unit.position.x, nearest_enemy.position.x) end_x = max(unit.position.x, nearest_enemy.position.x) start_y = min(unit.position.y, nearest_enemy.position.y) end_y = max(unit.position.y, nearest_enemy.position.y) shoot = True cur_x, cur_y = unit.position.x, unit.position.y while start_x <= cur_x <= end_x and start_y <= cur_y <= end_y: if game.level.tiles[int(cur_x)][int(cur_y)] != model.Tile.EMPTY: shoot = False break else: cur_x += unit_aim.x cur_y += unit_aim.y unit_action = model.UnitAction(velocity=target_pos.x - unit.position.x, jump=jump, jump_down=not jump, aim=aim, shoot=shoot, reload=False, swap_weapon=False, plant_mine=False) return unit_action
def get_action(self, unit, game, debug): global max_health if unit.health > max_health: max_health = unit.health mine = False weapon_change = False shoot_e = True target_pos = unit.position # max_health = model.Properties.unit_max_health # Determining nearest entities to pickup def distance_sqr(a, b): return (a.x - b.x)**2 + (a.y - b.y)**2 nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) nearest_mine = min( filter(lambda box: isinstance(box.item, model.Item.Mine), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) nearest_health = min( filter(lambda box: isinstance(box.item, model.Item.HealthPack), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) if unit.weapon is None and nearest_weapon is not None: target_pos = nearest_weapon.position elif nearest_enemy is not None: target_pos = nearest_enemy.position if nearest_health is not None and unit.health <= max_health * 0.7: target_pos = nearest_health.position aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) if unit.weapon is not None and nearest_mine is not None: if distance_sqr(nearest_mine.position, unit.position) < 100: target_pos = nearest_mine.position if unit.weapon is not None and nearest_weapon is not None: if int(nearest_weapon.item.weapon_type) > int(unit.weapon.typ): target_pos = nearest_weapon.position weapon_change = True # Steering vel, jump = self.rrt(unit.position, target_pos, unit, game) # Basic properties if nearest_enemy is not None and unit.weapon is not None: if nearest_enemy.position.x < unit.position.x and model.game.tiles[ int(unit.position.x - 1), int(unit.position.y)] == model.Tile.WALL: shoot_e = False elif nearest_enemy.position.x > unit.position.x and model.game.tiles[ int(unit.position.x + 1), int(unit.position.y)] == model.Tile.WALL: shoot_e = False # Printing entites debug.draw(model.CustomData.Log("Target pos: {}".format(target_pos))) debug.draw( model.CustomData.Log("Current pos: {}".format(unit.position))) debug.draw( model.CustomData.Log("Opponent position: {}".format( nearest_enemy.position))) return model.UnitAction(velocity=vel, jump=jump, jump_down=not jump, aim=aim, shoot=shoot_e, reload=False, swap_weapon=weapon_change, plant_mine=mine)
def get_action(self, unit, game, debug): # Replace this code with your own def distance_sqr(a, b): return (a.x - b.x)**2 + (a.y - b.y)**2 def getNearestWeapon(weapon_name): nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position) if str(box).split('WeaponType.')[1].split(':')[ 0] == weapon_name else len(game.level.tiles[0]) * 2, # если интересующее нас оружие, кладем его координату, иначе кладем координату заведомо проигрышную, ширина поля * default=None) return nearest_weapon def getNearestHealthPack(): nearest_healthPack = min( filter(lambda box: isinstance(box.item, model.Item.HealthPack), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) return nearest_healthPack def getBooleanShoot(): # заменить позицию на упрежденную точку, в которой будет персонаж, когда он будет с выстрелом на заданном расстоянии koords = list() tan = (max(nearest_enemy.position.y, unit.position.y) - min(nearest_enemy.position.y, unit.position.y)) / ( max(nearest_enemy.position.x, unit.position.x) - min(nearest_enemy.position.x, unit.position.x)) debug.draw(model.CustomData.Log("tan: {0}".format(tan))) # for i in range(min(int(unit.position.x), int(nearest_enemy.position.x)), max(int(unit.position.x), int(nearest_enemy.position.x))): # koords.append([i, int(i * tan)]) for i in range( min(int(unit.position.x), int(nearest_enemy.position.x)), max(int(unit.position.x), int(nearest_enemy.position.x))): # Кладем в массив пару: координата x и y koords.append([ i, min(int(nearest_enemy.position.y), int(unit.position.y)) + int(i * tan) ]) result = False if len(koords) == 0: result = True else: try: for koord in koords: if game.level.tiles[koord[0]][ koord[1]] == model.Tile.WALL: result = False break else: result = True except: result = True return result # Текущая целевая точка self.target_pos = unit.position nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = getNearestWeapon(self.best_weapon[self.index % 3]) nearest_healthPack = getNearestHealthPack() self.target_pos = nearest_weapon.position # Если подобрано лучшее оружее, то больше пушки не меняем if (unit.weapon and str(unit.weapon.typ) == 'WeaponType.' + self.best_weapon[self.index % 3]) or self.shoot: self.swap_weapon = False self.target_pos = nearest_weapon.position # Если пушка подобрана, то определяем, стрелять или нет if unit.weapon: if self.target_pos.y > unit.position.y: if self.target_pos.x > unit.position.x and game.level.tiles[ int(unit.position.x + 1)][int( unit.position.y + 1 )] != model.Tile.WALL and game.level.tiles[int( unit.position.x + 1)][int( unit.position.y )] != model.Tile.WALL and game.level.tiles[int( unit.position.x )][int( unit.position.y + 1)] != model.Tile.WALL and game.level.tiles[ int(unit.position.x - 1)][int( unit.position.y)] != model.Tile.WALL: self.shoot = getBooleanShoot() elif self.target_pos.x < unit.position.x and game.level.tiles[ int(unit.position.x - 1)][int( unit.position.y + 1 )] != model.Tile.WALL and game.level.tiles[int( unit.position.x - 1)][int( unit.position.y )] != model.Tile.WALL and game.level.tiles[int( unit.position.x )][int( unit.position.y + 1)] != model.Tile.WALL and game.level.tiles[ int(unit.position.x + 1)][int( unit.position.y)] != model.Tile.WALL: self.shoot = getBooleanShoot() else: if self.target_pos.x > unit.position.x and game.level.tiles[ int(unit.position.x + 1)][int( unit.position.y - 1 )] != model.Tile.WALL and game.level.tiles[int( unit.position.x + 1)][int( unit.position.y )] != model.Tile.WALL and game.level.tiles[int( unit.position.x)][int( unit.position.y )] != model.Tile.WALL and game.level.tiles[int( unit.position.x)][int( unit.position.y - 1 )] != model.Tile.WALL and game.level.tiles[ int(unit.position.x - 1)][int(unit.position.y - 1)] != model.Tile.WALL: self.shoot = getBooleanShoot() elif self.target_pos.x < unit.position.x and game.level.tiles[ int(unit.position.x - 1)][int( unit.position.y - 1 )] != model.Tile.WALL and game.level.tiles[int( unit.position.x - 1)][int( unit.position.y )] != model.Tile.WALL and game.level.tiles[int( unit.position.x)][int( unit.position.y )] != model.Tile.WALL and game.level.tiles[int( unit.position.x)][int( unit.position.y - 1 )] != model.Tile.WALL and game.level.tiles[ int(unit.position.x + 1)][int(unit.position.y - 1)] != model.Tile.WALL: self.shoot = getBooleanShoot() if int( math.sqrt( distance_sqr(unit.position, nearest_enemy.position))) < 1: self.shoot = True debug.draw(model.CustomData.Log("Shoot: {0}".format(self.shoot))) if (self.shoot and unit.health == game.properties.unit_max_health ) or (self.shoot and unit.health < game.properties.unit_max_health and not nearest_healthPack): self.target_pos = unit.position self.jump = False self.jump_down = False else: self.target_pos = nearest_enemy.position else: self.target_pos = nearest_weapon.position # Если уровень здоровья не 100%, бежим к ближайшей аптечке if unit.health < game.properties.unit_max_health and not unit.weapon: try: self.target_pos = nearest_healthPack.position except: self.target_pos = nearest_weapon.position elif unit.health < game.properties.unit_max_health and unit.weapon: try: self.target_pos = nearest_healthPack.position except: self.target_pos = nearest_enemy.position # Если цель выше нас или на одном уровне с нами, то прыгаем # self.jump = self.target_pos.y >= unit.position.y # Так же прыгаем, если тайл мешает пройти if self.target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: self.jump = True self.jump_down = False if self.target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: self.jump = True self.jump_down = False if int(self.target_pos.x) == int(unit.position.x) and int( self.target_pos.y) < int(unit.position.y): self.jump = False self.jump_down = True # Если противник мешает пройти, пытаемся его перепрыгнуть if self.target_pos != nearest_enemy.position and math.fabs( nearest_enemy.position.x - unit.position.x) < 1: self.jump = True self.jump_down = True # if self.boo: # print(unit.health) # self.boo = False # Стараемся держаться на "безопасном расстоянии от врага" if self.target_pos == unit.position and nearest_enemy.position.x < unit.position.x: self.target_pos.x = self.target_pos.x + 5 elif self.target_pos == unit.position and nearest_enemy.position.x > unit.position.x: self.target_pos.x = self.target_pos.x - 5 debug.draw( model.CustomData.Log("Speed: {0}".format( math.fabs(int((self.target_pos.x - unit.position.x))) * game.properties.unit_max_horizontal_speed))) debug.draw( model.CustomData.Log("Target: {0}:{1}".format( int(self.target_pos.x - unit.position.x), int(self.target_pos.y - unit.position.y)))) # Прицеливание бота # if self.boo: # # main() # self.boo = False aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) # # Если цель выше нас или на одном уровне с нами, то прыгаем # self.jump = self.target_pos.y >= unit.position.y # # Так же прыгаем, если тайл мешает пройти # if self.target_pos.x > unit.position.x and game.level.tiles[int(unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: # self.jump = True # if self.target_pos.x < unit.position.x and game.level.tiles[int(unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: # self.jump = True return model.UnitAction( # velocity = (self.target_pos.x - unit.position.x) * game.properties.unit_max_horizontal_speed, velocity=(self.target_pos.x - unit.position.x) * game.properties.unit_max_horizontal_speed, jump=self.jump, jump_down=self.jump_down, aim=aim, shoot=self.shoot, swap_weapon=self.swap_weapon, plant_mine=False)
def get_action(self, unit, game, debug): global max_health global flag global prev_x # Declaration of constants mine = False weapon_change = False shoot_e = True target_pos = unit.position if unit.health > max_health: max_health = unit.health # Determining nearest entities to pickup def distance_sqr(a, b): return (a.x - b.x)**2 + (a.y - b.y)**2 nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) nearest_mine = min( filter(lambda box: isinstance(box.item, model.Item.Mine), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) nearest_health = min( filter(lambda box: isinstance(box.item, model.Item.HealthPack), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) # Deciding target if unit.weapon is None and nearest_weapon is not None: target_pos = nearest_weapon.position elif nearest_enemy is not None: target_pos = nearest_enemy.position if nearest_health is not None and unit.health <= max_health * 0.7: target_pos = nearest_health.position print(int(nearest_weapon.item.weapon_type)) debug.draw(model.CustomData.Log("Target pos: {}".format(target_pos))) debug.draw( model.CustomData.Log("Current pos: {}".format(unit.position))) debug.draw( model.CustomData.Log("Opponent position: {}".format( nearest_enemy.position))) aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) if unit.weapon is not None and nearest_mine is not None: if distance_sqr(nearest_mine.position, unit.position) < 100: target_pos = nearest_mine.position if unit.weapon is not None and nearest_weapon is not None: if int(nearest_weapon.item.weapon_type) > int(unit.weapon.typ): target_pos = nearest_weapon.position weapon_change = True jump = target_pos.y > unit.position.y if target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: if unit.weapon is not None and unit.weapon.last_angle > 0: print(unit.weapon.last_angle) shoot_e = False jump = True if target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: if unit.weapon is not None and unit.weapon.last_angle > 0: shoot_e = False jump = True vel = target_pos.x - unit.position.x # if unit.weapon is not None and unit.weapon.last_angle is not None: # if unit.weapon.last_angle < 0 and game.level.tiles[int(unit.position.x)][int(unit.position.y-1)] == model.Tile.WALL: # if unit.position.x < nearest_enemy.position.x and game.level.tiles[int(unit.position.x-1)][int(unit.position.y-1)] == model.Tile.WALL: # shoot_e = False # elif unit.position.x > nearest_enemy.position.x and game.level.tiles[int(unit.position.x+1)][int(unit.position.y-1)] == model.Tile.WALL: # shoot_e = False isRetracing = False if distance_sqr(unit.position, nearest_enemy.position) < 9: flag = 1 if flag: isRetracing = True vel = vel * (-1) if abs(vel) < 2: vel = vel * 10 if unit.mines is not None and isRetracing: mine = True if flag and distance_sqr(unit.position, nearest_enemy.position) > 64: flag = 0 # print("{} {} {}".format(unit.jump_state.max_time, unit.jump_state.speed, unit.jump_state.max_time * unit.jump_state.speed)) if unit.jump_state.max_time > 0 and unit.jump_state.max_time == 5.5: max_height = unit.jump_state.max_time * unit.jump_state.speed for i in range(int(max_height)): if unit.position.y + i < 28 and game.level.tiles[int( unit.position.x)][int(unit.position.y + i)] == model.Tile.WALL: print("%%%%%%%%%%%%%%%%%%%%%%%%") target_pos.x = random.randint( int(unit.position.x) - 20, int(unit.position.x) + 20) target_pos.y = unit.position.y if target_pos.y > unit.jump_state.max_time * unit.jump_state.speed: print("*****************") jump = True if vel < 0 and game.level.tiles[int(unit.position.x - 1)][int( unit.position.y)] == model.Tile.WALL: target_pos.x = random.randint(int(unit.position.x), int(unit.position.x) + 20) if vel > 0 and game.level.tiles[int(unit.position.x + 1)][int( unit.position.y)] == model.Tile.WALL: target_pos.x = random.randint( int(unit.position.x) - 20, int(unit.position.x)) else: target_pos.x = random.randint( int(unit.position.x) - 20, int(unit.position.x) + 20) target_pos.y = unit.position.y return model.UnitAction(velocity=vel, jump=jump, jump_down=not jump, aim=aim, shoot=shoot_e, reload=False, swap_weapon=weapon_change, plant_mine=mine)
def get_action(self, unit, game, debug): # Replace this code with your own def distance_sqr(a, b, c): return (a.x - b)**2 + (a.y - c)**2 target_pos = unit.position nearest_enemy = min(filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr( u.position, unit.position.x, unit.position.y), default=None) nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position.x, unit. position.y), default=None) jump = target_pos.y > unit.position.y and self.checkifjumpvalid( game, unit.position, target_pos) aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) nearest_weapon.position.x, nearest_weapon.position.y = self.findtarget( game, 29) if (unit.position.y >= nearest_weapon.position.y): target_pos = unit.position jump = False return model.UnitAction(velocity=target_pos.x - unit.position.x, jump=jump, jump_down=False, aim=aim, shoot=True, reload=False, swap_weapon=False, plant_mine=False) """for t in range(2,5): if unit.position.y+t<28: if (game.level.tiles[int (unit.position.x)][int (unit.position.y+t)]==model.Tile.WALL or game.level.tiles[int (unit.position.x+0.1)][int (unit.position.y+t)]==model.Tile.WALL or game.level.tiles[int (unit.position.x-1)][int (unit.position.y+t)]==model.Tile.WALL)and game.level.tiles[int (unit.position.x)][int (unit.position.y-1)]!=model.Tile.EMPTY : nearest_weapon.position.x=unit.position.x-2 nearest_weapon.position.y target_pos=nearest_weapon.position print("strt") return model.UnitAction( velocity=target_pos.x - unit.position.x, jump=jump, jump_down=False, aim=aim, shoot=True, reload=False, swap_weapon=False, plant_mine=False)""" k = 0 #print(unit.position) arrx = [[]] arry = [] arrx = self.findnodes(game, arrx, arry) print(arrx) print("\n\n\n\n\n\n") mini = 1000000 k = 0 flag = 1 for i in arrx: if flag == 1: if (i[1] > unit.position.y or i[1] > unit.position.y + 0.005 ) and i[1] - unit.position.y <= 12: for j in arrx: #if(j[1]>i[1]): #break """print(j[0]," ",j[1]) print(game.level.tiles[int (unit.position.x)][j[1]-1]==model.Tile.WALL or game.level.tiles[int (unit.position.x+0.3)][j[1]-1]==model.Tile.WALL) print("C1=",float (-0.2)<(j[0]-unit.position.x)<float (0.2)) print("C2=",int (j[1])!=int (unit.position.y))""" #if( float (-0.2)<(j[0]-unit.position.x)<float (0.2) and int (j[1])!=int (unit.position.y) and (game.level.tiles[int (unit.position.x)][j[1]-1]==model.Tile.WALL or game.level.tiles[int (unit.position.x+0.3)][j[1]-1]==model.Tile.WALL)): #continue if distance_sqr( unit.position, j[0], j[1] ) < mini and j[1] == i[1] and self.checkifjumpvalid( game, unit.position, target_pos): #print(self.checkifjumpvalid(game,unit.position,target_pos)) mini = distance_sqr(unit.position, j[0], j[1]) nearest_weapon.position.x = j[0] nearest_weapon.position.y = j[1] break target_pos = nearest_weapon.position debug.draw(model.CustomData.Log("Target pos: {}".format(target_pos))) debug.draw(model.CustomData.Log("Unit pos: {}".format(unit.position))) target_pos = nearest_weapon.position mini = 100000 minx = -1 miny = -1 jumptest = 0 for z in range(0, 39): if game.level.tiles[z][int( unit.position.y )] == model.Tile.LADDER and game.level.tiles[z][int( unit.position.y + 2)] != model.Tile.LADDER: print("No ladder") break elif game.level.tiles[z][int( unit.position.y)] == model.Tile.LADDER: print("Ladder") if distance_sqr(unit.position, z, unit.position.y) < mini: mini = distance_sqr(unit.position, z, unit.position.y) minx = z miny = unit.position.y if (mini != 100000): if self.checkwall(game, int(z), int(unit.position.x), int(unit.position.y + 1)) == 0: print("Ladder") nearest_weapon.position.x = (minx + 0.5) if ( minx > unit.position.x) else (minx) nearest_weapon.position.y = miny + 2 target_pos = nearest_weapon.position if (-0.1 < target_pos.x - unit.position.x < 0.1): jumptest = 1 aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) jump = target_pos.y > unit.position.y and self.checkifjumpvalid( game, unit.position, target_pos) if target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: jump = True elif target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: jump = True if target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y - 1)] == model.Tile.EMPTY: jump = True elif target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y - 1)] == model.Tile.EMPTY: jump = True if (jumptest == 1): jump = True return model.UnitAction(velocity=(target_pos.x - unit.position.x), jump=jump, jump_down=False, aim=aim, shoot=True, reload=False, swap_weapon=False, plant_mine=False)
def get_action(self, unit, game, debug): # Replace this code with your own def distance_sqr(a, b): return (a.x - b.x)**2 + (a.y - b.y)**2 nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) nearest_health = min( filter(lambda box: isinstance(box.item, model.Item.HealthPack), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) target_pos = unit.position #Verifica se ja esta com #Alguma arma, se não tiver #Ira em direção a arma #Se ja tiver uma arma, ira em direção #Ao Inimigo procurando_inimigo = False desviar_de_bullet = False if unit.weapon is None and nearest_weapon is not None: target_pos = nearest_weapon.position elif unit.health < 90 and nearest_health is not None: target_pos = nearest_health.position #Se tiver outro pacote mais perto de mim #do que do inimigo, ira atraz dele #Pega o Objeto inimigo for j in game.units: if unit.id != j.id: inimigo = j print("BEGIN FOR") health_mais_perto_de_mim = [] #Itera em todos os pacotes for i in game.loot_boxes: #Se o pacote for de vida if isinstance(i.item, model.Item.HealthPack): #print("loots.item:" , i) #To mais perto que o inimigo #Da vida if distance_sqr(i.position, unit.position) < distance_sqr( i.position, inimigo.position): health_mais_perto_de_mim.append(i) print("TODOS PERTO DE MIM:", health_mais_perto_de_mim) if len(health_mais_perto_de_mim) > 0: target_pos = min(health_mais_perto_de_mim, key=lambda h_m_p_de_m: distance_sqr( h_m_p_de_m.position, unit.position), default=None).position #target_pos = health_mais_perto_de_mim[0].position print("MAIS PERTO DE MIM:", target_pos) #############3#elif unit.weapon is not None and unit.weapon.typ == 2: elif unit.weapon is not None and unit.weapon.typ == 0 or unit.weapon.typ == 1: if nearest_weapon is not None: target_pos = nearest_weapon.position elif len(game.bullets) > 0: #Pega o Objeto inimigo for j in game.units: if unit.id != j.id: inimigo = j lista_bullet_inimigo = list( filter(lambda bull: (bull.unit_id == inimigo.id), game.bullets)) for i in lista_bullet_inimigo: print("INIMIGO BULLET:", i) if len(lista_bullet_inimigo): #nearest_bullet = min( game.bullets, key=lambda bull: distance_sqr(bull.position, unit.position) ) nearest_bullet = min(lista_bullet_inimigo, key=lambda bull: distance_sqr( bull.position, unit.position)) print("ALL BULLETS:", game.bullets) print("MIN BULLETS:", nearest_bullet) target_pos = nearest_bullet.position desviar_de_bullet = True elif nearest_enemy is not None: target_pos = nearest_enemy.position procurando_inimigo = True print("POS:", target_pos) debug.draw(model.CustomData.Log("Txarget pos: {}".format(target_pos))) aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) #print("AIM:", aim) print("unit.position.x:", unit.position.x) print("unit.position.y:", unit.position.y) jump = target_pos.y > unit.position.y #Caso chegue em uma parede, ele pula if target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: jump = True if target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: jump = True #posição do alvo maior que a posição minha atual shooting_command = True if nearest_enemy.position.x > unit.position.x: for i in range(int(unit.position.x), int(nearest_enemy.position.x), 1): if game.level.tiles[i][int( unit.position.y)] == model.Tile.WALL: shooting_command = False print("NOOO SHOOTING MAN") break elif nearest_enemy.position.x < unit.position.x: for i in range(int(nearest_enemy.position.x), int(unit.position.x), 1): if game.level.tiles[i][int( unit.position.y)] == model.Tile.WALL: shooting_command = False print("NO NO NO NO SHOOTING MAN") break #Troca de Arma #Se tiver com uma ROCKET_LAUNCHER troca, por qualquer outra troca_arma = MyStrategy.troca_arma(unit) velocidade_deslocamento = MyStrategy.aumentar_velocidade( target_pos.x - unit.position.x) if desviar_de_bullet == True: velocidade_deslocamento *= -1 jump = not jump jump_down = not jump skill_plat_form = MyStrategy.skill_up_platform(unit, target_pos, game, jump) if skill_plat_form == True: jump = False jump_down = False return model.UnitAction( velocity=velocidade_deslocamento, jump=jump, jump_down=jump_down, aim=aim, shoot=shooting_command, reload=False, swap_weapon=troca_arma, #plant_mine=plat_mine_command) plant_mine=False)
def get_action(self, unit, game, debug): # Replace this code with your own def distance_sqr(a, b): return (a.x - b.x)**2 + (a.y - b.y)**2 nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) nearest_health = min( filter(lambda box: isinstance(box.item, model.Item.HealthPack), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) print( "filter:", filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes)) #print("model.Item::", model.Item) #print("game.loot_boxes::", game.loot_boxes) print("bullet:", game.bullets) target_pos = unit.position #Verifica se ja esta com #Alguma arma, se não tiver #Ira em direção a arma #Se ja tiver uma arma, ira em direção #Ao Inimigo procurando_inimigo = False if unit.weapon is None and nearest_weapon is not None: target_pos = nearest_weapon.position elif unit.health < 90 and nearest_health is not None: target_pos = nearest_health.position elif unit.weapon is not None and unit.weapon.typ == 2: if nearest_weapon is not None: target_pos = nearest_weapon.position elif nearest_enemy is not None: target_pos = nearest_enemy.position procurando_inimigo = True debug.draw(model.CustomData.Log("Txarget pos: {}".format(target_pos))) aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) jump = target_pos.y > unit.position.y if target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: jump = True if target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: jump = True #if procurando_inimigo : # jump = True ''' print("unit" , unit) print("unit.mines" , unit.mines) print("unit.health" , unit.health) print("unit.weapon" , unit.weapon) print("unit.id" , unit.id) print("unit.jump_state" , unit.jump_state) print("unit.on_ground" , unit.on_ground) print("unit.on_ladder" , unit.on_ladder) print("unit.player_id" , unit.player_id) print("unit.position" , unit.position) print("unit.size" , unit.size) print("unit.stand" , unit.stand) print("unit.walked_right" , unit.walked_right) print("nearest_enemy" , nearest_enemy) print("nearest_weapon" , nearest_weapon) print("nearest_health" , nearest_health) print("nearest_health.postion:" , nearest_health.position) print("target_pos.y" , target_pos.y) print("unit_pos.y" , unit.position.y) print("jump" , jump) ''' plat_mine_command = True #Deve ter pelo menos uma mina #E não pode estar na escada if unit.mines > 0 and unit.on_ladder == False: jump = False plat_mine_command = True #Troca de Arma #Se tiver com uma PISTOLA troca, por qualquer outra troca_arma = False if unit.weapon is not None: if unit.weapon.typ == 2 or unit.weapon.typ == 2: troca_arma = True ## if unit.health >= 90: ## velocidade_deslocamento = target_pos.x - unit.position.x ##else : if True: velocidade_deslocamento = target_pos.x - unit.position.x if abs(velocidade_deslocamento) < 4: velocidade_deslocamento *= 3 if abs(velocidade_deslocamento) < 2: velocidade_deslocamento *= 5 print("Velocity:", target_pos.x - unit.position.x) print("velocidade_deslocamento:", velocidade_deslocamento) return model.UnitAction(velocity=velocidade_deslocamento, jump=jump, jump_down=not jump, aim=aim, shoot=True, reload=False, swap_weapon=troca_arma, plant_mine=plat_mine_command)
def get_action(self, unit, game, debug): nearest_enemy, nearest_weapon, nearest_hpbox, nearest_mine, expected_enemy_pos = self.calc_objects( unit, game) target_pos, velocity = self.calc_move(unit, nearest_weapon, nearest_enemy, nearest_hpbox, nearest_mine) aim, los = self.calc_aim(nearest_enemy, unit, game) shoot = self.calc_shoot(los) jump = self.calc_jump(unit, game, target_pos) jump_down = not jump plant_mine, jump, jump_down = self.calc_plant_mine( unit, nearest_enemy, velocity, jump, jump_down, los) # Debug---------------------- # if unit.weapon is not None: # debug.draw(model.CustomData.Log( # "Magazine: {}".format(unit.weapon.magazine))) # debug.draw(model.CustomData.Log( # "Fire timer: {}".format(unit.weapon.fire_timer))) # debug.draw(model.CustomData.Log( # "Last fire tick: {}".format(unit.weapon.last_fire_tick))) # debug.draw(model.CustomData.Log( # "Shoot Counter: {}".format(self.shoot_counter))) # debug.draw(model.CustomData.Log( # "rltv_dist: {}".format(self.rltv_enm_dist))) # debug.draw(model.CustomData.Log( # "rltv_side: {}".format(self.rltv_enm_side))) # # debug.draw(model.CustomData.Log( # "Weapon: {}".format(unit.weapon.typ))) # debug.draw(model.CustomData.Log("mines: {}".format(unit.mines))) # debug.draw(model.CustomData.Log("plant_mine: {}".format(plant_mine))) # debug.draw(model.CustomData.Log( # "Nearest Mine: {}".format(nearest_mine))) # debug.draw(model.CustomData.Log("Max HP: {}".format(self.max_hp))) # debug.draw(model.CustomData.Log("Current HP: {}".format(self.curr_hp))) # debug.draw(model.CustomData.Log("My velocity: {}".format(velocity))) # debug.draw(model.CustomData.Log( # "Enemy velocity: {}".format(self.enemy_velocity))) # debug.draw(model.CustomData.Log("Target pos: {}".format(target_pos))) # debug.draw(model.CustomData.Log("Unit pos: {}".format(unit.position))) # debug.draw(model.CustomData.Log( # "Enemy pos: {}".format(nearest_enemy.position))) # debug.draw(model.CustomData.Log( # "Expected enemy pos: {}".format(expected_enemy_pos))) # debug.draw(model.CustomData.Log( # "Velocity: {}".format(target_pos.x - unit.position.x))) # debug.draw(model.CustomData.Log("Jump: {}".format(jump))) # debug.draw(model.CustomData.Log("Dist X: {}".format( # nearest_enemy.position.x - unit.position.x))) # debug.draw(model.CustomData.Log("Dist Y: {}".format( # nearest_enemy.position.y - unit.position.y))) # debug.draw(model.CustomData.Log("Trajectory length: {}".format(leng))) # debug.draw(model.CustomData.Log( # "poslist: {}".format(poslist))) # /Debug---------------------- self.prev_enemy_pos = nearest_enemy.position return model.UnitAction(velocity=velocity, jump=jump, jump_down=jump_down, aim=aim, shoot=shoot, reload=False, swap_weapon=self.swap_weapon, plant_mine=plant_mine and not shoot)
def get_action(self, unit, game, debug): # Replace this code with your own def distance_sqr(a, b): return (a.x - b.x)**2 + (a.y - b.y)**2 nearest_enemy = min( filter(lambda u: u.player_id != unit.player_id, game.units), key=lambda u: distance_sqr(u.position, unit.position), default=None) nearest_weapon = min( filter(lambda box: isinstance(box.item, model.Item.Weapon), game.loot_boxes), key=lambda box: distance_sqr(box.position, unit.position), default=None) target_pos = unit.position if unit.weapon is None and nearest_weapon is not None: target_pos = nearest_weapon.position elif nearest_enemy is not None: target_pos = nearest_enemy.position debug.draw(model.CustomData.Log("Target pos: {}".format(target_pos))) velo = (target_pos.x - unit.position.x) * uniform(-1, 2) debug.draw(model.CustomData.Log("velo: {:f}".format(velo))) debug.draw( model.CustomData.Log("dx: {:f}".format(self.px - unit.position.x))) debug.draw(model.CustomData.Log(repr(game.properties))) tmp = game.level.tiles debug.draw( model.CustomData.Log( get_debug([ tmp[int(unit.position.x)][int(unit.position.y)], tmp[int(unit.position.x - 1)][int(unit.position.y)], tmp[int(unit.position.x)][int(unit.position.y + 1)], tmp[int(unit.position.x + 1)][int(unit.position.y)], tmp[int(unit.position.x)][int(unit.position.y - 1)] ]))) aim = model.Vec2Double(0, 0) if nearest_enemy is not None: aim = model.Vec2Double(nearest_enemy.position.x - unit.position.x, nearest_enemy.position.y - unit.position.y) jump = target_pos.y > unit.position.y if target_pos.x > unit.position.x and game.level.tiles[int( unit.position.x + 1)][int(unit.position.y)] == model.Tile.WALL: jump = True if target_pos.x < unit.position.x and game.level.tiles[int( unit.position.x - 1)][int(unit.position.y)] == model.Tile.WALL: jump = True if unit.position.x >= (len(game.level.tiles) - 2): self.vv = -1 if unit.position.x <= 2: self.vv = 1 jump = True if game.level.tiles[int(unit.position.x)][int( unit.position.y )] == model.Tile.PLATFORM and self.px - unit.position.x: jump = False self.px = unit.position.x return model.UnitAction( velocity=game.properties.unit_max_horizontal_speed * self.vv, jump=jump, jump_down=not jump, aim=aim, shoot=True, reload=False, swap_weapon=False, plant_mine=False)