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)
