def update(self, planet, dt): if not self.indicator: self.indicator = RangeIndicator(planet.pos, planet.DEFENSE_RANGE + planet.get_radius(), PICO_PINK, line_length=2, line_space=5) planet.scene.game_group.add(self.indicator) planet.selected_graphics.append(self.indicator) self.fire_time += dt threats = planet.get_threats() if self.fire_time > self.FIRE_RATE and threats: t = random.choice(threats) delta = t.pos - planet.pos _, angle = delta.as_polar() angle *= 3.14159 / 180 angle += random.random() * 1.5 - 0.75 self.fire_time = 0 b = bullet.Bullet(planet.pos + helper.from_angle(angle) * planet.get_radius(), t, planet, vel=helper.from_angle(angle) * 20, mods={ 'homing': 1, "damage_base": 10 * planet.planet_weapon_mul, "blast_radius": 10, "color": PICO_WHITE, "life": 5, "missile_speed": 0.5 }) planet.scene.game_group.add(b)
def update(self, planet, dt): # Regenerate planet.health += 0.5 * dt # Fire at threats self.fire_time += dt threats = self.get_threats(planet) if self.fire_time > self.FIRE_RATE and threats: self.fire_time = 0 threat = random.choice(threats) _, angle = (threat.pos - planet.pos).as_polar() angle *= 3.14159 / 180 angle += random.random() * 0.5 - 0.25 b = bullet.Bullet( planet.pos + helper.from_angle(angle) * planet.get_radius(), threat, planet, vel=helper.from_angle(angle) * 20, mods={ 'homing': 1, 'color': PICO_YELLOW, 'damage_base': 3, 'missile_speed': -0.25, 'life': 5 }, ) planet.scene.game_group.add(b)
def _generate_image(self): self._width, self._height = self.radius * 2 + 8, self.radius * 2 + 8 t1 = math.cos(clamp(self.time, 0, 1) * 3.14159) * -0.5 + 0.5 t2 = math.cos(clamp(self.time - 0.65, 0, 1) * 3.14159) * -0.5 + 0.5 self.image = pygame.Surface((self._width, self._height), pygame.SRCALPHA) a1 = 3.14159 / 2 + t2 * 6.2818 a2 = 3.14159 / 2 + t1 * 6.4 #pygame.draw.arc(self.image, PICO_BLUE, (4,4,self._width - 8, self._height - 8), a1, a2, 1) center = V2(self._width / 2, self._height / 2) pts = [] steps = int(a2 * 20) for i in range(steps): theta = i / 20 if theta > a1: pts.append((helper.from_angle(-theta) * self.radius + center - V2(1, 1))) if len(pts) >= 2: pygame.draw.lines(self.image, PICO_BLUE, False, pts, 2) vs = helper.from_angle(-a2) vf = V2(vs.y, -vs.x) pt = vs * self.radius + center p1 = pt + vs * 3 + vf * -3 p2 = pt + -vs * 3 + vf * -3 pygame.draw.lines(self.image, PICO_BLUE, False, [tuple(p1), pt, tuple(p2)], 2) self._recalc_rect()
def _generate_image(self): self.image = pygame.Surface((self.radius * 2, self.radius * 2), pygame.SRCALPHA) num_lines = int(self.radius * 6.2818 / (self.line_space + self.line_length)) for i in range(num_lines): a = i / num_lines * 6.2818 + self.angle pc = V2(self.radius, self.radius) + helper.from_angle(a) * self.radius p1 = pc + helper.from_angle(a + 3.14159 / 2) * self.line_length / 2 p2 = pc - helper.from_angle(a + 3.14159 / 2) * self.line_length / 2 pygame.draw.line(self.image, self.color, p1, p2, 1) self._width = self.radius * 2 self._height = self._width self._recalc_rect()
def __init__(self, scene, pos, resources): super().__init__(scene, pos) self.resources = resources self.total_resources = (self.resources.iron + self.resources.ice + self.resources.gas) self.radius = self.total_resources // 30 + 2 self.offset = (0.5, 0.5) self.selectable = True self.collidable = True self.stationary = True self.collision_radius = self.radius + 4 self.set_health(self.get_max_health()) self._circles = [] for i in range(self.total_resources // 20 + 2): pos = helper.from_angle( random.random() * 6.2818) * (random.random() * (self.radius * 0.75) + 1) size = 1 if pos.length_squared() > (self.radius * 0.75)**2: size = random.random() * 2 + 1 else: size = random.random() * 4 + 2 self._circles.append((pos, size)) self._generate_frames() self.health_bar.pos = self.pos + V2(0, -7)
def state_siege(self, dt): super().state_siege(dt) if self.busters > 0 and isinstance(self.effective_target, planet.Planet): self.buster_time -= dt if self.buster_time <= 0: self.busters -= 1 self.buster_time = 0.5 ang = (self.effective_target.pos - self.pos).as_polar()[1] ang *= 3.14159 / 180 rvel = helper.from_angle(ang + 3.14159 + random.random() - 0.5) b = bullet.Bullet(self.pos, self.effective_target, self, vel=rvel, mods={ 'homing': 0.5, 'color': PICO_PINK, 'missile_speed': -0.65, 'life': 15, 'kill_pop': 1, 'shape': 'circle', 'size': 2, 'trail': PICO_PINK }) self.scene.game_group.add(b) self._generate_buster_display()
def make_attack_speed_particle(self): as_factor = self.get_fire_rate() / self.FIRE_RATE if as_factor > 1: extra = int((as_factor - 1) * 3) + 1 for i in range(3 + extra): ang = self.attack_speed_particle_angle ang += (random.random() - 0.5) * 1.6 pos = self.pos + helper.from_angle(ang) * (4 + random.random() * 3) colors = [ PICO_BLUE, PICO_WHITE, PICO_GREEN, PICO_PINK, PICO_PURPLE ] colors = colors[0:extra] p = Particle([random.choice(colors)], 1, pos, 0.1, -helper.from_angle(ang) * 30) self.scene.add_particle(p)
def convert(pts, angle): out = [] for pt in pts: d, a = pt.as_polar() a *= 3.14159 / 180 out.append((helper.from_angle(a + angle) * d + center)) return out
def kill(self): for ship in self.frozen_ships: self.unfreeze_ship(ship) for replica in self.frozen_replicas: replica.kill() self.countdown.kill() sound.play_explosion() base_angle = random.random() * 6.2818 for x in range(self.image.get_width()): for y in range(self.image.get_height()): color = tuple(self.image.get_at((x,y))) if color[3] >= 128 and color[0:3] != PICO_BLACK: _,a = (V2(x,y) - V2(self.width/2,self.height/2)).as_polar() a *= 3.14159 / 180 ad = abs(helper.get_angle_delta(a, base_angle)) if ad > 3.14159/2: a = base_angle + 3.14159 else: a = base_angle pvel = helper.from_angle(a) * 6 p = particle.Particle([ color[0:3], color[0:3], DARKEN_COLOR[color[0:3]] ], 1, self.pos + V2(x - self.width // 2,y - self.height // 2), 1.25 + random.random() ** 2, pvel ) self.scene.game_group.add(p) return super().kill()
def load_level(self, levelfile): p1 = Planet(self, V2(300, 220) + self.game.game_offset, 7, Resources(70, 20, 10)) p1.change_owner(self.player_civ) p1.hide_warnings = True self.homeworld = p1 self.game_group.add(p1) p2 = Planet(self, V2(400, 120) + self.game.game_offset, 3, Resources(100, 0, 0)) p2.change_owner(self.enemy.civ) p2.flag.kill() p2.visible = False p2.selectable = False p2.population = 0 self.game_group.add(p2) for i in range(6): theta = i * -0.65 pos = helper.from_angle(theta) * ( 50 + random.random() * 80) + self.homeworld.pos a = Asteroid(self, pos, Resources(40, 0, 0)) a.health = 10 self.game_group.add(a) self.objgrid.generate_grid(self.get_objects_initial()) self.player_civ.bonus_supply = 99
def apply(self, ship, planet): if ship.SHIP_BONUS_NAME == "fighter" and ( ship.chosen_target != planet or ship.effective_target != planet): ship.chosen_target = planet ship.effective_target = planet # Decoy sound effect delta = ship.pos - planet.pos dn = helper.try_normalize(delta) dist, ang = delta.as_polar() ang *= 3.14159 / 180 t = 0 p1 = planet.pos steps = 8 for i in range(steps): t += 0.25 if i == steps - 1: p2 = ship.pos else: p2 = p1 + helper.from_angle(ang + ((i % 2) - 0.5)) * dist / steps l = laserparticle.LaserParticle(p1, p2, PICO_BLUE, 0.25 + i / 8) planet.scene.add_particle(l) p1 = V2(p2) return super().apply(ship, planet)
def _generate_image(self): r = self.sat.planet.radius + 8 self._width = r * 2 + 8 self._height = r * 2 + 8 self.image = pygame.Surface((self._width, self._height), pygame.SRCALPHA) center = V2(r + 4, r + 4) pts = 13 for i in range(pts): # angle - quarter circle to angle + quarter circle a = self.sat.angle + math.pi / pts * i - math.pi / 2 p1 = helper.from_angle(a - (math.pi / pts) / 2) * r + center p2 = helper.from_angle(a + (math.pi / pts) / 2) * r + center pygame.draw.circle(self.image, PICO_PINK, (helper.from_angle(a) * r + center), 1.25, 0) pygame.draw.line(self.image, PICO_PINK, p1, p2) self._recalc_rect()
def special_stat_update(self, dt): # Regenerate self.health += self.get_stat("ship_regenerate") * dt self.bonus_attack_speed_time -= dt speed_factor = self.get_max_speed() / self.MAX_SPEED if speed_factor > 1: if self._timers['bonus_speed_particle_time'] > 0.15 / speed_factor: #e = explosion.Explosion(self.pos + helper.random_angle(), [PICO_BLUE, PICO_BLUE, PICO_BLUE, PICO_WHITE, PICO_WHITE, PICO_BLUE], 0.25, 3, line_width=1) colors = [ PICO_WHITE, PICO_BLUE, PICO_GREEN, PICO_PINK, PICO_PURPLE ] n = int((speed_factor - 1) * 3) + 1 colors = colors[0:n] #ang = self.velocity.as_polar()[1] + 3.14159 + (random.random() - 0.5) * 3 ang = (self.velocity.as_polar()[1] * 3.14159 / 180 ) + 3.14159 + (random.random() - 0.5) * 0.45 + math.sin( self.time * 3 * speed_factor) if self.velocity.length_squared() == 0: veln = V2(0, 0) else: veln = helper.try_normalize(self.velocity) p = particle.Particle([random.choice(colors)], 1, self.pos + -veln * self.radius, 0.6, helper.from_angle(ang) * 8) self.scene.add_particle(p) self._timers['bonus_speed_particle_time'] = 0
def update(self, dt): self.time += dt self.colonist.offset = (helper.from_angle(self.time * 3) * 0.05 + V2(0.5, 0.5)) for s in self.game_group.sprites() + self.ui_group.sprites(): s.update(dt) super().update(dt)
def debug_render(screen, scene): surf = pygame.Surface(screen.get_size(), pygame.SRCALPHA) for ship in scene.get_ships(): p2 = ship.pos + helper.from_angle(ship.angle) * 10 pygame.draw.line(surf, (255,0,0,180), ship.pos, p2, 1) p3 = ship.pos + helper.from_angle(ship.debug_rotation_num / 8 * 6.2818) * 10 pygame.draw.line(surf, (0,255,0,180), ship.pos, p3, 1) for planet in scene.get_civ_planets(scene.enemy.civ): text.FONTS['tiny'].render_to(surf, (planet.pos + V2(-15,15)), "%s" % sum(planet.ships.values()), (255,128,255,120)) #text.FONTS['tiny'].render_to(surf, (250, 5), ["feeling safe","in fear"][scene.enemy.fear_attack], (255,128,255,120)) text.FONTS['tiny'].render_to(surf, (250, 15), "%d ups" % len(scene.enemy.civ.upgrades_stocked), (255,128,255,120)) #surf.set_alpha(50) screen.blit(surf, (0,0))
def sphere_get(offset, planet_pos): spherize = 0.25 + pow(planet_pos.length(), 1.75) / 55.0 dist, angle = planet_pos.as_polar() angle *= 3.14159 / 180 angle += wavy_angle p2 = offset + helper.from_angle(angle) * dist * spherize p2.x = clamp(p2.x, 0, ww - 1) p2.y = clamp(p2.y, 0, wh - 1) color = wavy.get_at((int(p2.x), int(p2.y))) return color
def state_siege(self, dt): if self.wants_to_dogfight() and not self.cinematic_no_combat: threats = self.get_threats() if threats: self.set_state(STATE_DOGFIGHT) return if not self.effective_target or self.effective_target.health <= 0 or self.effective_target.owning_civ == self.owning_civ: # If we just killed a planet, stay in waiting. if self.effective_target and isinstance(self.effective_target, planet.planet.Planet): self.set_state(STATE_WAITING) else: print("returning from siege") self.set_state(STATE_RETURNING) return tp = self.effective_target.pos + helper.try_normalize( self.pos - self.effective_target.pos) * self.effective_target.radius delta = tp - self.pos dsq_from_target = delta.length_squared( ) - self.effective_target.radius**2 def in_range(): return dsq_from_target <= self.get_weapon_range()**2 # Time to fire and in range? if self.fire_timer >= 1: if in_range(): self.fire_timer = 0 self.fire(self.effective_target) if random.random() < 0.33: self.combat_dodge_direction = random.randint(-1, 1) dir = V2(0, 0) if not in_range(): dir = helper.try_normalize(delta) self.target_heading = None elif self.fire_timer > 0.95: dir = helper.try_normalize(delta) self.target_heading = dir.as_polar()[1] * 3.14159 / 180 elif dsq_from_target < (self.get_weapon_range() * 0.66)**2: dir = -helper.try_normalize(delta) self.target_heading = None else: _, a = (-delta).as_polar() a *= 3.14159 / 180 a += self.combat_dodge_direction * 3.14159 / 2 dir = helper.from_angle(a) if self.combat_dodge_direction == 0: dir = V2(0, 0) self.target_heading = None self.target_velocity = dir * self.get_cruise_speed()
def make_arc(color, radius, a1, a2, width=1): surf = pygame.Surface((radius * 2, radius * 2), pygame.SRCALPHA) mask = pygame.Surface((radius * 2, radius * 2), pygame.SRCALPHA) pygame.draw.circle(surf, color, (radius, radius), radius, width) max_angle_delta = math.pi / 4 direction = 1 if a2 < a1: direction = -1 angle = a1 poly = [(radius, radius)] poly.append( (helper.from_angle(angle) * (radius + width + 2) + V2(radius, radius))) while angle < a2: #p1 = helper.from_angle(angle) * (radius + width + 1) angle += min(max_angle_delta, a2 - angle) poly.append((helper.from_angle(angle) * (radius + width + 2) + V2(radius, radius))) pygame.draw.polygon(mask, (255, 255, 255), poly, 0) surf.blit(mask, (0, 0), None, pygame.BLEND_RGBA_MULT) return surf
def update(self, planet, dt): self.fire_time += dt threats = planet.get_threats() if self.fire_time > self.FIRE_RATE and threats: self.fire_time = 0 for i in range(planet.population): angle = random.random() * 6.2818 b = bullet.Bullet( planet.pos + helper.from_angle(angle) * planet.get_radius(), random.choice(threats), planet, vel=helper.from_angle(angle) * 20, mods={ 'homing': 1, "damage_base": 3 * planet.planet_weapon_mul, "color": PICO_WHITE, "life": 5 }) planet.scene.game_group.add(b)
def find_new_target(self): def is_valid(t): return isinstance(t, Asteroid) or (t.owning_civ and t.owning_civ != self.planet.owning_civ and t.health > 0) d = helper.from_angle(self.angle) * 5 steps = 0 p = V2(self.pos + helper.from_angle(self.angle) * 6) self.target = None while (p.x > 0 and p.x < self.scene.game.game_resolution.x) and (p.y > 0 and p.y < self.scene.game.game_resolution.y): p += d steps += 1 possible = [o for o in self.scene.get_objects_in_range(p, 25) if not isinstance(o, bullet.Bullet)] nearest, dsq = helper.get_nearest(p, possible) if not nearest: continue if dsq < (nearest.radius) ** 2: if is_valid(nearest): self.target = nearest break elif dsq < (nearest.radius + steps * 2) ** 2 and is_valid(nearest): self.target = nearest
def update(self, dt): self.time += dt self.particle_time += dt if self.particle_time > 0.1: for res in self.resources.data.keys(): amt = self.resources.data[res] if amt > 0: pos = helper.from_angle(self.time * 2) * 6 + self.owner.pos p = particle.Particle([RESOURCE_COLORS[res]], 1, pos, amt / 100, helper.random_angle() * 2) self.owner.scene.game_group.add(p) self.particle_time = 0 return super().update(dt)
def _generate_image(self): d = 10 self._width = (self.planet.radius + d + 6) * 2 self._height = self._width cancel = pygame.image.load( resource_path("assets/cancel.png")).convert_alpha() self.image = pygame.Surface((self._width, self._height), pygame.SRCALPHA) c = V2(self._width // 2, self._height // 2) for i in range(8): theta = i * 3.14159 / 4 p1 = helper.from_angle(theta) * (self.planet.radius + d) p2 = helper.from_angle(theta + 0.05) * (self.planet.radius + d + 5) p3 = helper.from_angle(theta) * (self.planet.radius + d + 4) p4 = helper.from_angle(theta - 0.05) * (self.planet.radius + d + 5) pts = [(p + c) for p in [p1, p2, p3, p4]] pygame.draw.polygon(self.image, PICO_RED, pts, 0) self.image.blit(cancel, (c - V2(4, 4))) self._recalc_rect()
def draw_spiral(image, angle, curviness, squash=1, rotate=0): w, h = image.get_size() cx = w // 2# + random.randint(-1,1) cy = h // 2# + random.randint(-1,1) pos = V2(cx, cy) center = V2(cx, cy) radius = w // 2 - 8 steps = radius for i in range(steps): t = i / steps csize = 2.5 * (1 - t) #csize = 1 rr = int((radius / 8)) rr2 = int((radius / 14)) pm, pa = (pos - center).as_polar() pa *= 3.14159 / 180 tp = helper.from_angle(pa + rotate) * pm + center tp2 = (helper.from_angle(pa + rotate + 0.05) * pm * 0.95) + center brightness = clamp(int(((3 / csize) + 1) * 60 * (1 - t)),0,255) tempimage = pygame.Surface((w,h), pygame.SRCALPHA) #pygame.gfxdraw.filled_circle(tempimage, int(pos.x), int(pos.y), int(csize), (255,255,255,brightness)) if csize > 1: pygame.draw.circle(tempimage, (255,255,255,brightness), ttuple(p), int(csize)) pygame.draw.circle(tempimage, (255,255,255,brightness * 0.8), (tp2 + V2(random.randint(-rr2,rr2), random.randint(-rr2,rr2))), int(csize)) else: tempimage.set_at(ttuple(p), (255,255,255, brightness)) tempimage.set_at((tp2 + V2(random.randint(-rr2,rr2), random.randint(-rr2,rr2))), (255,255,255, brightness)) tempimage.set_at((tp + V2(random.randint(-rr,rr), random.randint(-rr,rr))), (255,255,255, random.randint(10, 120))) if random.random() < 0.25: tempimage.set_at((tp + V2(random.randint(-rr,rr), random.randint(-rr,rr))), (255,255,255, random.randint(50, 255))) image.blit(tempimage, (0,0)) off = helper.from_angle(angle) * 1.75 off = V2(off.x, off.y * squash) pos += off angle += curviness curviness *= 0.93
def state_dogfight(self, dt): def invalid_target(): return (not self.effective_target or not self.effective_target.is_alive() or (self.effective_target.pos - self.pos).length_squared() > self.THREAT_RANGE_DEFENSE**2 or self.effective_target.owning_civ == self.owning_civ) # If our target is dead or w/e, find a new one if invalid_target(): self.find_target() if invalid_target( ): # Still no target? Go back to whatever we were doing. self.set_state(self.post_dogfight_state) return # If we're defending a planet... if self.defending: # And our dogfight target is too far... if (self.effective_target.pos - self.defending.pos ).length_squared() > self.STOP_CHASING_RANGE**2: self.set_state("returning") # Fire if reloaded (and close enough) if self.fire_timer > 1: if (self.effective_target.pos - self.pos).length_squared() < self.get_weapon_range()**2: self.fire_timer = 0 self.fire(self.effective_target) self.target_heading = None # Need to get close to the enemy delta = self.effective_target.pos - self.pos if delta.length_squared() > self.get_weapon_range()**2: # Too far dir = helper.try_normalize(delta) elif delta.length_squared() < (self.get_weapon_range() / 2)**2: # Too close dir = -helper.try_normalize(delta) elif self.fire_timer > 0.65: # If we're close and about to fire dir = helper.try_normalize(delta) self.target_heading = dir.as_polar()[1] * 3.14159 / 180 else: _, a = (-delta).as_polar() a *= 3.14159 / 180 a += self.combat_dodge_direction * 3.14159 / 2 dir = helper.from_angle(a) self.target_velocity = dir * self.get_max_speed()
def update(self, planet, dt): if not self.indicator: self.indicator = RangeIndicator(planet.pos, self.RANGE, PICO_PINK, line_length=2, line_space=5) planet.scene.game_group.add(self.indicator) planet.selected_graphics.append(self.indicator) self.fire_time += dt threats = [ o for o in planet.scene.get_enemy_objects(planet.owning_civ) if (o.pos - planet.pos).length_squared() < self.RANGE**2 and o.health > 0 and not o.stealth ] if self.fire_time > self.FIRE_RATE and threats: self.fire_time = 0 t = random.choice(threats) delta = t.pos - planet.pos _, angle = delta.as_polar() angle *= 3.14159 / 180 angle += random.random() * 1.5 - 0.75 b = bullet.Bullet(planet.pos + helper.from_angle(angle) * planet.get_radius(), t, planet, vel=helper.from_angle(angle) * 20, mods={ 'homing': 1, "damage_base": 10 * planet.planet_weapon_mul, "blast_radius": 10, "color": PICO_WHITE, "life": 5, "missile_speed": 0.5 }) planet.scene.game_group.add(b)
def generate_stranded_ships(self): stranded_ships = ['fighter', 'colonist', 'fighter', 'colonist'] if random.random() > 0.5: stranded_ships.append('bomber') else: stranded_ships.append('interceptor') theta = random.random() * 6.2818 for ship in stranded_ships: p = self.pos + helper.from_angle(theta) * random.randint(18,32) s = SHIPS_BY_NAME[ship](self.scene, p, self.scene.player_civ) if ship == 'colonist': s.set_pop(random.randint(2,5)) self.scene.game_group.add(s) self.freeze(s) theta += random.random() + 0.1
def draw_shape(self, surface, shape, color, offset, angle, expand=False): angle += 3.14159 / 2 center = V2(offset) for pt in shape: center += pt * (1 / len(shape)) final_pts = [] for pt in shape: dist, ang = pt.as_polar() ang *= 3.14159 / 180 ang += angle new_pt = helper.from_angle(ang) * dist * 1.25 + offset if expand: new_pt += helper.try_normalize(new_pt - center) * .75 final_pts.append(new_pt) pygame.draw.polygon(surface, color, [pt for pt in final_pts], 0)
def update(self, dt): self.new_target_timer += dt if self.new_target_timer > 0.35: self.new_target_timer = 0 self.find_new_target() if self.target: delta = (self.target.pos - self.pos).normalize() lp = LaserParticle(self.pos + delta * 6, V2(self.target.pos), PICO_PINK, 0.25) self.scene.add_particle(lp) b = bullet.Bullet(self.target.pos, self.target, self, mods={'damage_base':3 * self.planet.planet_weapon_mul}) self.scene.game_group.add(b) self.pos += delta * -2 if self.target: delta = helper.from_angle(self.angle) off = delta * 0 vel = delta * -15 + helper.random_angle() * 15 p = Particle([PICO_WHITE, PICO_PINK], 1, self.pos + off, 0.25, vel) self.scene.game_group.add(p) return super().update(dt)
def update(self, dt): self.time += dt self.wobble_image = pygame.Surface(self.image.get_size(), pygame.SRCALPHA) self.wobble_image.blit(self.image, (0, 0)) z = 0 rot = helper.from_angle(self.rotation + 3.14159 / 2) for z in range(len(self.band_images)): self.wobble_image.blit(self.band_images[z], (0, 0)) for i in range(2): color, line = self.wobble_lines[z * 2 + i] l2 = [(p + rot * math.sin(i + self.time * (math.sin(z) + 2) / 3) * 1) for i, p in enumerate(line)] pygame.draw.lines(self.wobble_image, color, False, l2, 2) self._draw_mask(self.wobble_image) self.wobble_image.blit(self.shading, (0, 0)) return super().update(dt)
def state_waiting(self, dt): self.waiting_time += dt if not self.effective_target: return # If we have a target, we want to orbit it. delta = self.pos - self.effective_target.pos _, a = delta.as_polar() a *= 3.14159 / 180 # Create a target point which is a step around the circle compared to my angle around the circle. a += 0.2 target_pt = self.effective_target.pos + helper.from_angle(a) * ( ATMO_DISTANCE + self.effective_target.radius) # Adjust our velocity to aim at this target point self.target_velocity = helper.try_normalize( target_pt - self.pos) * self.get_max_speed() * 0.5 if isinstance(self.effective_target, planet.planet.Planet): if self.can_land(self.effective_target): self.set_state(STATE_CRUISING)