def send_seed_corrupt(self, signal):
if not self.frozen:
if self.tweener.is_tweening:
self.tweener.when_done(lambda: self.send_seed_corrupt(signal))
else:
x = randint(-2, 2)
y = randint(-2, 2)
seeds = self.scene.get(tag='seed')
corrupt = [seed for seed in seeds if seed.is_corrupt]
if corrupt:
candidates = []
for seed in corrupt:
for ox, oy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
try:
neighbor = self.get(seed.x + ox, seed.y + oy)
except GridCellError:
continue
else:
if not neighbor.is_corrupt:
candidates.append(neighbor)
if candidates:
seed = choice(candidates)
x = seed.x
y = seed.y
signal(SeedCorruption(x, y))
delay(3, lambda: self.send_seed_corrupt(signal))
else:
delay(0.25, lambda: self.send_seed_corrupt(signal))
def burst(self, duration, color, source=None, target=None):
if target is None:
tleft, ttop = -2, 2
tright, tbottom = 2, -2
elif isinstance(target, ppb.Vector):
tleft, ttop = target
tright, tbottom = target
else:
tleft, ttop = target[0]
tright, tbottom = target[1]
if source is None:
sleft, stop = 0, 0
sright, sbottom = 0, 0
elif isinstance(source, ppb.Vector):
sleft, stop = source
sright, sbottom = source
else:
sleft, stop = source[0]
sright, sbottom = source[1]
step = duration / 100
for i in range(int(100 * duration)):
tx = tleft + random() * (tright - tleft)
ty = tbottom + random() * (ttop - tbottom)
sx = sleft + random() * (sright - sleft)
sy = sbottom + random() * (stop - sbottom)
spos = self.position + V(sx, sy)
tpos = self.position + V(tx, ty)
delay(i * step,
lambda spos=spos, tpos=tpos: ParticleSystem.spawn(
spos, color, tpos))
def on_seed_corruption(self, ev, signal):
if self.x == ev.x and self.y == ev.y:
if not self.is_corrupt:
self.is_corrupt = True
tween(self, 'color', COLOR_NEARBLACK, 1.0, easing='out_quad')
tween(self, 'size', 0.8, 1.0, easing='out_quad')
self.sparkle(1.0, rate=0.1)
delay(1.0, lambda: signal(SeedCorruptionComplete()))
def attack(self, dmg, signal):
tween(self, 'position', self.position - V(1, 0), 0.1, easing='in_quad')
tween(self,
'position',
self.position,
0.1,
delay=0.1,
easing='out_quad')
delay(0.1, lambda: signal(DamageDealt('player', dmg)))
self.plan_attack()
def tick():
nonlocal hp
hp -= d
if target.hp >= d:
target.shield += d
if perf_counter() > end:
if hp > 0:
target.shield += hp
else:
delay(1.0, tick)
def chime(t, signal):
global _chime_playing
if not _chime_playing:
signal(PlaySound(SOUND_CHIME))
SOUND_CHIME.volume = 6.0
tween(SOUND_CHIME, 'volume', 0.0, t, easing='out_quad')
_chime_playing = True
def done():
global _chime_playing
_chime_playing = False
delay(t, done)
def login(self,email,password,addr):
self.driver.get(addr)
email_id =self.driver.find_element_by_id('i0116')
email_id.send_keys(email)
btn= self.driver.find_element_by_id('idSIButton9') # Email Button
btn.click()
passport_id = self.driver.find_element_by_id('i0118')
passport_id.send_keys(password)
timer.delay()
btn_2 = self.driver.find_element_by_id('idSIButton9')
btn_2.click()
btn_3 = self.driver.find_element_by_id('idSIButton9')
btn_3.click()
reservation_btn = self.driver.find_element_by_xpath("//*[@class='btn btn-success save create btnCreate']")
timer.delay()
reservation_btn.click()
def spawn(cls, pos, color, heading=None, tsize=2.5):
s = cls.sparkles[cls.index]
cls.index = (cls.index + 1) % cls.size
if color == COLOR_BLACK:
s.opacity_mode = 'blend'
s.opacity = 255
else:
s.opacity_mode = 'add'
s.opacity = 128
s.color = color
s.position = pos
s.rotation = randint(0, 260)
s.size = 1.5
s.layer = 100
cls.t.tween(s, 'opacity', 0, 0.5, easing='linear')
cls.t.tween(s, 'size', tsize, 0.5, easing='linear')
delay(0.5, lambda: setattr(s, 'size', 0))
if heading:
cls.t.tween(s, 'position', heading, 0.5, easing='linear')
def on_monster_death(self, ev, signal):
t = ENEMIES[self.monster_index].get('deathtime', 2.0)
delay(0.5, lambda: setattr(ev.monster, 'smoke_enabled', False))
delay(
1.0, lambda: tween(ev.monster,
'position',
POS_ENEMY + V(4, 0),
2.0,
easing='out_quad'))
delay(3.0, lambda: setattr(ev.monster, 'smoke_enabled', True))
delay(3.0, lambda: signal(MonsterSpawn(ev.monster)))
def main():
stabilizeSwitch.initialize()
gyroSensor.initialize()
homePositionSwitch.initialize()
motor.initialize()
timer.delay(500);
stabilizeState = stabilizeSwitch.position()
while 1:
while stabilizeSwitch.position() == stabilizeState:
pass
stabilizeState = stabilizeSwitch.position()
goHome()
if stabilizeState == stabilizeSwitch.on:
goToStartStabilizePosition()
stabilize()
def shield(duration, target, hp):
"""Reduce incoming damage by a certain amount over a number of seconds."""
start = perf_counter()
end = start + duration
d = floor(hp / duration)
def tick():
nonlocal hp
hp -= d
if target.hp >= d:
target.shield += d
if perf_counter() > end:
if hp > 0:
target.shield += hp
else:
delay(1.0, tick)
delay(1.0, tick)
def heal(duration, target, hp):
"""Heal the target an amount of HP over a number of seconds."""
start = perf_counter()
end = start + duration
d = floor(hp / duration)
def tick():
nonlocal hp
hp -= d
if target.hp >= d:
target.hp += d
if perf_counter() > end:
if hp > 0:
target.hp += hp
else:
delay(1.0, tick)
delay(1.0, tick)
def _():
enemy = first(self.scene.get(tag='enemy'))
if corruption:
enemy.sparkler.burst(
1,
COLOR_BLACK,
source=(V(-2, -2), V(2, 2)),
target=V(0, 0),
)
delay(1, lambda: signal(EnemyAttack(enemy, corruption)))
if dmg:
# signal(DamageDealt('monster', dmg))
i = choice([c for c in colors if c >= 0])
enemy.sparkler.burst(0.25, SEED_COLORS[i])
if heal:
player = first(self.scene.get(tag='player'))
player.sparkler.burst(
2.0,
COLOR_GREEN,
source=V(0, -1.25),
target=(V(-1, 1.5), V(1, 1)),
)
spells.heal(2.0, player, 4)
if shield:
player = first(self.scene.get(tag='player'))
player.sparkler.burst(
3.0,
COLOR_YELLOW,
source=V(2, 0),
target=(V(2, 2.5), V(2, -2.5)),
)
spells.shield(3.0, player, 6)
def turnCW():
#output PWM
print('turn motor clockwise.')
timer.delay(50)
return 1
def goToStartStabilizePosition():
print('go to stabilize position.')
motor.turnCW()
timer.delay(motor.timeToStartPosition)
def find_matches(self, signal):
if self.frozen:
return
if self.tweener.is_tweening:
self.tweener.when_done(lambda: self.find_matches(signal))
return
seeds = set()
colors = defaultdict(int)
points = 0
# [-2, -1, =0, +1, +2]
# Only need to loop to 0's because we look at at least the next two to make 3-matches
for x in range(-2, 3):
for y in range(-2, 3):
try:
match_seeds, match_points = self.find_one_match(x, y)
except GridCellOutOfBounds:
continue
except GridCellMissing:
# A cell was missing, so something is in motion, stop looking for matches...
return
else:
if match_seeds:
points += match_points
seeds.update(match_seeds)
# END grid loop
signal(ScorePoints(points))
if seeds:
# Add up the matched seeds for each color and animate them accordingly
d = 0.5
# Calculate damage and spell effects
dmg = 0
shield = 0
heal = 0
corruption = 0
for seed in seeds:
attack = False
colors[seed.seed_type] += 1
if seed.seed_type == SEED_GREEN:
dest = POS_PLAYER
heal += 1
elif seed.seed_type == SEED_YELLOW:
dest = POS_PLAYER
shield += 1
elif seed.seed_type == SEED_CORRUPTED:
dest = POS_ENEMY
corruption += 1
else:
dest = POS_ENEMY
dmg += 1
attack = True
t = 0.1 * dist(seed.position, dest)
seed.free()
seed.layer = 10
delay((1.0 - d), lambda seed=seed: seed.sparkle(t))
self.tweener.tween(seed,
'size',
1.1,
0.1,
easing='out_quad',
delay=1.0 - d - 0.1)
self.tweener.tween(seed,
'position',
dest,
t,
easing='out_quad',
delay=1.0 - d)
self.tweener.tween(seed,
'size',
0.0,
t,
easing='in_quad',
delay=1.0 - d)
if attack:
delay(t + (1.0 - d),
lambda: signal(DamageDealt('monster', 1)))
d *= 0.5
signal(MovementStart(colors))
def _():
chime(t + 1.0 - d, signal)
delay(d, _)
def _():
enemy = first(self.scene.get(tag='enemy'))
if corruption:
enemy.sparkler.burst(
1,
COLOR_BLACK,
source=(V(-2, -2), V(2, 2)),
target=V(0, 0),
)
delay(1, lambda: signal(EnemyAttack(enemy, corruption)))
if dmg:
# signal(DamageDealt('monster', dmg))
i = choice([c for c in colors if c >= 0])
enemy.sparkler.burst(0.25, SEED_COLORS[i])
if heal:
player = first(self.scene.get(tag='player'))
player.sparkler.burst(
2.0,
COLOR_GREEN,
source=V(0, -1.25),
target=(V(-1, 1.5), V(1, 1)),
)
spells.heal(2.0, player, 4)
if shield:
player = first(self.scene.get(tag='player'))
player.sparkler.burst(
3.0,
COLOR_YELLOW,
source=V(2, 0),
target=(V(2, 2.5), V(2, -2.5)),
)
spells.shield(3.0, player, 6)
delay(1.0 - d + t, _)
@self.tweener.when_done
def on_tweening_done():
for seed in seeds:
seed.layer = 1
# Drop new seeds at the top of each column with gaps
for x in range(-2, 3):
# Collect all the seeds in a column and drop them
column = []
for y in range(-2, 3):
seed = GRID.get(x, y)
if seed:
column.append(seed)
if len(column) < 5:
gap = 0
for y in range(-2, 3):
if (x, y) not in GRID:
gap += 1
else:
if gap > 0:
seed = GRID[x, y]
del GRID[x, y]
seed.y -= gap
GRID[seed.x, seed.y] = seed
self.tweener.tween(seed,
'position',
ppb.Vector(
seed.x, seed.y),
1 + random() * 0.25,
delay=0.5,
easing='out_bounce')
# Add new seeds at the top
for i in range(gap):
if seeds:
seed = seeds.pop()
seed.drop(self.tweener, x, 2 - i)
self.tweener.when_done(lambda: signal(MovementDone()))
return seeds
def on_scene_started(self, ev, signal):
self.scene = ev.scene
delay(3, lambda: self.send_seed_corrupt(signal))
self.tweener = Tweener()
self.scene.add(self.tweener)
def sparkle(self, seconds, rate=0.01):
self.stop_sparkle()
self.sparkle_timer = repeat(rate, self.spark)
delay(seconds, self.stop_sparkle)
def turnCCW():
#output PWM
print('turning motor counter clockwise.')
timer.delay(50)
return 1
def sparkle(self, seconds, color):
self.start_sparkle(color)
delay(seconds, self.stop_sparkle)
