def main():
filename = str(input("Filename (csv): "))
if ".csv" not in filename:
sys.exit("Input is not a csv file!")
while True:
try:
timestep = int(
input(
"Note: The time step should be small compared with the orbital"
" period of the bodies.\n"
"Time step (s): "))
break
except ValueError:
print("Please insert an integer.")
while True:
try:
total_frames = int(input("Total frames for the animation: "))
break
except ValueError:
print("Please insert an integer")
animation = Animate(filename, timestep)
Animate.show(animation, total_frames)
def crushed_death_animation(self):
time = pygame.time.get_ticks()
# Animate and keep on screen for half a second before killing sprite
self.animator = Animate(self.crushed_images)
if abs(time - self.last_frame) > 1000:
self.player.score += 100
self.kill()
def __init__(self,
x,
y,
image,
speed,
obstacles,
floor,
item_type,
rise_from=None,
animated=False):
super(Item, self).__init__()
if animated:
self.animator = Animate(image)
self.image = self.animator.get_image()
else:
self.animator = None
self.image = image
self.item_type = item_type
self.rect = self.image.get_rect()
self.rect.left, self.rect.top = x, y
self.speed = speed
self.jump_speed = 0
self.obstacles = obstacles # objects that the item may collide with
self.floor = floor # rects for the floor
self.rise_from = rise_from
def __init__(self, x, y, screen, points=100):
super(Coin, self).__init__()
images = [
'images/Coin-1.png', 'images/Coin-2.png', 'images/Coin-3.png',
'images/Coin-4.png'
]
self.animator = Animate(images)
self.image = self.animator.get_image()
self.rect = self.image.get_rect()
self.rect.left, self.rect.top = x, y
self.screen = screen
self.points = points
def __init__(self, screen, x, y, player, floor, block, goombas, koopas):
self.walk_images = [
'images/GoombaLeftBoot.png', 'images/GoombaRightBoot.png'
]
self.upside_down_images = [
'images/GoombaUD1.png', 'images/GoombaUD2.png'
]
self.crushed_images = ['images/GoombaCrushed.png']
self.animator = Animate(self.walk_images)
image = self.animator.get_image()
super().__init__(screen, image, x, y, player, floor, block, goombas,
koopas)
def upside_down_death_animation(self):
time = pygame.time.get_ticks()
# Animate getting hit (Go up for two seconds)
if self.death_animation_frame == 0:
self.rect.y += (abs(self.ENEMY_DIRECTION) * self.ENEMY_SPEED)
else:
self.rect.y += (abs(self.ENEMY_DIRECTION) * self.ENEMY_SPEED * -1)
# After two seconds fall down while upside down
if self.death_animation_frame == 0 and abs(self.last_frame -
time) > 2000:
self.animator = Animate(self.UD_death_images)
self.death_animation_frame += 1
# Kill off after 10 seconds (Enough to be off screen)
if abs(self.last_frame - time) > 10000:
self.player.score += 100
self.kill()
def cozmo_run(robot, position=None, deliver=None):
global count
if robot.is_ready:
if not robot.has_in_progress_actions:
if robot.is_on_charger:
robot.drive_off_charger_contacts().wait_for_completed()
print("Count: %s" % count)
if position:
reward_run(robot, position=position, deliver=deliver)
count = 0
else:
if count == 90:
anim = Animate()
anim.anim_run(robot)
count = 0
else:
count += 1
def plotPose(pose_list, dl):
"""
Method for plotting a pose given a list of poses (in pca format).
The PCA is trained on the training data, and we use the inverse
transformation to translate the 10 learned factors back to real (normalized)
coordinates.
Keyword Arguments
pose_list - one frame output of the decoder
dl - dataloader object that contains our training data
"""
# pose_list = dl.pca.inverse_transform(pose_list)
# plt.plot(pose_list[0:10:2], pose_list[1:10:2])
# plt.plot([pose_list[2], pose_list[10]], [pose_list[3], pose_list[11]])
# plt.plot(pose_list[10::2], pose_list[11::2])
# plt.show()
pose_list = dl.pca.inverse_transform(pose_list)
animation_object = Animate((-2, 2), (-2, 2))
anim = animation_object.animate(pose_list, 500)
anim.save('animation.html', writer='imagemick', fps=60)
def __init__(self, screen, x, y, player, floor, block, goombas, koopas):
self.name_1, self.name_2 = None, None
self.name_1 = Enemy.img_file('KoopaWalkLeft_1', 25, 40)
self.name_2 = Enemy.img_file('KoopaWalkLeft_2', 25, 40)
self.left_images = [self.name_1, self.name_2]
self.name_1 = Enemy.img_file('KoopaWalkRight_1', 25, 40)
self.name_2 = Enemy.img_file('KoopaWalkRight_2', 25, 40)
self.right_images = [self.name_1, self.name_2]
self.name_1 = Enemy.img_file('KoopaShell', 35, 30)
self.death_images = [self.name_1]
self.name_1 = Enemy.img_file('KoopaShellUD', 35, 30)
self.UD_death_images = [self.name_1]
self.name_1 = Enemy.img_file('KoopaLegs', 35, 30)
self.feet_images = [self.name_1]
self.animator = Animate(self.left_images)
image = self.animator.get_image()
super().__init__(screen, image, x, y, player, floor, block, goombas,
koopas)
self.collision_flag = False
self.feet_frame = 0
self.counter = 0
def __init__(self,
max_speed=1.0,
average_turn=20.0,
turn_std_dev=5.0,
probability_positive_turn=0.5,
x_pos=0.0,
y_pos=0.0,
parent=None):
# super(Searcher, self).__init__(
Animate.__init__(
self,
max_speed,
average_turn,
turn_std_dev,
probability_positive_turn,
x_pos,
y_pos,
parent=parent)
self.giving_up_time = 0
self.time_since_encounter = Searcher.MAX_TIME_SINCE_ENC
self.detection_range = max_speed * Searcher.SPEED_DETECTION_RATIO
class Coin(Sprite):
# sprite for the coin
def __init__(self, x, y, screen, points=100):
super(Coin, self).__init__()
images = [
'images/Coin-1.png', 'images/Coin-2.png', 'images/Coin-3.png',
'images/Coin-4.png'
]
self.animator = Animate(images)
self.image = self.animator.get_image()
self.rect = self.image.get_rect()
self.rect.left, self.rect.top = x, y
self.screen = screen
self.points = points
def update(self):
# updates coin image
self.image = self.animator.get_image()
def blit(self):
# blits the coin to the screen
self.screen.blit(self.image, self.rect)
def set_emotion(self, valence=None, arousal=None, r=None, phi=None, degrees=False, anim_time=0):
self.isEmotion = True
# TODO: Phi in deg or radians? Internally probably radians
e = 0 + 0j
if valence is not None and arousal is not None:
e = valence + arousal*1j
elif r is not None and phi is not None:
if degrees:
phi = phi * math.pi/180.0
e = cmath.rect(r, phi)
else:
raise RuntimeError("Bad combination of parameters. Either valence and arousal or r and phi need to be provided.")
# Make sure emotion is restricted to within unity circle.
if abs(e) > 1.0:
e = cmath.rect(1.0, cmath.phase(e))
if anim_time > 0:
self._anim = Animate([0, anim_time], [self._emotion, e])
else:
self._emotion = e
def __init__(self,
x,
y,
norm_images,
explode_images,
obstacles,
floor,
goomba,
koopa,
speed=5):
self.norm_animator = Animate(norm_images)
self.explode_animator = Animate(explode_images, repeat=False)
self.image = self.norm_animator.get_image()
self.rect = self.image.get_rect()
self.rect.x, self.rect.y = x, y
self.obstacles = obstacles
self.floor = floor
self.goomba, self.koopa = goomba, koopa
self.speed_x = speed
self.speed_y = speed
self.active = True
super(FireBall, self).__init__()
class LuaAnimate(object):
def __init__(self, times, values):
# Workaround to convert lua tables to lists
self._a = Animate(list(times.values()), list(values.values()))
@classmethod
def new(cls, times, values):
return LuaAnimate(times, values)
def __call__(self):
return self._a()
def has_ended(self):
return self._a.has_ended()
def __init__(self,
x,
y,
screen,
map_group,
game_objects,
item=MUSHROOM,
static_img=None):
if not static_img:
images = [
'images/Question-Block-1.png', 'images/Question-Block-2.png',
'images/Question-Block-3.png'
]
self.animator = Animate(images)
initial_image = self.animator.get_image()
else:
initial_image = static_img
self.animator = None
self.game_objects = game_objects
if item in (QuestionBlock.MUSHROOM, QuestionBlock.FIRE_FLOWER,
QuestionBlock.STARMAN, QuestionBlock.ONE_UP):
self.item = item
coins = None
else:
self.item = None
coins = 1
super(QuestionBlock, self).__init__(x,
y,
initial_image,
screen,
map_group,
coins=coins if coins else 0)
if self.item:
self.sound = mixer.Sound('audio/Powerup-Appear.wav')
self.blank_img = image.load(
'images/super-mario-empty-block.png') # force blank image
self.state['blank'] = False
def checkpoint(self, i, pop):
init = self.initial_conditions()
sim = self.simulate(pop[0], init)
basename = self.checkpoint_basename.format(i)
with open(basename + '.csv', 'w') as f:
writer = csv.DictWriter(f, sim[0].keys())
writer.writeheader()
writer.writerows(sim)
with open(basename + '.pickle', 'wb') as f:
pickle.dump(pop, f)
if self.checkpoint_animation:
Animate(sim, init.l, 2 * init.dt * 1000, tight_layout=True).show()
if self.checkpoint_summary:
self.plot(sim)
pygame.init()
settings = Settings()
screen_size = settings.screen_length, settings.screen_height
screen = pygame.display.set_mode(screen_size)
pygame.display.set_caption("Atom Land")
player = Player(screen, settings)
levels = LevelDesign(settings)
basic_enemies = Group()
game_functions.create_basic_enemies(screen, basic_enemies, levels, settings)
buttons = []
fight_enemies = Group()
question_box = []
animate_player = Animate("images/player_walk_down/player_walk", settings)
animate_player.start()
while True:
game_functions.check_pygame_events(player, basic_enemies, fight_enemies,
buttons, question_box, levels, screen,
settings)
game_functions.update_sprites(player, basic_enemies, fight_enemies,
buttons, question_box, screen, levels,
settings)
game_functions.update_screen(player, basic_enemies, fight_enemies, buttons,
question_box, screen, settings)
class Item(Sprite):
MUSHROOM = 'mushroom'
ONE_UP = '1-up'
FIRE_FLOWER = 'fire-flower'
STARMAN = 'starman'
def __init__(self,
x,
y,
image,
speed,
obstacles,
floor,
item_type,
rise_from=None,
animated=False):
super(Item, self).__init__()
if animated:
self.animator = Animate(image)
self.image = self.animator.get_image()
else:
self.animator = None
self.image = image
self.item_type = item_type
self.rect = self.image.get_rect()
self.rect.left, self.rect.top = x, y
self.speed = speed
self.jump_speed = 0
self.obstacles = obstacles # objects that the item may collide with
self.floor = floor # rects for the floor
self.rise_from = rise_from
def rise(self):
if not self.rise_from:
raise ValueError(
'Cannot rise from an object when that object is None')
if self.rect.bottom <= self.rise_from.rect.top:
self.rise_from = None
else:
self.rect.bottom -= 2
def jump(self):
if self.speed >= 0:
self.jump_speed = -(self.speed * 5)
else:
self.jump_speed = (self.speed * 5)
def flip_direction(self):
# make the item go in the opposite direction
self.speed = -self.speed
self.rect.left += self.speed
def bounce_off_obstacles(self):
# checks if the item has hit any obstacles
for obs in self.obstacles:
pts = [
obs.rect.bottomleft, obs.rect.midleft, obs.rect.bottomright,
obs.rect.midright
]
for pt in pts:
if self.rect.collidepoint(pt):
self.flip_direction()
return
for rect in self.floor:
pts = [
rect.midleft, rect.midright, rect.bottomleft, rect.bottomright
]
y_cap = rect.top
for pt in pts:
if self.rect.collidepoint(pt) or \
((self.rect.left == rect.right or self.rect.right == rect.left) and self.rect.top > y_cap):
self.flip_direction()
return
def fall(self):
# makes the item fall through gaps in the ground
falling = True
for rect in self.floor:
# check if bottom is at the top of the floor rect and that the x pos is within floor area
if self.rect.bottom == rect.top and (
rect.left < self.rect.center[0] < rect.right):
self.rect.bottom = rect.top
falling = False
break
if falling:
for obj in self.obstacles:
pts = [obj.rect.topleft, obj.rect.midtop, obj.rect.topright]
for pt in pts:
if self.rect.collidepoint(pt):
falling = False
break
if not falling:
break
if falling:
self.rect.bottom += abs(self.speed)
def update(self):
# updates item position
if self.animator:
self.image = self.animator.get_image()
if not self.rise_from:
if abs(self.jump_speed) > 0:
self.rect.top += self.jump_speed
self.jump_speed += 1 # simulate gravity reducing speed
self.rect.left += self.speed
self.bounce_off_obstacles()
self.fall()
else:
self.rise()
def koopa_physics(self):
self.check_boundary()
if not self.check_floor() and self.start_movement:
self.rect.y += (abs(self.ENEMY_DIRECTION) * self.ENEMY_GRAVITY)
self.rect.x = self.rect.x + (self.ENEMY_DIRECTION *
(self.ENEMY_SPEED - 1))
if self.check_floor() and self.start_movement:
self.rect.x = self.rect.x + (self.ENEMY_DIRECTION *
self.ENEMY_SPEED)
# If collision
if self.check_collisions():
# Gets stomped on -> stop
# Collides with player when in shell -> Movement
if self.enemy_player_collide_flag and self.shell_mode:
time = pygame.time.get_ticks()
# Only put in shell if needed
if self.death_animation_frame == 0:
self.animator = Animate(self.death_images)
self.image = self.animator.get_image()
tempx, tempy = self.rect.x, self.rect.y
self.rect = self.image.get_rect()
self.rect.x = tempx
self.rect.y = tempy
self.death_animation_frame += 1
# Collide with player in shell mode causes movement
if self.check_player_shell_collision():
self.shell_movement = True
# Move shell depending on which side was hit
if self.shell_movement:
if self.death_animation_frame == 1:
# Left side was hit
if self.rect.x >= self.player.rect.x:
self.ENEMY_DIRECTION = abs(self.ENEMY_DIRECTION)
# Right side hit
else:
self.ENEMY_DIRECTION = abs(
self.ENEMY_DIRECTION) * -1
self.death_animation_frame += 1
if self.check_block_collision():
pass
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
# Not being hit by player again makes koopa pop out of shell
if not self.check_player_shell_collision() and abs(self.last_frame - time) > 8000 and not\
self.shell_movement:
if self.counter == 0:
self.animator = Animate(self.feet_images)
self.feet_frame = pygame.time.get_ticks()
self.counter += 1
if abs(self.feet_frame - time) > 3000:
self.counter = 0
self.ENEMY_DIRECTION = abs(self.ENEMY_DIRECTION) * -1
self.animator = Animate(self.left_images)
self.enemy_player_collide_flag = False
self.shell_mode = False
# Collision with map or block
elif self.enemy_block_collide_flag:
# Killed by player hitting block
if self.block_enemy_kill:
self.dead = True
self.upside_down_death_animation()
# If colliding with map (i.e. Pipe) change direction
else:
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
self.enemy_block_collide_flag = False
# If colliding with goomba change direction
elif self.enemy_goomba_collide_flag:
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
self.enemy_goomba_collide_flag = False
elif self.enemy_koopa_collide_flag:
# Colliding with koopa shell thats moving
if self.shell_enemy_kill:
self.dead = True
self.upside_down_death_animation()
# Colliding with koopa enemy or shell
else:
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
self.enemy_koopa_collide_flag = False
class Koopa(Enemy):
def __init__(self, screen, x, y, player, floor, block, goombas, koopas):
self.name_1, self.name_2 = None, None
self.name_1 = Enemy.img_file('KoopaWalkLeft_1', 25, 40)
self.name_2 = Enemy.img_file('KoopaWalkLeft_2', 25, 40)
self.left_images = [self.name_1, self.name_2]
self.name_1 = Enemy.img_file('KoopaWalkRight_1', 25, 40)
self.name_2 = Enemy.img_file('KoopaWalkRight_2', 25, 40)
self.right_images = [self.name_1, self.name_2]
self.name_1 = Enemy.img_file('KoopaShell', 35, 30)
self.death_images = [self.name_1]
self.name_1 = Enemy.img_file('KoopaShellUD', 35, 30)
self.UD_death_images = [self.name_1]
self.name_1 = Enemy.img_file('KoopaLegs', 35, 30)
self.feet_images = [self.name_1]
self.animator = Animate(self.left_images)
image = self.animator.get_image()
super().__init__(screen, image, x, y, player, floor, block, goombas,
koopas)
self.collision_flag = False
self.feet_frame = 0
self.counter = 0
def upside_down_death_animation(self):
time = pygame.time.get_ticks()
# Animate getting hit (Go up for two seconds)
if self.death_animation_frame == 0:
self.rect.y += (abs(self.ENEMY_DIRECTION) * self.ENEMY_SPEED)
else:
self.rect.y += (abs(self.ENEMY_DIRECTION) * self.ENEMY_SPEED * -1)
# After two seconds fall down while upside down
if self.death_animation_frame == 0 and abs(self.last_frame -
time) > 2000:
self.animator = Animate(self.UD_death_images)
self.death_animation_frame += 1
# Kill off after 10 seconds (Enough to be off screen)
if abs(self.last_frame - time) > 10000:
self.player.score += 100
self.kill()
def update(self):
self.koopa_physics()
self.image = self.animator.get_image()
def check_player_shell_collision(self):
# Check player collision when in shell
if self.rect.colliderect(self.player.rect):
return True
def koopa_physics(self):
self.check_boundary()
if not self.check_floor() and self.start_movement:
self.rect.y += (abs(self.ENEMY_DIRECTION) * self.ENEMY_GRAVITY)
self.rect.x = self.rect.x + (self.ENEMY_DIRECTION *
(self.ENEMY_SPEED - 1))
if self.check_floor() and self.start_movement:
self.rect.x = self.rect.x + (self.ENEMY_DIRECTION *
self.ENEMY_SPEED)
# If collision
if self.check_collisions():
# Gets stomped on -> stop
# Collides with player when in shell -> Movement
if self.enemy_player_collide_flag and self.shell_mode:
time = pygame.time.get_ticks()
# Only put in shell if needed
if self.death_animation_frame == 0:
self.animator = Animate(self.death_images)
self.image = self.animator.get_image()
tempx, tempy = self.rect.x, self.rect.y
self.rect = self.image.get_rect()
self.rect.x = tempx
self.rect.y = tempy
self.death_animation_frame += 1
# Collide with player in shell mode causes movement
if self.check_player_shell_collision():
self.shell_movement = True
# Move shell depending on which side was hit
if self.shell_movement:
if self.death_animation_frame == 1:
# Left side was hit
if self.rect.x >= self.player.rect.x:
self.ENEMY_DIRECTION = abs(self.ENEMY_DIRECTION)
# Right side hit
else:
self.ENEMY_DIRECTION = abs(
self.ENEMY_DIRECTION) * -1
self.death_animation_frame += 1
if self.check_block_collision():
pass
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
# Not being hit by player again makes koopa pop out of shell
if not self.check_player_shell_collision() and abs(self.last_frame - time) > 8000 and not\
self.shell_movement:
if self.counter == 0:
self.animator = Animate(self.feet_images)
self.feet_frame = pygame.time.get_ticks()
self.counter += 1
if abs(self.feet_frame - time) > 3000:
self.counter = 0
self.ENEMY_DIRECTION = abs(self.ENEMY_DIRECTION) * -1
self.animator = Animate(self.left_images)
self.enemy_player_collide_flag = False
self.shell_mode = False
# Collision with map or block
elif self.enemy_block_collide_flag:
# Killed by player hitting block
if self.block_enemy_kill:
self.dead = True
self.upside_down_death_animation()
# If colliding with map (i.e. Pipe) change direction
else:
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
self.enemy_block_collide_flag = False
# If colliding with goomba change direction
elif self.enemy_goomba_collide_flag:
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
self.enemy_goomba_collide_flag = False
elif self.enemy_koopa_collide_flag:
# Colliding with koopa shell thats moving
if self.shell_enemy_kill:
self.dead = True
self.upside_down_death_animation()
# Colliding with koopa enemy or shell
else:
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
self.enemy_koopa_collide_flag = False
class QuestionBlock(CoinBlock):
# random item block
MUSHROOM = 'mushroom'
ONE_UP = '1-up'
FIRE_FLOWER = 'fire-flower'
STARMAN = 'starman'
def __init__(self,
x,
y,
screen,
map_group,
game_objects,
item=MUSHROOM,
static_img=None):
if not static_img:
images = [
'images/Question-Block-1.png', 'images/Question-Block-2.png',
'images/Question-Block-3.png'
]
self.animator = Animate(images)
initial_image = self.animator.get_image()
else:
initial_image = static_img
self.animator = None
self.game_objects = game_objects
if item in (QuestionBlock.MUSHROOM, QuestionBlock.FIRE_FLOWER,
QuestionBlock.STARMAN, QuestionBlock.ONE_UP):
self.item = item
coins = None
else:
self.item = None
coins = 1
super(QuestionBlock, self).__init__(x,
y,
initial_image,
screen,
map_group,
coins=coins if coins else 0)
if self.item:
self.sound = mixer.Sound('audio/Powerup-Appear.wav')
self.blank_img = image.load(
'images/super-mario-empty-block.png') # force blank image
self.state['blank'] = False
@classmethod
def q_block_from_tmx_obj(cls, obj, screen, map_group, game_objects):
# creates a question mark box
item_type = obj.properties.get('item', None)
if obj.properties.get('invisible', None):
return cls(obj.x,
obj.y,
screen,
map_group,
game_objects,
item_type,
static_img=obj.image)
return cls(obj.x, obj.y, screen, map_group, game_objects, item_type)
def check_hit(self, other):
points = super(QuestionBlock, self).check_hit(other)
if self.item and self.state['meta'] == CoinBlock.HIT_STATE:
obstacles, floor = self.game_objects[
'collide_objs'], self.game_objects['floors']
if self.item == QuestionBlock.MUSHROOM and not other.state_info[
'big']:
n_item = Mushroom(self.rect.x,
self.rect.y,
obstacles,
floor,
rise_from=self)
elif self.item == QuestionBlock.ONE_UP:
n_item = OneUp(self.rect.x,
self.rect.y,
obstacles,
floor,
rise_from=self)
elif self.item == QuestionBlock.FIRE_FLOWER or self.item == QuestionBlock.MUSHROOM:
n_item = FireFlower(self.rect.x,
self.rect.y,
obstacles,
floor,
rise_from=self)
else:
n_item = StarMan(self.rect.x,
self.rect.y,
obstacles,
floor,
rise_from=self)
self.game_objects['items'].add(n_item)
self.map_group.add(n_item)
self.item = None
self.state['blank'] = True
self.sound.play()
elif points:
return points
def update(self):
# updates the question block
if not self.state['blank'] and self.animator:
self.image = self.animator.get_image()
elif self.state['blank']:
self.image = self.blank_img
super(QuestionBlock, self).update()
if __name__ == '__main__':
#~ blocks = [[0,1,3],[4,2,5],[7,8,6]]
#~ blocks = [[6,0,5],[8,7,4],[3,2,1]]
#~ blocks = [[8,6,7],[2,5,4],[1,3,0]]
blocks = [[2,3,4,8],[1,6,0,12],[5,10,7,11],[9,13,14,15]]
#~ blocks = [[5,1,8],[2,7,3],[4,0,6]]
#~ blocks = [[1,2,3,4],[6,10,7,8],[5,0,11,12],[9,13,14,15]]
initial = Board(blocks)
# this list save all the solution's boards
lst = []
if initial.isSolvable():
solver = Solver(initial)
for board in solver.solution():
lst.append(board)
# here is where the magic ocurrs
win = GraphWin("Npuzzle", 800, 800)
win.setBackground('#FFFFFF')
A = Animate(initial)
for pic in A.getLst():
pic.exhibit(win)
for i in range(1, len(lst)):
A.animation(lst[i])
win.getMouse() # pause for click in window
win.close()
# here is where the magic ocurrs
else:
print "Unsolvable"
from weather import Weather
from ranking import Ranking
from tictactoe import TicTacToe
from replit import db
import re
#############
# Ryan Tan, Timothy Wu
# For our own discord server.
# Requires repl to run this program, particular the database
#
################
#Load in the client from the discord api
client = discord.Client()
animate = Animate()
ranking = Ranking()
tictoe = TicTacToe()
emote = "⣿⣯⣿⣟⣟⡼⣿⡼⡿⣷⣿⣿⣿⠽⡟⢋⣿⣿⠘⣼⣷⡟⠻⡿⣷⡼⣝⡿⡾⣿\n⣿⣿⣿⣿⢁⣵⡇⡟⠀⣿⣿⣿⠇⠀⡇⣴⣿⣿⣧⣿⣿⡇⠀⢣⣿⣷⣀⡏⢻⣿\n⣿⣿⠿⣿⣿⣿⠷⠁⠀⠛⠛⠋⠀⠂⠹⠿⠿⠿⠿⠿⠉⠁⠀⠘⠛⠛⠛⠃⢸⣯\n⣿⡇⠀⣄⣀⣀⣈⣁⠈⠉⠃⠀⠀⠀⠀⠀⠀⠀⠀⠠⠎⠈⠀⣀⣁⣀⣀⡠⠈⠉\n⣿⣯⣽⡿⢟⡿⠿⠛⠛⠿⣶⣄⠀⠀⠀⠀⠀⠀⠈⢠⣴⣾⠛⠛⠿⠻⠛⠿⣷⣶\n⣿⣿⣿⠀⠀⠀⣿⡿⣶⣿⣫⠉⠀⠀⠀⠀⠀⠀⠀⠈⠰⣿⠿⠾⣿⡇⠀⠀⢺⣿\n⣿⣿⠻⡀⠀⠀⠙⠏⠒⡻⠃⠀⠀⠀⠀⣀⠀⠀⠀⠀⠀⠐⡓⢚⠟⠁⠀⠀⡾⢫\n⣿⣿⠀⠀⡀⠀⠀⡈⣉⡀⡠⣐⣅⣽⣺⣿⣯⡡⣴⣴⣔⣠⣀⣀⡀⢀⡀⡀⠀⣸\n⣿⣿⣷⣿⣟⣿⡿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢻⢾⣷⣿\n⣿⣿⣟⠫⡾⠟⠫⢾⠯⡻⢟⡽⢶⢿⣿⣿⡛⠕⠎⠻⠝⠪⢖⠝⠟⢫⠾⠜⢿⣿\n⣿⣿⣿⠉⠀⠀⠀⠀⠈⠀⠀⠀⠀⣰⣋⣀⣈⣢⠀⠀⠀⠀⠀⠀⠀⠀⠀⣐⢸⣿\n⣿⣿⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⣿⣿⣿⣿⣧⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⣿\n⣿⣿⣿⣿⣦⡔⠀⠀⠀⠀⠀⠀⢻⣿⡿⣿⣿⢽⣿⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿\n⣿⣿⣿⣿⣿⣿⣶⣤⣀⠀⠀⠀⠘⠛⢅⣙⣙⠿⠉⠀⠀⠀⢀⣠⣴⣿⣿⣿⣿⣿\n⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⣄⣅⠀⠓⠀⠀⣀⣠⣴⣺⣿⣿⣿⣿⣿⣿⣿⣿\n"
riebot_help_msg = "`animate <gif_number>(optional)` - Send out a random(or selected) gif from the collection.\n`animate delete <gif_number>` - Deletes a selected gif from the collection. \n`animate insert <tenor gif url>` - Inserts a gif into the collection.\n`test` - testing\n`weather <zip-code>` - Reports the weather from the zipcode.\n`whotao` - Whotao?"
#This is the response that the bot should have when it is ready/loaded.
@client.event
async def on_ready():
await client.change_presence(activity=discord.Activity(type=discord.ActivityType.listening, name="the Sounds of Rie"))
print("We have logged in as {0.user}".format(client))
@client.event
#Check on the message and see how to process it.
def __init__(self, times, values):
# Workaround to convert lua tables to lists
self._a = Animate(list(times.values()), list(values.values()))
class Goomba(Enemy):
def __init__(self, screen, x, y, player, floor, block, goombas, koopas):
self.walk_images = [
'images/GoombaLeftBoot.png', 'images/GoombaRightBoot.png'
]
self.upside_down_images = [
'images/GoombaUD1.png', 'images/GoombaUD2.png'
]
self.crushed_images = ['images/GoombaCrushed.png']
self.animator = Animate(self.walk_images)
image = self.animator.get_image()
super().__init__(screen, image, x, y, player, floor, block, goombas,
koopas)
def crushed_death_animation(self):
time = pygame.time.get_ticks()
# Animate and keep on screen for half a second before killing sprite
self.animator = Animate(self.crushed_images)
if abs(time - self.last_frame) > 1000:
self.player.score += 100
self.kill()
def upside_down_death_animation(self):
time = pygame.time.get_ticks()
# Animate getting hit (Go up for two seconds)
if self.death_animation_frame == 0:
self.rect.y += (abs(self.ENEMY_DIRECTION) * self.ENEMY_SPEED)
else:
self.rect.y += (abs(self.ENEMY_DIRECTION) * self.ENEMY_SPEED * -1)
# After two seconds fall down while upside down
if self.death_animation_frame == 0 and abs(self.last_frame -
time) > 2000:
self.animator = Animate(self.upside_down_images)
self.death_animation_frame += 1
# Kill off after 10 seconds (Enough to be off screen)
if abs(self.last_frame - time) > 10000:
self.player.score += 100
self.kill()
def update(self):
if not self.dead:
self.goomba_physics()
else:
if self.player_enemy_kill is True:
self.crushed_death_animation()
elif self.block_enemy_kill is True:
self.upside_down_death_animation()
elif self.shell_enemy_kill is True:
self.upside_down_death_animation()
self.image = self.animator.get_image()
def goomba_physics(self):
self.check_boundary()
# If no blocks are touching enemy -> Fall Down
if not self.check_floor() and self.start_movement:
self.rect.y += (abs(self.ENEMY_DIRECTION) * self.ENEMY_GRAVITY)
self.rect.x = self.rect.x + (self.ENEMY_DIRECTION *
(self.ENEMY_SPEED - 1))
if self.check_floor() and self.start_movement:
self.rect.x = self.rect.x + (self.ENEMY_DIRECTION *
self.ENEMY_SPEED)
# print('Player ' + str(self.check_player_collision()))
# print('Block ' + str(self.check_block_collision()))
# print('Enemy' + str(self.check_friendly_collision()))
if self.check_collisions():
# Collides with player
if self.enemy_player_collide_flag:
# Enemy dead
if self.player_enemy_kill:
self.dead = True
self.last_frame = pygame.time.get_ticks()
self.crushed_death_animation()
else:
self.enemy_player_collide_flag = False
# Collision with map or block
elif self.enemy_block_collide_flag:
# Killed by player hitting block
if self.block_enemy_kill:
self.dead = True
self.upside_down_death_animation()
# If colliding with map (i.e. Pipe) change direction
else:
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
self.enemy_block_collide_flag = False
# If colliding with goomba change direction
elif self.enemy_goomba_collide_flag:
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
self.enemy_goomba_collide_flag = False
# If colliding with koopa
elif self.enemy_koopa_collide_flag:
# Colliding with koopa shell thats moving
if self.shell_enemy_kill:
self.dead = True
self.upside_down_death_animation()
# Colliding with koopa enemy or shell
else:
self.rect.x += (self.ENEMY_DIRECTION * self.ENEMY_SPEED)
self.enemy_koopa_collide_flag = False
def main():
"""Test the simulation with Mars and its moons."""
anim = Animate('marsandmoons.csv', 86)
anim.show(300)
def handleCommand(cmd, scr=True):
global anim
global curWorld
global proofMode
#strip any comments
i = cmd.find("//")
if i >= 0:
cmd = cmd[:i].strip()
if anim:
if scr and cmd:
print "a>" + cmd
result = anim.dispatch(cmd)
if result.startswith("_exit"):
print " " + result[5:]
anim = None
elif result:
print " " + result
return 0
if proofMode:
if scr and cmd:
print proofMode.prompt + ">" + cmd
result = proofMode.dispatch(cmd)
if result.startswith("_exit"):
print " " + result[5:]
proofMode = None
elif result:
print result
return 0
if cmd == "exit":
return -1
elif cmd == "animate":
anim = Animate(curWorld)
elif cmd == "proof":
proofMode = curWorld.ProofMode(curWorld)
elif cmd.startswith("load"):
words = parseCommand(cmd)
for f in words[1:]:
loadFile(f)
elif cmd.startswith("print"):
words = parseCommand(cmd)
if len(words) == 1:
print pPrint(curWorld.top)
else:
fName = words[1]
if "." not in fName:
fName = fName + ".n.out"
f = open(fName, "w")
f.write(pPrint(curWorld.top))
f.close()
print "Success writing to: " + fName
elif cmd.startswith("latex"):
words = parseCommand(cmd)
if len(words) == 1:
print lPrint(curWorld.top)
else:
fName = words[1]
if "." not in fName:
fName = fName + ".tex"
f = open(fName, "w")
f.write(lPrint(curWorld.top))
f.close()
print "Success writing to: " + fName
elif cmd.startswith("sh "):
try:
subprocess.call(cmd[3:], shell=True)
except Exception as e:
print "Error trying to execute '" + cmd[3:] + "': " + str(e)
else:
print "Executed " + cmd[3:]
elif cmd == "**":
curWorld.err = False
elif cmd.startswith("*"):
if curWorld.err:
return handleCommand(cmd[1:])
elif cmd == "help":
print "N v0.09"
print
print "Supported commands:"
print " help print this message"
print " exit exit n"
print " load filenames load the specified files"
print " latex [filename] output the current formal system as latex"
print " print [filename] output the current formal system in the source format"
print " proof switch to proof mode"
print " animate switch to animation mode"
print
print " * cmd execute cmd if an error has occured"
print " ** reset the error flag"
print
elif cmd == "":
pass
else:
print "Unknown command: ", cmd
return 1
return 0
class _Expression(object):
def __init__(self):
self._emotion = 0 + 0j
self._anim = None
self.servos = []
self.dofs = {}
self.dof_values = {}
self.lock = threading.Lock()
self.empty_config()
self.load_config()
self.isEmotion = False
def get_emotion_complex(self):
"""
Returns current emotion as a complex number
"""
return self._emotion
def set_emotion(self, valence=None, arousal=None, r=None, phi=None, degrees=False, anim_time=0):
self.isEmotion = True
# TODO: Phi in deg or radians? Internally probably radians
e = 0 + 0j
if valence is not None and arousal is not None:
e = valence + arousal*1j
elif r is not None and phi is not None:
if degrees:
phi = phi * math.pi/180.0
e = cmath.rect(r, phi)
else:
raise RuntimeError("Bad combination of parameters. Either valence and arousal or r and phi need to be provided.")
# Make sure emotion is restricted to within unity circle.
if abs(e) > 1.0:
e = cmath.rect(1.0, cmath.phase(e))
if anim_time > 0:
self._anim = Animate([0, anim_time], [self._emotion, e])
else:
self._emotion = e
def set_emotion_val_ar(self, valence, arousal, anim_time=0):
self.set_emotion(valence=valence, arousal=arousal, anim_time=anim_time)
def set_emotion_r_phi(self, r, phi, degrees=False, anim_time=0):
self.set_emotion(r=r, phi=phi, degrees=degrees, anim_time=anim_time)
def set_dof_values(self, dof_position_values):
self.isEmotion = False
for dof in dof_position_values:
dof_position_values[dof] = constrain(dof_position_values[dof], -1.0, 1.0)
self.dof_values = dof_position_values
def update(self):
if self._anim is not None:
self._emotion = self._anim()
if self._anim.has_ended():
self._anim = None
phi = cmath.phase(self._emotion)
r = abs(self._emotion)
# Create a list of dummy values.
# None indicates that the servo at that index will not be updated.
servo_pos_us = [None for i in range(16)]
# Buffer to store all DOF values
#self.dof_values = {}
# (1) Calculate DOF positions using phi/r
# (2) This step also applies overlay functions to the DOFs
if self.isEmotion:
for dofname, dof in self.dofs.iteritems():
self.dof_values[dofname] = dof.calc(phi, r)
# (3) Update all servos
for servo in self.servos:
if servo.pin < 0 or servo.pin > 15:
continue # Skip invalid pins
if servo.dofname in self.dof_values:
servo_pos_us[servo.pin] = servo.dof_to_us(self.dof_values[servo.dofname])
# TODO: send values to hardware
with Hardware.lock:
Hardware.servo_set_all(servo_pos_us)
def empty_config(self):
self.servos = []
self.dofs = {}
def load_config(self):
def open_yaml(filename):
"""Helper function to load YAML files into a dict."""
try:
yaml_dict = None
with open(filename) as f:
yaml_dict = yaml.load(f, Loader=Loader)
return yaml_dict
except IOError:
raise RuntimeError("Could not open YAML file: %s" % filename)
def default(x, e, y):
"""
Helper function that attempts to read a key from a dict. If the
specified exception occurs, a default value is returned.
"""
try:
return x()
except e:
return y
pinmap_yaml = open_yaml(_configs["pinmap"])
limits_yaml = open_yaml(_configs["limits"])
functions_yaml = open_yaml(_configs["functions"])
self.empty_config()
# Create all Servo objects
# Starts from pinmap, as a servo needs to have a pin associated with it.
# If DOF not found in limits, default values are assigned.
for pin, dofname in pinmap_yaml.iteritems():
dofname = str(dofname) # Force into str
s = {}
s["pin"] = pin
s["dofname"] = dofname
s["min_range"] = default(lambda: limits_yaml[dofname]["min"], KeyError, None)
s["mid_pos"] = default(lambda: limits_yaml[dofname]["mid"], KeyError, None)
s["max_range"] = default(lambda: limits_yaml[dofname]["max"], KeyError, None)
# Remove all empty values
s = {k: v for k, v in s.items() if v is not None}
# Create new servo object from dict
self.servos.append(Servo(**s))
# Create all DOF objects
# Starts from functions YAML
# If DOF not found in limits, default values are assigned.
for dofname, params in functions_yaml.iteritems():
d = {}
d["name"] = dofname
d["neutral"] = default(lambda: params.pop("neutral"), KeyError, None)
d["poly"] = default(lambda: params.pop("poly"), KeyError, None)
# Remove all empty values
d = {k: v for k, v in d.items() if v is not None}
# Create new DOF object from dict, store extra values from YAML
dof = DOF(**d)
dof.data = params
self.dofs[dofname] = dof
print_info("Loaded %d DOFs, %d servos" % (len(self.servos), len(self.dofs)) )
from animate import Animate from painter import Painter import numpy as np #Paint a random painting painting = Painter() painting.generate_n_frames(300) Animate(painting.frames)
class FireBall(Sprite):
# sprite for the fireball
def __init__(self,
x,
y,
norm_images,
explode_images,
obstacles,
floor,
goomba,
koopa,
speed=5):
self.norm_animator = Animate(norm_images)
self.explode_animator = Animate(explode_images, repeat=False)
self.image = self.norm_animator.get_image()
self.rect = self.image.get_rect()
self.rect.x, self.rect.y = x, y
self.obstacles = obstacles
self.floor = floor
self.goomba, self.koopa = goomba, koopa
self.speed_x = speed
self.speed_y = speed
self.active = True
super(FireBall, self).__init__()
def check_hit_wall(self):
# checks if fireball hits wall
for obs in self.obstacles:
pts = [
obs.rect.midleft, obs.rect.midright, obs.rect.bottomleft,
obs.rect.bottomright
]
for pt in pts:
if self.rect.collidepoint(pt):
self.active = False
return
for flr_rect in self.floor:
pts = [
flr_rect.midleft, flr_rect.midright, flr_rect.bottomleft,
flr_rect.bottomright
]
for pt in pts:
if self.rect.collidepoint(pt):
self.active = False
return
def check_hit_enemies(self):
# checks if fireball hits enemy
for g_enemy in self.goomba:
if collide_rect(self, g_enemy):
g_enemy.kill()
self.active = False
return
for k_enemy in self.koopa:
if collide_rect(self, k_enemy):
k_enemy.kill()
self.active = False
return
def apply_gravity(self):
# gravity to the fireball
bounce = False
for obs in self.obstacles:
pts = [obs.rect.topleft, obs.rect.midtop, obs.rect.topright]
for pt in pts:
if self.rect.collidepoint(pt):
bounce = True
break
if bounce:
break
if not bounce:
for flr_rect in self.floor:
# check if bottom is at the top of the floor rect and that the x pos is within floor area
if self.rect.bottom >= flr_rect.top and (
flr_rect.left < self.rect.center[0] < flr_rect.right):
bounce = True
break
if bounce:
self.speed_y = -abs(
self.speed_y) # ensure speed in y-direction is negative
else:
self.speed_y += 2 # apply gravity
self.rect.y += self.speed_y
def update(self):
# updates position of fireball
if self.active:
self.rect.x += self.speed_x
self.apply_gravity()
self.image = self.norm_animator.get_image()
self.check_hit_wall()
self.check_hit_enemies()
elif self.explode_animator.is_animation_done():
self.kill()
else:
self.image = self.explode_animator.get_image()
