class Controller: 'State of the simulation' def __init__(self, num_steps=100): self.initialize_model() self.initialize_animation() self.num_steps = num_steps def initialize_model(self): self.grid = Grid() self.grid.print_map() for i in range(num_people): self.grid.make_random_person() for i in range(num_fires): self.grid.make_random_fire() def initialize_animation(self): self.animation = Animation(self.grid) def start_simulation(self): print("Start simulation") for i in range(self.num_steps): self.update(i) self.end_simulation() def update(self, i): self.grid.simulate_step() self.animation.update_data(self.grid) def end_simulation(self): ani = self.animation.make_animation(self.num_steps) plt.show() print("End simulation")
def next_stage(self): self.ship = Animation(frames_path['ship'], ((self.w/16)*14, 200), self.screen) self.ship.reduce_scale(4) self.ship.centralize() self.sound_queue.append(sounds['stage']) self.played_sections += 1 self.last_dig = None self.curr_dig = None self.show_item = False self.stage_done = False self.treasure_found = False self.stage_begin = True self.block_index = 0 self.stage_map = Map(3 + self.played_sections, self.screen, self.w, self.h) self.char = Character(self.screen, Gameplay.char_sex, self.stage_map.blocks[self.block_index]) self.char.reduce_scale(4) self.char.centralize() self.elements = [self.bg, self.stage_map, self.ship, self.char]
def __init__(self, values): super(SuperGuinea, self).__init__(values) self.flying_r = self.img_folder + "/guinea-r-fly.png" self.flying_l = self.img_folder + "/guinea-l-fly.png" self.fly_fast_r_animation = Animation(self.img_folder + "/guinea-r-fly-fast-", 2, 1, True) self.fly_fast_l_animation = Animation(self.img_folder + "/guinea-l-fly-fast-", 2, 1, True)
class WindShift(FrozenClass): def __init__(self, surfaceoranimation, xpos, ypos, endtime): self.scompscale = variables.compscale() self.animation = surfaceoranimation if type(self.animation) == Surface: # frame rate does not matter if static image self.animation = Animation([self.animation], 10000, surfacelist=True) # map coordinates in pixels self.xpos = xpos self.ypos = ypos # when it expires self.endtime = endtime self._freeze() def draw(self, mapoffset, destination=variables.screen): cmpscale = variables.compscale() surf = self.animation.current_frame() offset = self.animation.current_offset() # only draw if it was spawned at the correct scale and on screen if cmpscale == self.scompscale: drawrect = Rect( self.xpos * cmpscale + mapoffset[0] + offset[0] * cmpscale, self.ypos * cmpscale + mapoffset[1] + offset[1] * cmpscale, surf.get_width(), surf.get_height()) if screenrect.contains(drawrect): destination.blit(surf, drawrect) variables.dirtyrects.append(drawrect)
def __init__(self, fileName, keys, stick, stones, helps, ball, bar, rightBall, level, game): """ Initialize a challenge @param self -- the challenge @param fileName -- a string that contains the sound name @param keys -- the key vector @param stick -- the stick @param stones -- the stones @param helps -- the helps @param ball -- the left ball that it is used in the animation @param bar -- the grey bar that it is used in the animation @param rightBall -- the right ball that it is used in the animation @param level -- the challenge level @param game -- the game """ self.fileName = fileName self.music = Sound() self.music.setFileName("sound/music/" + fileName) self.section = Section() self.section.setFileName("sound/section/" + fileName) self.section.setKeys(keys) self.stick = stick self.animation = Animation(stones, keys, helps, ball, rightBall, bar, game) self.ball = ball self.level = level self.attempts = 0 self.game = game
def __init__(self, text, on_click_deferred, on_click_return_value, window_values, surface, hover_animation_surface = None, mouse_down_animation = None, spritesheet_dimensions=(2, 2), font_size='big'): #spritesheet for potential fancy animations later self.x, self.y, self.w, self.h = window_values self.font_size = font_size self.text = text self.surface = surface self.text_label = render_text(text, (0,0,0), font_size) self.get_text_draw_coords() self.on_click_deferred = on_click_deferred self.on_click_return_value = on_click_return_value hover_animation_surface = None if hover_animation_surface: self.on_hover_animation = Animation(TileSheet(hover_animation_surface, 292, 120, spritesheet_dimensions[0], spritesheet_dimensions[1]), 10, 4) else: self.on_hover_animation = None if mouse_down_animation: self.mouse_down_animation = Animation(TileSheet(mouse_down_animation, 292, 120, 1, 1), 10, 1) else: self.mouse_down_animation = None self.on_hover_animation_active = False self.mouse_down_animation_active = False
def test_Can_Get_Result_After_It_Is_Set(): a = Animation([]) a.SetResult(Rect(1, 2, 3, 4), 1, True) r = a.GetResult() assert r.area == Rect(1, 2, 3, 4) assert r.statusType == 1 assert r.statusEnabled == True
def test_Can_Resume(): a = Animation([]) assert a.running == True a.Pause() assert a.running == False a.Resume() assert a.running == True
class Hint: scrol_frames = ['img/scrol_frame_1.png', 'img/scrol_frame_2.png'] def __init__(self, pos, hint, screen): self.pos = pos self.hint = hint self.screen = screen self.overlay = Overlay(self.screen, (0, 0), self.screen.get_size()[0], self.screen.get_size()[1]) self.textsurface = Text(self.screen, self.pos, self.hint, True, (232, 197, 150)) self.scrol = Animation(self.scrol_frames, self.pos, self.screen) self.scrol.reduce_scale(4) self.scrol.centralize() self.elements = [self.overlay, self.scrol, self.textsurface] def draw(self): for element in self.elements: element.draw()
def __init__(self, canvas, imageCenter, imagePath): Animation.__init__(self, canvas, self.drawCommand, ImageCircleAnimation.cycleDuration) self.imageCenter = imageCenter image = Image.open(imagePath) self.croppedImageSource = cropCircleImage(image) self.easingFunction = easeOutElastic
def __init__(self, values): super(Nugget, self).__init__(values) self.nugget_animation = Animation("nugget-", 4, 2, True) self.collected_animation = Animation("yellow-particle-", 4, 1, False) self.x -= 4 self.y -= 4 self.w = 32 self.h = 32
def test_Is_Marked_For_Deletion_After_Animation_Complete(): a = Animation([1, 2, 3]) assert a.markedForDeletion == False a.Run() # Frame 1 assert a.markedForDeletion == False a.Run() # Frame 2 assert a.markedForDeletion == False a.Run() # Frame 3 assert a.markedForDeletion == True
def parse(self, node): self.id = int(node.attrib['id']) self.name = node.attrib['name'] for elem in node: if elem.tag != 'animation': continue a = Animation(elem) self.animations[a.get_id()] = a
class DecryptorGif: def __init__(self, message, fontfile="C:\\WINDOWS\\FONTS\\CONSOLA.TTF", fontsize=50, textcolor="green", background="black", outputfile="decryptor.gif", margin=20): # FONT_FILE = '/System/Library/Fonts/Monaco.dfont' # FONT_FILE = "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf" self.font = ImageFont.truetype(font=fontfile, size=fontsize) self.textcolor = textcolor self.background = background self.margin = margin self.animation = Animation(filename=outputfile, duration=.1) self.make_images(message) self.animation.save_gif() def create_frame(self, size, message_string): img = Image.new('RGB', size, color=self.background) drawing = ImageDraw.Draw(img) drawing.text((10, 10), message_string, fill=self.textcolor, font=self.font) self.animation.frames = img def get_text_size(self, text): img = Image.new('RGB', (1, 1), color='black') drawing = ImageDraw.Draw(img) size = drawing.textsize(text, font=self.font) return size[0] + self.margin, size[1] + self.margin def make_images(self, message_string): size = self.get_text_size(message_string) for i, guess in enumerate(self.crypt_strings(message_string)): self.create_frame(size, guess) @staticmethod def crypt_strings(message_string): previous_guesses = tuple(set() for _ in message_string) current_chars = random.choices(CHARS, k=len(message_string)) current_string = "".join(current_chars) yield current_string while current_string != message_string: for idx, target_char in enumerate(message_string): if current_chars[idx] != target_char: guess = random.choice( tuple(CHARSET_CHARS - previous_guesses[idx])) previous_guesses[idx].add(guess) current_chars[idx] = guess current_string = "".join(current_chars) yield current_string
def __init__(self, message, fontfile="C:\\WINDOWS\\FONTS\\CONSOLA.TTF", fontsize=50, textcolor="green", background="black", outputfile="decryptor.gif", margin=20): # FONT_FILE = '/System/Library/Fonts/Monaco.dfont' # FONT_FILE = "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf" self.font = ImageFont.truetype(font=fontfile, size=fontsize) self.textcolor = textcolor self.background = background self.margin = margin self.animation = Animation(filename=outputfile, duration=.1) self.make_images(message) self.animation.save_gif()
def __init__(self): super().__init__() self.w, self.h = self.screen.get_size() self.next_state = "STARTMENU" self.sound_queue.append(sounds['menu']) bg = Animation(frames_path['play-background'], (0, 0), self.screen) image = Animation(frames_path['how-to-play'], (0, 0), self.screen) self.elements = [bg, image]
def __init__(self, var_dict): BaseObject.__init__(self, var_dict) self.type = PLAYER self.xvel = 0 self.yvel = 0 self.jumpvel = 1 self.walkvel = 0.05 self.maxXvel = 2.3 self.maxYvel = 8 self.direction = DIR_RIGHT self.iswalking = False self.on_object = None self.col_object = None self.jump_state = NOT_JUMPING self.airborne = True self.j_delay_timer = Timer(50, self.__next_jump_state, False) self.jump_timer = Timer(240, self.__next_jump_state, False) self._layer = 10 #Array of objects currently colliding with rect - Tracks objects that are possible to interact with self.pos_interact = [] self.held_item = None self.drop_item = None self.collidable = True self.held_ofs_x = 0.0 self.held_ofs_y = 0.0 self.obey_gravity = True self.visible = True self.idle_files = var_dict['idle_files'].split(',') self.idle_times = var_dict['idle_times'].split(',') self.jump_files = var_dict['jump_files'].split(',') self.jump_times = var_dict['jump_times'].split(',') self.walk_files = var_dict['walk_files'].split(',') self.walk_times = var_dict['walk_times'].split(',') self.idle_anim = Animation(self.idle_files, self.idle_times) self.jumping_anim = Animation(self.jump_files, self.jump_times) self.walking_anim = Animation(self.walk_files, self.walk_times) self.walking_anim.set_colorkey((255, 255, 255)) if var_dict['w'] == 0 or var_dict['h'] == 0: self.rect.w = self.idle_anim.getRect().w self.rect.h = self.idle_anim.getRect().h else: pass #Needs to scale all animations while keeping aspect ratio. #self.walking_anim.scale((var_dict['w'], var_dict['h'])) #self.jumping_anim.scale((var_dict['w'], var_dict['h'])) self.anim_player = Animation_Player() self.anim_player.add(self.walking_anim, WALK_ANIM) self.anim_player.add(self.jumping_anim, JUMP_ANIM) self.anim_player.add(self.idle_anim, IDLE_ANIM) self.anim_player.set(IDLE_ANIM, True)
def __init__(self, parent=None): QWidget.__init__(self, parent) # Database Reader Module self.dbReader = TestDatabaseReader() # NFC Reader Thread self.nfcReader = NFCReader() self.nfcReader.start() # Animation self.animation = Animation() # UI for the page self.ui = Ui_LogIn() self.ui.setupUi(self) # hide dialogue self.ui.DialogueShadow.hide() # Insert buttons into QButtonGroup self.keypadButtons = QButtonGroup() self.keypadButtons.addButton(self.ui.KeypadButton_0, 0) self.keypadButtons.addButton(self.ui.KeypadButton_1, 1) self.keypadButtons.addButton(self.ui.KeypadButton_2, 2) self.keypadButtons.addButton(self.ui.KeypadButton_3, 3) self.keypadButtons.addButton(self.ui.KeypadButton_4, 4) self.keypadButtons.addButton(self.ui.KeypadButton_5, 5) self.keypadButtons.addButton(self.ui.KeypadButton_6, 6) self.keypadButtons.addButton(self.ui.KeypadButton_7, 7) self.keypadButtons.addButton(self.ui.KeypadButton_8, 8) self.keypadButtons.addButton(self.ui.KeypadButton_9, 9) self.keyDisplays = QButtonGroup() self.keyDisplays.addButton(self.ui.NumberDisplay_1, 1) self.keyDisplays.addButton(self.ui.NumberDisplay_2, 2) self.keyDisplays.addButton(self.ui.NumberDisplay_3, 3) self.keyDisplays.addButton(self.ui.NumberDisplay_4, 4) self.keyDisplays.addButton(self.ui.NumberDisplay_5, 5) self.keyDisplays.addButton(self.ui.NumberDisplay_6, 6) self.keyDisplays.addButton(self.ui.NumberDisplay_7, 7) self.keyDisplays.addButton(self.ui.NumberDisplay_8, 8) self.displayIndex = 1 self.password = "" for i in range(0, 10): self.keypadButtons.button(i).clicked.connect( partial(self.writeNumber, i)) self.ui.DButtonYes.clicked.connect(lambda: print("playing piano!")) self.ui.DButtonNo.clicked.connect(lambda: self.hideDialogueCheck()) self.nfcReader.nfc_connect.connect(self.checkValidUid)
def __init__(self, curve, cp, col, factor=1, name="", visible=False, parent=None): """curve is something derived from Line""" GraphicObject.__init__(self, visible, parent) comp = SoComplexity() comp.value.setValue(.1) self.separator.addChild(comp) ## ============================ points = curve.getPoints() pointsp = [ curve[i] + cp(t) * factor for i, t in enumerate(intervalPartition(curve.iter)) ] for p, pp in zip(points, pointsp): self.addChild( Arrow(p, pp, visible=True, escala=.005, extremos=True)) self.animation = Animation(lambda num: self[num - 1].show(), (4000, 1, len(points)))
def __init__(self, var_dict): BaseObject.__init__(self, var_dict) self.type = LEVEL_OBJECT self.files = var_dict['files'].split(',') self.times = var_dict['times'].split(',') #HACK - ANIMATION WILL CHANGE THIS #If files is larger than 1, create animation with 2 frames # if len(self.files) > 1 and self.files[1] != '': # self.idle_anim = pyganim.PygAnimation([(os.path.join(self.files[0]), .75), # (os.path.join(self.files[1]), .75)]) # self.idle_anim.set_colorkey((255, 255, 255)) # #Else if files has 1 file, create animation with 1 frame # elif len(self.files) > 0: # self.idle_anim = pyganim.PygAnimation([(os.path.join(self.files[0]), 1)]) # self.idle_anim.set_colorkey((255, 255, 255)) self.idle_anim = Animation(self.files, self.times) #If width or height is 0, use default w/h if var_dict['w'] == 0 or var_dict['h'] == 0: self.rect.w = self.idle_anim.getRect().w self.rect.h = self.idle_anim.getRect().h else: self.idle_anim.scale((var_dict['w'], var_dict['h'])) self.rect.x = var_dict['x'] self.rect.y = var_dict['y'] self.col_objects = [] self.on_object = None self._layer = var_dict['_layer'] self.layer = self._layer self.collidable = to_bool(var_dict['collidable']) self.idle_anim.play() self.obey_gravity = to_bool(var_dict['obey_gravity']) self.visible = True
def __init__(self, pos, hint, screen): self.pos = pos self.hint = hint self.screen = screen self.overlay = Overlay(self.screen, (0, 0), self.screen.get_size()[0], self.screen.get_size()[1]) self.textsurface = Text(self.screen, self.pos, self.hint, True, (232, 197, 150)) self.scrol = Animation(self.scrol_frames, self.pos, self.screen) self.scrol.reduce_scale(4) self.scrol.centralize() self.elements = [self.overlay, self.scrol, self.textsurface]
def __init__(self, stance_path, action): print(stance_path) self.path = stance_path + "/" + action self.sub_dirs = glob.glob(self.path + '/*') self.animations = [ Animation(x, ACTIVITY_PARAMS[action][0], ACTIVITY_PARAMS[action][1]) for x in self.sub_dirs ]
def __init__(self, id: int, position: [float, float], type_name="MovableObject"): super(MovableObject, self).__init__(id, position, type_name=type_name) self._max_hp = game_objects_data[id]['max_hp'] self._hp = self._max_hp self._speed = game_objects_data[id]['speed'] self._velocity_vector = [0, 0] self.drop = game_objects_data[id]['drop'] self.animation = Animation(id) self._position = position
def __init__(self, surfaceoranimation, xpos, ypos, endtime): self.scompscale = variables.compscale() self.animation = surfaceoranimation if type(self.animation) == Surface: # frame rate does not matter if static image self.animation = Animation([self.animation], 10000, surfacelist=True) # map coordinates in pixels self.xpos = xpos self.ypos = ypos # when it expires self.endtime = endtime self._freeze()
def __init__(self): super().__init__() self.w, self.h = self.screen.get_size() self.sound_queue.append(sounds['stage']) self.menu = Menu(self.screen) self.menu.add_button('sound', frames_path['sound'],(int((self.w/16)*15), int((self.h/10)*1)),self.switch_sound) self.menu.buttons['sound'].reduce_scale(5) self.menu.buttons['sound'].centralize() self.msgs = { 'lose': Text(self.screen, (int(self.w/2), 200), 'Oh não, os piratas chegaram na ilha, melhor zarparmos e tentarmos denovo outro dia!', True, (255,255,255)) } ''' Sessões de Jogo ''' self.played_sections = 0 self.wins = 0 self.stage_done = False self.stage_begin = True ''' Mapa ''' self.block_index = 0 self.stage_map = Map(3, self.screen, self.w, self.h) ''' Escavações ''' self.last_dig = None self.curr_dig = None self.show_item = False ''' Personagem ''' self.char = Character(self.screen, Gameplay.char_sex, self.stage_map.blocks[self.block_index]) self.char.reduce_scale(4) self.char.centralize() ''' Cena ''' self.ship = Animation(frames_path['ship'], ((self.w/16)*14, 200), self.screen) self.ship.reduce_scale(4) self.ship.centralize() self.bg = Animation(frames_path['play-background'], (0, 0), self.screen) self.elements = [self.bg, self.stage_map, self.ship, self.char]
def __init__(self, gmp, posX, posY, w, h, gms): pygame.init() #Initialise le module pygame self.gamePanel = gmp #Jesaispasquoimettrec'estevident self.gameScene = gms self.width = w #Largeur du joueur self.height = h #Hauteur du joueur self.FPS = Constants.FPS self.fast = Constants.screenHeight / 40 / Constants.FPS #0.25 -> 60FPS/0.5 -> 30FPS #De combien on bouge de pixel entre chaque update self.movingUp = False self.isPlaying = False self.dy = 0 self.maxDy = 40 / (Constants.FPS / 15) self.lastPos = [] self.pointSpeed = int((math.sqrt(Constants.screenWidth) / 4)) self.maxPoint = 10 self.dead = False self.ball = getBalls()[int(Helper.getSelectedBall())] self.currentThemeId = self.gameScene.getCurrentTheme().id self.shadow = pygame.image.load('./drawable/ball_shadow.png') self.shadow = pygame.transform.scale(self.shadow, (self.width, self.height)) self.currentSpritesheet = self.ball.yellow_spritesheet self.animation = Animation(self.currentSpritesheet, 50, 50, self.ball.numFrames, self.ball.speed) self.pos = pygame.Rect(0, 0, 0, 0) self.pos.x = posX self.pos.y = posY #BONUS self.slow = False self.shield = False self.speed = False pygame.display.flip()
def import_fbx_as_anim(filename, pelvis_name=None): joint_names, parents, offsets, qs, ts, qs_global, ts_global = import_fbx( filename, pelvis_name) orients = Quaternions.id(len(joint_names)) # anim = Animation(rotations=Quaternions.id((qs.shape[0], qs.shape[1])), # positions=ts, orients=orients, offsets=offsets, parents=parents) anim = Animation(rotations=Quaternions(qs), positions=ts, orients=orients, offsets=offsets, parents=parents) return joint_names, parents, offsets, anim, ts_global
def main(): ''' Initialises the engine and loads the scene. For every frame it updates the camera, updates the animated entity (which updates the animation), renders the scene to the screen, and then updates the display. When the display is closed the engine gets cleaned up. ''' # texture_path = 'data/models/assimp/duck_sample.jpg' # texture_path = 'data/shea-coulee.png' texture_path = 'data/models/farm_boy/diffuse.png' # model_path = 'data/models/duck/duck_triangles.dae' # model_path = 'data/models/basic/cow.obj' # model_path = 'data/models/regina/regina.dae' model_path = 'data/models/farm_boy/model.dae' engine = RenderEngine() loader = OpenGLLoader() model = ColladaParser(model_path) raw_model: RawModel = loader.load_to_VAO(model) textureID = loader.load_texture(texture_path) animated_model = AnimatedModel(raw_model, textureID, root_joint=model.root_joint, num_joints=16) entity = Entity(animated_model, position=[0, -5, -30], rotation=[-90, 30, 0], scale=1.0) # farm boy # entity = Entity(animated_model, position=[0, -160, -600], rotation=[0, 0, 0], scale=1.0) # regina camera = Camera(model.vertices.max()) scene = Scene(entity, camera) animation = Animation(model.key_frames) scene.entity.animator.set_animation(animation) while not engine.window_should_close(): glfw.poll_events() scene.camera.move() scene.entity.increase_position([0, 0, 0]) # scene.entity.increase_rotation([0, 0.2, 0]) scene.entity.update() engine.render_scene(scene) engine.update() loader.clean_up() engine.close()
class WindShift(FrozenClass): def __init__(self, surfaceoranimation, xpos, ypos, endtime): self.scompscale = variables.compscale() self.animation = surfaceoranimation if type(self.animation) == Surface: # frame rate does not matter if static image self.animation = Animation([self.animation], 10000, surfacelist = True) # map coordinates in pixels self.xpos = xpos self.ypos = ypos # when it expires self.endtime = endtime self._freeze() def draw(self, mapoffset, destination = variables.screen): cmpscale = variables.compscale() surf = self.animation.current_frame() offset = self.animation.current_offset() # only draw if it was spawned at the correct scale and on screen if cmpscale == self.scompscale: drawrect = Rect(self.xpos*cmpscale + mapoffset[0] + offset[0]*cmpscale, self.ypos*cmpscale + mapoffset[1] + offset[1]*cmpscale, surf.get_width(), surf.get_height()) if screenrect.contains(drawrect): destination.blit(surf, drawrect) variables.dirtyrects.append(drawrect)
def test_Will_Loop_If_Marked_For_Looping(): a = Animation([1, 2, 3]) a.SetLooping(True) assert a.currentFrame == 0 a.Run() assert a.currentFrame == 1 a.Run() assert a.currentFrame == 2 a.Run() assert a.currentFrame == 0
def __init__(self): super().__init__() self.w, self.h = self.screen.get_size() bg = Animation(frames_path['play-background'], (0, 0), self.screen) text = Text(self.screen, (int(self.w/2), 100), 'Escolha seu Pirata, marujo!', True, (255,255,255), 50) self.menu = Menu(self.screen) self.menu.add_button('boy-pirate', frames_path['boy-pirate'],((self.w/4), (self.h/2)),self.selectBoy) self.menu.buttons['boy-pirate'].reduce_scale(3) self.menu.buttons['boy-pirate'].centralize() self.menu.add_button('girl-pirate', frames_path['girl-pirate'],((self.w/4)*3, (self.h/2)),self.selectBoy) self.menu.buttons['girl-pirate'].reduce_scale(3) self.menu.buttons['girl-pirate'].centralize() self.elements = [bg, self.menu, text]
def __init__(self, surfaceoranimation, xpos, ypos, endtime): self.scompscale = variables.compscale() self.animation = surfaceoranimation if type(self.animation) == Surface: # frame rate does not matter if static image self.animation = Animation([self.animation], 10000, surfacelist = True) # map coordinates in pixels self.xpos = xpos self.ypos = ypos # when it expires self.endtime = endtime self._freeze()
class FlyingNugget(Ob): img = "nugget-1.png" w = 8 h = 8 is_mover = True experiences_gravity = True collides_with_movers = False is_solid = False nugget_animation = Animation("nugget-", 4, 2, True) does_not_collide = True def __init__(self, values): super(FlyingNugget, self).__init__(values) self.created_at = datetime.datetime.now() def behave(self, engine): super().behave(engine) if datetime.datetime.now() - self.created_at > datetime.timedelta(seconds=5): engine.remove_ob(self) def animate(self, engine): self.set_animation(self.nugget_animation)
def main_origin(): parser = argparse.ArgumentParser() parser.add_argument("map", help="input file containing map") parser.add_argument("schedule", help="schedule for agents") parser.add_argument('--video', dest='video', default=None, help="output video file (or leave empty to show on screen)") parser.add_argument("--speed", type=int, default=1, help="speedup-factor") args = parser.parse_args() with open(args.map) as map_file: map = yaml.load(map_file, Loader=yaml.FullLoader) with open(args.schedule) as states_file: schedule = yaml.load(states_file, Loader=yaml.FullLoader) animation = Animation(map, schedule) if args.video: animation.save(args.video, args.speed) else: animation.show()
class LevelObject(BaseObject): def __init__(self, var_dict): BaseObject.__init__(self, var_dict) self.type = LEVEL_OBJECT self.files = var_dict['files'].split(',') self.times = var_dict['times'].split(',') #HACK - ANIMATION WILL CHANGE THIS #If files is larger than 1, create animation with 2 frames # if len(self.files) > 1 and self.files[1] != '': # self.idle_anim = pyganim.PygAnimation([(os.path.join(self.files[0]), .75), # (os.path.join(self.files[1]), .75)]) # self.idle_anim.set_colorkey((255, 255, 255)) # #Else if files has 1 file, create animation with 1 frame # elif len(self.files) > 0: # self.idle_anim = pyganim.PygAnimation([(os.path.join(self.files[0]), 1)]) # self.idle_anim.set_colorkey((255, 255, 255)) self.idle_anim = Animation(self.files, self.times) #If width or height is 0, use default w/h if var_dict['w'] == 0 or var_dict['h'] == 0: self.rect.w = self.idle_anim.getRect().w self.rect.h = self.idle_anim.getRect().h else: self.idle_anim.scale((var_dict['w'], var_dict['h'])) self.rect.x = var_dict['x'] self.rect.y = var_dict['y'] self.col_objects = [] self.on_object = None self._layer = var_dict['_layer'] self.layer = self._layer self.collidable = to_bool(var_dict['collidable']) self.idle_anim.play() self.obey_gravity = to_bool(var_dict['obey_gravity']) self.visible = True def draw(self, screen, translated): self.idle_anim.blit(screen, translated) def update(self): self.move() def do_gravity(self, gravity): self._change_vel(DIR_DOWN, gravity) def collide(self, obj): if self.rect.colliderect(obj.rect): if obj.collidable: self.col_objects.append(obj) if obj.type == PLAYER: return if obj.rect.collidepoint(self.rect.midbottom): self.yvel = 0 #save the object the object is on self.on_object = obj.rect elif obj in self.col_objects: self.col_objects.remove(obj) def config_files(self, config, counter): config.set(self.name, 'file' + str(counter), self.files[counter]) if counter >= len(self.files): counter += 1 self.config_files(config, counter) def serialize(self, config): BaseObject.serialize(self, config)
def __init__(self, proxy): assert proxy.__class__ is ALProxy; self.__proxy = proxy; self.__ledsNames, self.__colorsNames = self.__getLedsNames(); self.__animation = Animation(); self.__parallelism = False;
class PlayerSprite(BaseObject): def __init__(self, var_dict): BaseObject.__init__(self, var_dict) self.type = PLAYER self.xvel = 0 self.yvel = 0 self.jumpvel = 1 self.walkvel = 0.05 self.maxXvel = 2.3 self.maxYvel = 8 self.direction = DIR_RIGHT self.iswalking = False self.on_object = None self.col_object = None self.jump_state = NOT_JUMPING self.airborne = True self.j_delay_timer = Timer(50, self.__next_jump_state, False) self.jump_timer = Timer(240, self.__next_jump_state, False) self._layer = 10 #Array of objects currently colliding with rect - Tracks objects that are possible to interact with self.pos_interact = [] self.held_item = None self.drop_item = None self.collidable = True self.held_ofs_x = 0.0 self.held_ofs_y = 0.0 self.obey_gravity = True self.visible = True self.idle_files = var_dict['idle_files'].split(',') self.idle_times = var_dict['idle_times'].split(',') self.jump_files = var_dict['jump_files'].split(',') self.jump_times = var_dict['jump_times'].split(',') self.walk_files = var_dict['walk_files'].split(',') self.walk_times = var_dict['walk_times'].split(',') self.idle_anim = Animation(self.idle_files, self.idle_times) self.jumping_anim = Animation(self.jump_files, self.jump_times) self.walking_anim = Animation(self.walk_files, self.walk_times) self.walking_anim.set_colorkey((255, 255, 255)) if var_dict['w'] == 0 or var_dict['h'] == 0: self.rect.w = self.idle_anim.getRect().w self.rect.h = self.idle_anim.getRect().h else: pass #Needs to scale all animations while keeping aspect ratio. #self.walking_anim.scale((var_dict['w'], var_dict['h'])) #self.jumping_anim.scale((var_dict['w'], var_dict['h'])) self.anim_player = Animation_Player() self.anim_player.add(self.walking_anim, WALK_ANIM) self.anim_player.add(self.jumping_anim, JUMP_ANIM) self.anim_player.add(self.idle_anim, IDLE_ANIM) self.anim_player.set(IDLE_ANIM, True) def draw(self, screen, rect_loc): if self.jump_state > 0: self.anim_player.set(JUMP_ANIM) elif self.iswalking is True: self.anim_player.set(WALK_ANIM) else: self.anim_player.set(IDLE_ANIM) self.anim_player.draw(screen, rect_loc) def move(self): if self.iswalking is False: if self.xvel <= 0: self.xvel = 0 else: self.xvel -= 1 if self.direction == DIR_RIGHT and self.iswalking: if self.col_object is None: self._change_vel(DIR_RIGHT, self.walkvel) else: #check what side the object is on, permit walking the other way if self.col_object.rect.x < self.rect.x: self._change_vel(DIR_RIGHT, self.walkvel) elif self.direction == DIR_LEFT and self.iswalking: if self.col_object is None: self._change_vel(DIR_LEFT, self.walkvel) else: if self.col_object.rect.x > self.rect.x: self._change_vel(DIR_LEFT, self.walkvel) #Is the player colliding with ANY objects? if self.col_object is not None: #Check if still colliding with col_object if not self.rect.colliderect(self.col_object.rect): self.col_object = None #If player was on top of an object last tick if self.on_object is not None: #Check if player is still on object if self.on_object.rect.collidepoint(self.rect.midbottom): self.airborne = False #If player is on an object and yvel is being modified by do_jump(), stop the jump #if self._is_jumping(): # self._stop_jump() else: self.on_object = None else: self.airborne = True if self.jump_state == JUMP: self._do_jump() self.update_pos() def move_direction(self, player_dir): #check if changing direction, if so lessen x velocity if player_dir != self.direction: self.xvel -= self.xvel / 2 self.anim_player.flip() self.direction = player_dir self.iswalking = True def collide(self, obj): """Returns if object is colliding, calls _respond_collision on True and _check_pos_interact every time""" colliding = False if self.rect.colliderect(obj.rect): colliding = True self._respond_collision(obj) self._check_pos_interact(obj, colliding) return colliding def _respond_collision(self, obj): """Responds to a collision, trusts the caller that the objects are colliding""" if obj.collidable: #save the last collided object self.col_object = obj if obj.rect.collidepoint(self.rect.midbottom): self.yvel = 0 self.rect.bottom = obj.rect.top #save the object the player is on self.on_object = obj #If falling, let jump state know player landed if self.jump_state == FALLING: self.__next_jump_state() elif obj.rect.collidepoint(self.rect.bottomleft): if self.direction == DIR_LEFT: self.xvel = 0 elif obj.rect.collidepoint(self.rect.bottomright): if self.direction == DIR_RIGHT: self.xvel = 0 def _check_pos_interact(self, obj, colliding): """Maintains list of objects with possible interaction""" if colliding: if obj not in self.pos_interact: self.pos_interact.append(obj) else: if obj in self.pos_interact: self.pos_interact.remove(obj) def __next_jump_state(self): if self.jump_state == NOT_JUMPING: self.jump_state = JUMP_DELAY self.j_delay_timer.start_timer() elif self.jump_state == JUMP_DELAY: self.jump_state = JUMP self.jump_timer.start_timer() self._change_vel(DIR_UP, 2) elif self.jump_state == JUMP: self.jump_state = FALLING elif self.jump_state == FALLING: self.jump_state = NOT_JUMPING else: print("Invalid player jump state: " + str(self.jump_state)) def start_jump(self): self.__next_jump_state() def _do_jump(self): self._change_vel(DIR_UP, self.jumpvel) def update(self): self.move() def do_gravity(self, gravity): self._change_vel(DIR_DOWN, gravity) def check_interactions(self): if not self._use_timer: self._use_timer = Timer(self.use_timer_len, self._set_can_use) if self._can_use: #interact with held item if self.held_item: if self.interact(self.held_item, PLACE): self._can_use = False self._use_timer.start_timer() return for obj in self.pos_interact: if self.interact(obj, TOGGLE_POWER): return def interact(self, obj, behvaior): print('interacting with ' + obj.name) for behavior in self.behaviors: if self.delegate_behavior(obj, behavior): return True return False def delegate_behavior(self, obj, behavior): if behavior == PICKUP: return self.pickup(obj) if behavior == PLACE: return self.drop() return obj.interact(self, behavior) def drop(self): if self.held_item: self.drop_item = self.held_item self.drop_item.visible = True self.drop_item.obey_gravity = True self.held_item = None print('dropped item') return True return False def pickup(self, obj): if PICKUP in obj.behaviors and not self.held_item: obj.visible = False obj.obey_gravity = False self.held_item = obj #level.objects.change_layer(self.held_item, self._layer) #Check/update this in level.draw function self.held_item.rect.y = self.rect.centery + (self.rect.w / 6) self.held_item.rect.x = self.rect.centerx #save offsets from the top left of player sprite self.held_ofs_x = self.held_item.rect.x - self.rect.x self.held_ofs_y = self.held_item.rect.y - self.rect.y print('picked up item') return True return False def update_pos(self): self.rect.x += self.xvel self.rect.y += self.yvel if self.held_item: self.held_item.rect.x = self.held_ofs_x + self.rect.x self.held_item.rect.y = self.held_ofs_y + self.rect.y
def set_animations(texture): walking_down = Animation() walking_up = Animation() walking_left = Animation() walking_right = Animation() walking_down.texture = texture walking_down.add_frame(sf.Rectangle((64, 0), (64, 64))) walking_down.add_frame(sf.Rectangle((128, 0), (64, 64))) walking_down.add_frame(sf.Rectangle((64, 0), (64, 64))) walking_down.add_frame(sf.Rectangle((0, 0), (64, 64))) walking_up.texture = texture walking_up.add_frame(sf.Rectangle((64, 192), (64, 64))) walking_up.add_frame(sf.Rectangle((128, 192), (64, 64))) walking_up.add_frame(sf.Rectangle((64, 192), (64, 64))) walking_up.add_frame(sf.Rectangle((0, 192), (64, 64))) walking_left.texture = texture walking_left.add_frame(sf.Rectangle((64, 64), (64, 64))) walking_left.add_frame(sf.Rectangle((128, 64), (64, 64))) walking_left.add_frame(sf.Rectangle((64, 64), (64, 64))) walking_left.add_frame(sf.Rectangle((0, 64), (64, 64))) walking_right.texture = texture walking_right.add_frame(sf.Rectangle((64, 128), (64, 64))) walking_right.add_frame(sf.Rectangle((128, 128), (64, 64))) walking_right.add_frame(sf.Rectangle((64, 128), (64, 64))) walking_right.add_frame(sf.Rectangle((0, 128), (64, 64))) return (walking_down, walking_left, walking_right, walking_up)
#param rk2 dt=((b-a)/N)/(2*(ordre+1)) Tmax=20. #param animation ymin = -1.0 ymax = 1.0 #init galerkin galerkin = GD(ordre,a,b,N) #Array 3D contenant la solution W = zeros((2,N,ordre)) #init animation x = galerkin.getX() anim = Animation(x,ymin,ymax) #init rk2 rk2 = RK2(dt,galerkin.dW) #avance temporelle while(rk2.t<Tmax): def lim0(): we = zeros((2,1)) #we[:,0] = [10*exp(-100*(rk2.t-0.2)*(rk2.t-0.2)),0.] we[:,0] = [sin(5*rk2.t/pi),0.] return we def limN(): we = zeros((2,1))
class Button(): def __init__(self, text, on_click_deferred, on_click_return_value, window_values, surface, hover_animation_surface = None, mouse_down_animation = None, spritesheet_dimensions=(2, 2), font_size='big'): #spritesheet for potential fancy animations later self.x, self.y, self.w, self.h = window_values self.font_size = font_size self.text = text self.surface = surface self.text_label = render_text(text, (0,0,0), font_size) self.get_text_draw_coords() self.on_click_deferred = on_click_deferred self.on_click_return_value = on_click_return_value hover_animation_surface = None if hover_animation_surface: self.on_hover_animation = Animation(TileSheet(hover_animation_surface, 292, 120, spritesheet_dimensions[0], spritesheet_dimensions[1]), 10, 4) else: self.on_hover_animation = None if mouse_down_animation: self.mouse_down_animation = Animation(TileSheet(mouse_down_animation, 292, 120, 1, 1), 10, 1) else: self.mouse_down_animation = None self.on_hover_animation_active = False self.mouse_down_animation_active = False def on_click(self): if self.mouse_down_animation: self.mouse_down_animation.done = True self.on_click_deferred.value = self.on_click_return_value def on_mouse_down(self): if not self.mouse_down_animation_active and self.mouse_down_animation: self.mouse_down_animation_active = True def on_hover(self): if not self.on_hover_animation_active and self.on_hover_animation: self.on_hover_animation_active = True def on_hover_off(self): self.mouse_down_animation_active = False def update(self, time=1): if self.mouse_down_animation_active: if self.mouse_down_animation.done: self.mouse_down_animation.done = False self.mouse_down_animation.reset() #self.mouse_down_animation_active = False self.mouse_down_animation.update(time) elif self.on_hover_animation_active: if self.on_hover_animation.done: self.on_hover_animation.done = False self.on_hover_animation.reset() self.on_hover_animation_active = False self.on_hover_animation.update(time) def draw(self): if self.mouse_down_animation_active: self.mouse_down_animation.draw(screen, self.x, self.y) elif self.on_hover_animation_active: self.on_hover_animation.draw(screen, self.x, self.y) else: screen.blit(self.surface, (self.x, self.y)) screen.blit(self.text_label, (self.text_x, self.text_y)) def mouse_over_button(self, mouse_pos): return Utils.point_in_rect(mouse_pos, (self.x, self.y, self.w, self.h)) def get_text_draw_coords(self): if self.font_size == "big": text_w = font.size(self.text)[0] text_h = font.size(self.text)[1] elif self.font_size == "small": text_w = font_small.size(self.text)[0] text_h = font_small.size(self.text)[1] self.text_x = self.x + 0.5 * self.w - 0.5 * text_w self.text_y = self.y + 0.5 * self.h - 0.5 * text_h
octopus_parts.extend(octopus_arms) # add the body of the octopus octopus_parts.append([AnimationPart("octopus/body")]) # now flip the list, because the body and the arms are drawn before the head octopus_parts.reverse() octopus_animation = MultiPartAnimation(octopus_parts, getpic("octopus/body").get_width(), getpic("octopus/body").get_height()) raisewing = Animation(["flyingchimney7", "flyingchimney4"], 100, False) lowerwing = Animation(["flyingchimney5", "flyingchimney6"], 60, False) chimneyanimation = Animation([raisewing, lowerwing], 600) chimneyanimation.updatealwaysbattle = True stevewave = [Animation(["scarysteven05", "scarysteven06"], 1/2), Animation(["scarysteven07", "scarysteven08"], 1/2), Animation(["scarysteven09", "scarysteven10"], 1/2), Animation(["scarysteven11", "scarysteven12"], 1/2), Animation(["scarysteven13", "scarysteven14"], 1/2), Animation(["scarysteven15", "scarysteven16"], 1/2)] for a in stevewave: a.relativeframerate = True stevehat = [Animation(["scarysteven17", "scarysteven18", "scarysteven19", "scarysteven20"], 1/4), Animation(["scarysteven21", "scarysteven22", "scarysteven23", "scarysteven24"], 1/4), Animation(["scarysteven25", "scarysteven26", "scarysteven27", "scarysteven28"], 1/4),
def __init__(self,name=0,adress=0,port=0): self.name=name self.membre=None # Différence par rapport à naoqi : # Dans l'interface OpenGL, les rotations des membres droits sont inversé par la symétrie # Donc en fait les angles pour la partie gauche et la partie droite sont les memes # alors que dans naoqi, les parties droite et gauche sont gérées indépendemment # Solution : # Après copie de la liste renvoyée par le naoqi réel, # on copie tous les éléments de la partie gauche pour les coller et remplacer ceux de # la partie droite. # Données : [angleMin, angleMax, vitesseMin, vitesseMax] self.limitsAll={"T14":[[-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.671951770782 , 0.514872133732 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.314159274101 , 1.32645022869 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-1.54461634159 , -0.0349065847695 , 7.19407272339 , 1.20000004768 ], [-1.82386910915 , 1.82386910915 , 24.6229305267 , 0.759999990463 ], [0.0 , 1.0 , 8.32999992371 , 0.550000011921 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [1.32645022869, -0.314159274101 , 7.19407272339 , 1.20000004768 ], [2.08566856384 , -2.08566856384 , 8.26797389984 , 1.20000004768 ], [ -0.0349065847695, -1.54461634159 , 7.19407272339 , 1.20000004768 ], [1.82386910915 , -1.82386910915 , 24.6229305267 , 0.759999990463 ], [0.0 , 1.0 , 8.32999992371 , 0.550000011921 ]], "H21":[[-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-0.6719517707824707, 0.514872133731842, 7.194072723388672, 1.2000000476837158], [-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-0.3141592741012573, 1.326450228691101, 7.194072723388672, 1.2000000476837158], [-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-1.5446163415908813, -0.03490658476948738, 7.194072723388672, 1.2000000476837158], [-1.1452850103378296, 0.7407177090644836, 4.161737442016602, 3.200000047683716], [-0.37943458557128906, 0.7904596328735352, 4.161737442016602, 3.200000047683716], [-1.535889744758606, 0.4839797914028168, 6.40239143371582, 3.200000047683716], [-0.09232791513204575, 2.112546443939209, 6.40239143371582, 3.200000047683716], [-1.1894419193267822, 0.9225810170173645, 6.40239143371582, 3.200000047683716], [-0.3977605402469635, 0.7689920663833618, 4.161737442016602, 3.200000047683716], [-1.1452850103378296, 0.7407177090644836, 4.161737442016602, 3.200000047683716], [-0.37943458557128906, 0.7904596328735352, 4.161737442016602, 3.200000047683716], [-1.535889744758606, 0.4839797914028168, 6.40239143371582, 3.200000047683716], [-0.09232791513204575, 2.112546443939209, 6.40239143371582, 3.200000047683716], [-1.1894419193267822, 0.9225810170173645, 6.40239143371582, 3.200000047683716], [-0.3977605402469635, 0.7689920663833618, 4.161737442016602, 3.200000047683716], [-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-0.3141592741012573, 1.326450228691101, 7.194072723388672, 1.2000000476837158], [-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-1.5446163415908813, -0.03490658476948738, 7.194072723388672, 1.2000000476837158]], #not tested "H25":[[-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.671951770782 , 0.514872133732 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.314159274101 , 1.32645022869 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-1.54461634159 , -0.0349065847695 , 7.19407272339 , 1.20000004768 ], [-1.82386910915 , 1.82386910915 , 24.6229305267 , 0.759999990463 ], [0.0 , 1.0 , 8.32999992371 , 0.550000011921 ], [-1.1452850103378296, 0.7407177090644836, 4.161737442016602, 3.200000047683716], [-0.37943458557128906, 0.7904596328735352, 4.161737442016602, 3.200000047683716], [-1.535889744758606, 0.4839797914028168, 6.40239143371582, 3.200000047683716], [-0.09232791513204575, 2.112546443939209, 6.40239143371582, 3.200000047683716], [-1.1894419193267822, 0.9225810170173645, 6.40239143371582, 3.200000047683716], [-0.3977605402469635, 0.7689920663833618, 4.161737442016602, 3.200000047683716], [-1.1452850103378296, 0.7407177090644836, 4.161737442016602, 3.200000047683716], [-0.37943458557128906, 0.7904596328735352, 4.161737442016602, 3.200000047683716], [-1.535889744758606, 0.4839797914028168, 6.40239143371582, 3.200000047683716], [-0.09232791513204575, 2.112546443939209, 6.40239143371582, 3.200000047683716], [-1.1894419193267822, 0.9225810170173645, 6.40239143371582, 3.200000047683716], [-0.3977605402469635, 0.7689920663833618, 4.161737442016602, 3.200000047683716], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.314159274101 , 1.32645022869 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-1.54461634159 , -0.0349065847695 , 7.19407272339 , 1.20000004768 ], [-1.82386910915 , 1.82386910915 , 24.6229305267 , 0.759999990463 ], [0.0 , 1.0 , 8.32999992371 , 0.550000011921 ]] } self.ledMnM={'RightFaceLed8':"eye1D", 'RightFaceLed7':"eye2D", 'RightFaceLed6':"eye3D", 'RightFaceLed5':"eye4D", 'RightFaceLed4':"eye5D", 'RightFaceLed3':"eye6D", 'RightFaceLed2':"eye7D", 'RightFaceLed1':"eye8D", 'LeftFaceLed8':"eye8G", 'LeftFaceLed7':"eye7G", 'LeftFaceLed6':"eye6G", 'LeftFaceLed5':"eye5G", 'LeftFaceLed4':"eye4G", 'LeftFaceLed3':"eye3G", 'LeftFaceLed2':"eye2G", 'LeftFaceLed1':"eye1G" } self.ledIntensities={'RightFaceLed1':[.0,.0,.0], 'RightFaceLed2':[.0,.0,.0], 'RightFaceLed3':[.0,.0,.0], 'RightFaceLed4':[.0,.0,.0], 'RightFaceLed5':[.0,.0,.0], 'RightFaceLed6':[.0,.0,.0], 'RightFaceLed7':[.0,.0,.0], 'RightFaceLed8':[.0,.0,.0], 'LeftFaceLed8':[.0,.0,.0], 'LeftFaceLed7':[.0,.0,.0], 'LeftFaceLed6':[.0,.0,.0], 'LeftFaceLed5':[.0,.0,.0], 'LeftFaceLed4':[.0,.0,.0], 'LeftFaceLed3':[.0,.0,.0], 'LeftFaceLed2':[.0,.0,.0], 'LeftFaceLed1':[.0,.0,.0]} self.ledColors={'RightFaceLed1': ['Face/Led/Red/Right/0Deg/Actuator/Value', 'Face/Led/Green/Right/0Deg/Actuator/Value', 'Face/Led/Blue/Right/0Deg/Actuator/Value'], 'RightFaceLed3': ['Face/Led/Red/Right/90Deg/Actuator/Value', 'Face/Led/Green/Right/90Deg/Actuator/Value', 'Face/Led/Blue/Right/90Deg/Actuator/Value'], 'RightFaceLed2': ['Face/Led/Red/Right/45Deg/Actuator/Value', 'Face/Led/Green/Right/45Deg/Actuator/Value', 'Face/Led/Blue/Right/45Deg/Actuator/Value'], 'RightFaceLed5': ['Face/Led/Red/Right/180Deg/Actuator/Value', 'Face/Led/Green/Right/180Deg/Actuator/Value', 'Face/Led/Blue/Right/180Deg/Actuator/Value'], 'RightFaceLed4': ['Face/Led/Red/Right/135Deg/Actuator/Value', 'Face/Led/Green/Right/135Deg/Actuator/Value', 'Face/Led/Blue/Right/135Deg/Actuator/Value'], 'RightFaceLed7': ['Face/Led/Red/Right/270Deg/Actuator/Value', 'Face/Led/Green/Right/270Deg/Actuator/Value', 'Face/Led/Blue/Right/270Deg/Actuator/Value'], 'RightFaceLed6': ['Face/Led/Red/Right/225Deg/Actuator/Value', 'Face/Led/Green/Right/225Deg/Actuator/Value', 'Face/Led/Blue/Right/225Deg/Actuator/Value'], 'RightFaceLed8': ['Face/Led/Red/Right/315Deg/Actuator/Value', 'Face/Led/Green/Right/315Deg/Actuator/Value', 'Face/Led/Blue/Right/315Deg/Actuator/Value'], 'LeftFaceLed1': ['Face/Led/Red/Left/0Deg/Actuator/Value', 'Face/Led/Green/Left/0Deg/Actuator/Value', 'Face/Led/Blue/Left/0Deg/Actuator/Value'], 'LeftFaceLed3': ['Face/Led/Red/Left/90Deg/Actuator/Value', 'Face/Led/Green/Left/90Deg/Actuator/Value', 'Face/Led/Blue/Left/90Deg/Actuator/Value'], 'LeftFaceLed2': ['Face/Led/Red/Left/45Deg/Actuator/Value', 'Face/Led/Green/Left/45Deg/Actuator/Value', 'Face/Led/Blue/Left/45Deg/Actuator/Value'], 'LeftFaceLed5': ['Face/Led/Red/Left/180Deg/Actuator/Value', 'Face/Led/Green/Left/180Deg/Actuator/Value', 'Face/Led/Blue/Left/180Deg/Actuator/Value'], 'LeftFaceLed4': ['Face/Led/Red/Left/135Deg/Actuator/Value', 'Face/Led/Green/Left/135Deg/Actuator/Value', 'Face/Led/Blue/Left/135Deg/Actuator/Value'], 'LeftFaceLed7': ['Face/Led/Red/Left/270Deg/Actuator/Value', 'Face/Led/Green/Left/270Deg/Actuator/Value', 'Face/Led/Blue/Left/270Deg/Actuator/Value'], 'LeftFaceLed6': ['Face/Led/Red/Left/225Deg/Actuator/Value', 'Face/Led/Green/Left/225Deg/Actuator/Value', 'Face/Led/Blue/Left/225Deg/Actuator/Value'], 'LeftFaceLed8': ['Face/Led/Red/Left/315Deg/Actuator/Value', 'Face/Led/Green/Left/315Deg/Actuator/Value', 'Face/Led/Blue/Left/315Deg/Actuator/Value']} self.language="french" self.volume=0 self.listLimits={"Body":[]} self.animation = Animation()
class LedsActuator: def __init__(self, proxy): assert proxy.__class__ is ALProxy; self.__proxy = proxy; self.__ledsNames, self.__colorsNames = self.__getLedsNames(); self.__animation = Animation(); self.__parallelism = False; def setParallelism(self, value): self.__parallelism = value; #test OK def getLedsNames(self): return self.__ledsNames; #test OK def __getLedsNames(self): names = []; colorsNames = {}; for i in range(1,9): name = "RightFaceLed%s" %(i); names.append(name); degree = (i-1)*45; red = "Face/Led/Red/Right/%sDeg/Actuator/Value" %(degree); green = "Face/Led/Green/Right/%sDeg/Actuator/Value" %(degree); blue = "Face/Led/Blue/Right/%sDeg/Actuator/Value" %(degree); tab = [red,green,blue]; colorsNames[name] = tab; for i in range(8,0,-1): name = "LeftFaceLed%s" %(i); names.append(name); degree = (i-1)*45; red = "Face/Led/Red/Left/%sDeg/Actuator/Value" %(degree); green = "Face/Led/Green/Left/%sDeg/Actuator/Value" %(degree); blue = "Face/Led/Blue/Left/%sDeg/Actuator/Value" %(degree); tab = [red,green,blue]; colorsNames[name] = tab; return names, colorsNames; #test OK def getLedName(self, ledsNumber): assert ledsNumber < len(self.__ledsNames); return self.__ledsNames[ledsNumber]; #test OK def getLedsNumber(self): return len(self.__ledsNames); #test OK def allLedsOn(self): name = "FaceLeds"; self.__proxy.on(name); #test OK def rightLedsOn(self): name = "RightFaceLeds"; self.__proxy.on(name); #test OK def leftLedsOn(self): name = "LeftFaceLeds"; self.__proxy.on(name); #test OK def allLedsOff(self): name = "FaceLeds"; self.__proxy.off(name); #test OK def rightLedsOff(self): name = "RightFaceLeds"; self.__proxy.off(name); #test OK def leftLedsOff(self): name = "LeftFaceLeds"; self.__proxy.off(name); #test OK def getIntensity(self, ledNumber): name = self.getLedName(ledNumber); return self.__proxy.getIntensity(name); #test OK #renvoie red, green, blue def getColor(self, ledNumber): red, green, blue = 0,0,0; name = self.getLedName(ledNumber); tabColor = self.__colorsNames[name]; #print(self.__colorsNames) redIntensity = self.__proxy.getIntensity(tabColor[0]); greenIntensity = self.__proxy.getIntensity(tabColor[1]); blueIntensity = self.__proxy.getIntensity(tabColor[2]); red = int(redIntensity*255); green = int(greenIntensity*255); blue = int(blueIntensity*255); return red, green, blue; #test OK def setIntensity(self, ledNumber, intensity): name = self.getLedName(ledNumber); self.__proxy.setIntensity(name, intensity); #test OK def setIntensities(self, ledNumber, redIntensity, greenIntensity, blueIntensity): name = self.getLedName(ledNumber); tabColor = self.__colorsNames[name]; self.__proxy.setIntensity(tabColor[0], redIntensity); self.__proxy.setIntensity(tabColor[1], greenIntensity); self.__proxy.setIntensity(tabColor[2], blueIntensity); #test OK def fadeIntensity(self, ledsNumber, intensity, duration): name = self.getLedName(ledsNumber); self.__proxy.fade(name, intensity, duration); #test OK def setColor(self, ledsNumber, red, green, blue): name = self.getLedName(ledsNumber); self.__setColor(name, red, green, blue); #test OK def __setColor(self, ledName, red, green, blue): assert type(red) is int; assert type(green) is int; assert type(blue) is int; assert red >= 0 and red <= 255; assert green >= 0 and green <= 255; assert blue >= 0 and blue <= 255; tabColor = self.__colorsNames[ledName]; redIntensity = 0; greenIntensity = 0; blueIntensity = 0; if red != 0 : redIntensity = red/255.0; if green != 0 : greenIntensity = green/255.0; if blue != 0 : blueIntensity = blue/255.0; ## print(tabColor) ## print("ok") ## print(self.__colorsNames) self.__proxy.setIntensity(tabColor[0], redIntensity); self.__proxy.setIntensity(tabColor[1], greenIntensity); self.__proxy.setIntensity(tabColor[2], blueIntensity); #test OK def fadeColor(self, ledNumber, red, green, blue, duration): name = self.getLedName(ledNumber); color = self.__RGBToInt(red, green, blue); self.__proxy.fadeRGB (name, color, duration); #test OK def addLedAnimation(self, ledNumber, red, green, blue, time): name = self.getLedName(ledNumber); rgb = self.__RGBToInt(red, green, blue); self.__animation.addValue(name, rgb, time); #test OK def resetAnimation(self): self.__animation.reset(); #test OK def playAnimation(self): names = self.__animation.getNames(); values = self.__animation.getValues(); times = self.__animation.getTimes(); threads = []; i = 0; for name in names : valuesTab = values[i]; timesTab = times[i]; thread = threading.Thread(None, self.__playLedAnimation, None, (name, valuesTab, timesTab), {}); threads.append(thread); i=i+1; for thread in threads: thread.start(); #test OK def __playLedAnimation(self, name, values, times): assert len(values) == len(times); durations = self.__getDurations(times); for i in range(len(times)): duration = durations[i]; color = values[i]; time.sleep(duration); red,green,blue = self.__intToRGB(color); self.__setColor(name, red, green, blue); #test OK def __getDurations(self, timesTab): durationTab = []; previousTime = -1; if len(timesTab)>0: previousTime = timesTab[0]; durationTab.append(previousTime); for i in range(1, len(timesTab)): currentTime = timesTab[i]; if currentTime <= previousTime : string = "Times must be inscreasing at index %s : %s" %(i, timesTab[i]) raise Exception("TimeError", string); else: duration = currentTime - previousTime; previousTime = currentTime; durationTab.append(duration); return durationTab; #test OK def displayLedsNumber(self, ledsWord): for i in range(len(self.__ledsNames)): print(ledsWord,i, ":", self.__ledsNames[i]); #test OK def displayAnimation(self, ledWord, valueWord, timeWord, characterNumbers): names = self.__animation.getNames(); values = self.__animation.getValues(); times = self.__animation.getTimes(); for i in range(len(names)): ledNumber = self.__ledsNames.index(names[i]); print(ledWord,ledNumber," : "); for j in range(len(values[i])): string = " %s : %s" %(valueWord, hex(values[i][j])); string = self.addSpaces(string, characterNumbers); print(string,"-",timeWord,":",times[i][j]); #test OK #doublon !!!! def addSpaces(self, string, characterTotalNumbers): characterNumbers = len(string); if characterTotalNumbers > characterNumbers: spaceNumbers = characterTotalNumbers - characterNumbers; string = string+spaceNumbers*' '; return string; #test OK def __displayColorsNames(self): for name in self.__ledsNames: print(name,' :'); tab = self.__colorsNames[name]; print(" ",tab[0]); print(" ",tab[1]); print(" ",tab[2]); #test OK def __RGBToInt(self, red, green, blue): assert type(red) is int; assert type(green) is int; assert type(blue) is int; assert red >= 0 and red <= 255; assert green >= 0 and green <= 255; assert blue >= 0 and blue <= 255; color = int('%02x%02x%02x' %(red, green, blue), 16); #to check #print(hex(color)); return color; #test OK def __intToRGB(self, rgb): blue, green, red = [(rgb >> (8*i)) & 255 for i in range(3)]; return red,green,blue; def test(self): rgb = self.__RGBToInt(85,127,12); print(self.__intToRGB(rgb));
class Player(Dancer): xspeed = 0 yspeed = 0 leftpresstime = 0 rightpresstime = 0 uppresstime = 0 downpresstime = 0 normal_width = 10 normal_height = 10 xpos = 0 ypos = 0 lastxupdate = 0 lastyupdate = 0 storyprogress = 1 #animation left_animation = Animation([ GR["honeyside3"], GR["honeyside4"], GR["honeyside3"], GR["honeyside4"] ], 200) right_animation = Animation([ GR["honeyside0"], GR["honeyside1"], GR["honeyside0"], GR["honeyside2"] ], 200) down_animation = Animation([ GR["honeyback3"], GR["honeyback4"], GR["honeyback3"], GR["honeyback5"] ], 200) up_animation = Animation([ GR["honeyback0"], GR["honeyback1"], GR["honeyback0"], GR["honeyback2"] ], 200) current_animation = left_animation def teleport(self, x, y): self.xpos = x self.ypos = y def draw(self ): #movement is combination of top down scrolling and free range m = maps.current_map mw = m.finalimage.get_width() mh = m.finalimage.get_height() if self.xpos >= variables.hh and self.xpos <= ( mw - variables.hh): #If in scrolling area drawx = variables.hh #middle of screen elif self.xpos > (mw - variables.hh): #if on right side drawx = self.xpos - (mw - variables.height ) #normal x pos adjusted for scrolling area else: drawx = self.xpos #otherwise make the coordinates normal if self.ypos >= variables.hh and self.ypos <= ( mh - variables.hh): #same logic for y pos drawy = variables.hh elif self.ypos > (mh - variables.hh): drawy = self.ypos - ( mh - variables.height ) #mh - variables.height is the height of the scrolling area else: drawy = self.ypos self.current_pic_scaled() variables.screen.blit(self.current_display, [drawx, drawy]) def change_animation(self): if self.xspeed == 0: if self.yspeed < 0: self.current_animation = self.up_animation elif self.yspeed > 0: self.current_animation = self.down_animation elif self.xspeed < 0: self.current_animation = self.left_animation elif self.xspeed > 0: self.current_animation = self.right_animation self.current_animation.reset() def keypress(self, k): self.move() t = variables.current_time s = variables.playerspeed * variables.scaleoffset if k == pygame.K_LEFT or k == pygame.K_a: self.leftpresstime = variables.current_time self.xspeed = -s self.lastxupdate = t if k == pygame.K_RIGHT or k == pygame.K_d: self.rightpresstime = variables.current_time self.lastxupdate = t self.xspeed = s if k == pygame.K_UP or k == pygame.K_w: self.uppresstime = variables.current_time self.yspeed = -s self.lastyupdate = t if k == pygame.K_DOWN or k == pygame.K_s: self.downpresstime = variables.current_time self.yspeed = s self.lastyupdate = t self.change_animation() def keyrelease(self, k): self.move() s = variables.playerspeed * variables.scaleoffset t = variables.current_time if k == pygame.K_LEFT or k == pygame.K_a: self.leftpresstime = 0 self.lastxupdate = t if self.rightpresstime == 0: self.xspeed = 0 else: self.xspeed = s elif k == pygame.K_RIGHT or k == pygame.K_d: self.rightpresstime = 0 self.lastxupdate = t if self.leftpresstime == 0: self.xspeed = 0 else: self.xspeed = -s elif k == pygame.K_UP or k == pygame.K_w: self.lastyupdate = t self.uppresstime = 0 if self.downpresstime == 0: self.yspeed = 0 else: self.yspeed = s elif k == pygame.K_DOWN or k == pygame.K_s: self.lastyupdate = t self.downpresstime = 0 if self.uppresstime == 0: self.yspeed = 0 else: self.yspeed = -s self.change_animation() #moves with collision detection def move(self): t = variables.current_time #calculate moved positions xtime_factor = t - self.lastxupdate ytime_factor = t - self.lastyupdate movedxpos = self.xpos + self.xspeed * xtime_factor movedypos = self.ypos + self.yspeed * ytime_factor #collision detection iscollisionx = False iscollisiony = False m = maps.current_map t = m.terrain colliderects = m.colliderects numofrocks = len(t) #checks if the player collides with a rock def collisioncheck(arock, x, y): if (arock.iscollideable): if (arock.mask.overlap( self.mask, [int(x - arock.collidex), int(y - arock.collidey)]) == None): return False else: return True else: return False #return arock.iscollideable and (x+self.normal_width)>=arock.collidex and x<=(arock.collidex + arock.collidew) \ # and (y+self.normal_height)>=arock.collidey and y<=(arock.collidey + arock.collideh) if not self.xspeed == 0: #first check for edges of map if movedxpos < 0: self.xpos = 0 iscollisionx = True elif movedxpos + self.normal_width > m.finalimage.get_width(): self.xpos = m.finalimage.get_width() - self.normal_width iscollisionx = True else: #collision detection for the moved x pos with the unmoved y pos for x in range(0, len(colliderects)): playerR = Rect(movedxpos, self.ypos, self.normal_width, self.normal_height) if (playerR.colliderect(colliderects[x]) == 1): iscollisionx = True break for x in range(0, numofrocks): r = t[x] if collisioncheck(r, movedxpos, self.ypos): iscollisionx = True break if not self.yspeed == 0: if movedypos < 0: self.ypos = 0 iscollisiony = True elif movedypos + self.normal_height > m.finalimage.get_height(): self.ypos = m.finalimage.get_height() - self.normal_height iscollisiony = True else: #collision detection for the moved y pos with the unmoved x pos for x in range(0, len(colliderects)): playerR = Rect(self.xpos, movedypos, self.normal_width, self.normal_height) if (playerR.colliderect(colliderects[x]) == 1): iscollisiony = True break for x in range(0, numofrocks): r = t[x] if collisioncheck(r, self.xpos, movedypos): iscollisiony = True break if not iscollisionx: self.xpos = movedxpos if not iscollisiony: self.ypos = movedypos self.lastxupdate = variables.current_time self.lastyupdate = variables.current_time def current_pic_scaled(self): #returns the current pic to display if self.leftpresstime == 0 and self.rightpresstime == 0 and \ self.uppresstime == 0 and self.downpresstime == 0: c = self.current_animation.pics[0] else: c = self.current_animation.current_frame() c = pygame.transform.scale(c["img"], [ int(c["w"] * variables.scaleoffset), int(c["h"] * variables.scaleoffset) ]) self.current_display = c def scale_by_offset(self): self.current_pic_scaled() self.mask = pygame.mask.from_surface(self.current_display) self.normal_width = self.current_display.get_width() self.normal_height = self.current_display.get_height() s = variables.playerspeed * variables.scaleoffset if (self.xspeed > 0): self.xspeed = s if (self.xspeed < 0): self.xspeed = -s if (self.yspeed < 0): self.yspeed = -s if (self.yspeed > 0): self.yspeed = s def ismoving(self): return not (self.xspeed == 0 and self.yspeed == 0) def heal(self): self.health = stathandeling.max_health(self.lv) def change_of_state(self): self.downpresstime = 0 self.uppresstime = 0 self.leftpresstime = 0 self.rightpresstime = 0 self.xspeed = 0 self.yspeed = 0
class ALProxy(): # staticNao = NaoCommunicationVirtual.AbstractNaoEvenement # (remplace les fonctions du robot réel pour les events) staticNao=None # virtualNao = Nao3D # (remplace les membres du robot réel) virtualNao=None vocabList = [] typeRobot="T14" membres={0:"HeadYaw",1:"HeadPitch", 2:"LShoulderPitch",3:"LShoulderRoll",4:"LElbowYaw",5:"LElbowRoll",6:"LWristYaw",7:"LHand", 8:"RShoulderPitch",9:"RShoulderRoll",10:"RElbowYaw",11:"RElbowRoll",12:"RWristYaw",13:"RHand"} membresVirtual={0:"teteG2", 1:"teteG0",#ok 2:"bicepsG0",3:"bicepsG2",4:"coudeG1",5:"coudeG2",6:"mainG1",7:"doigt1G0",#ok 8:"bicepsD0",9:"bicepsD2",10:"coudeD1",11:"coudeD2",12:"mainD1",13:"doigt1D0"#ok } jointsAll={"T14":["HeadYaw", "HeadPitch", "LShoulderPitch", "LShoulderRoll", "LElbowYaw", "LElbowRoll", "LWristYaw", "LHand", "RShoulderPitch", "RShoulderRoll", "RElbowYaw", "RElbowRoll", "RWristYaw", "RHand"], "H21":['HeadYaw', 'HeadPitch', 'LShoulderPitch', 'LShoulderRoll', 'LElbowYaw', 'LElbowRoll', 'LHipYawPitch', 'LHipRoll', 'LHipPitch', 'LKneePitch', 'LAnklePitch', 'LAnkleRoll', 'RHipYawPitch', 'RHipRoll', 'RHipPitch', 'RKneePitch', 'RAnklePitch', 'RAnkleRoll', 'RShoulderPitch', 'RShoulderRoll', 'RElbowYaw', 'RElbowRoll'], #not tested, may not work : "H25":['HeadYaw', 'HeadPitch', 'LShoulderPitch', 'LShoulderRoll', 'LElbowYaw', 'LElbowRoll', "LWristYaw", "LHand", 'LHipYawPitch', 'LHipRoll', 'LHipPitch', 'LKneePitch', 'LAnklePitch', 'LAnkleRoll', 'RHipYawPitch', 'RHipRoll', 'RHipPitch', 'RKneePitch', 'RAnklePitch', 'RAnkleRoll', 'RShoulderPitch', 'RShoulderRoll', 'RElbowYaw', 'RElbowRoll',"RWristYaw", "RHand"] } parallelism = False; def __init__(self,name=0,adress=0,port=0): self.name=name self.membre=None # Différence par rapport à naoqi : # Dans l'interface OpenGL, les rotations des membres droits sont inversé par la symétrie # Donc en fait les angles pour la partie gauche et la partie droite sont les memes # alors que dans naoqi, les parties droite et gauche sont gérées indépendemment # Solution : # Après copie de la liste renvoyée par le naoqi réel, # on copie tous les éléments de la partie gauche pour les coller et remplacer ceux de # la partie droite. # Données : [angleMin, angleMax, vitesseMin, vitesseMax] self.limitsAll={"T14":[[-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.671951770782 , 0.514872133732 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.314159274101 , 1.32645022869 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-1.54461634159 , -0.0349065847695 , 7.19407272339 , 1.20000004768 ], [-1.82386910915 , 1.82386910915 , 24.6229305267 , 0.759999990463 ], [0.0 , 1.0 , 8.32999992371 , 0.550000011921 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [1.32645022869, -0.314159274101 , 7.19407272339 , 1.20000004768 ], [2.08566856384 , -2.08566856384 , 8.26797389984 , 1.20000004768 ], [ -0.0349065847695, -1.54461634159 , 7.19407272339 , 1.20000004768 ], [1.82386910915 , -1.82386910915 , 24.6229305267 , 0.759999990463 ], [0.0 , 1.0 , 8.32999992371 , 0.550000011921 ]], "H21":[[-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-0.6719517707824707, 0.514872133731842, 7.194072723388672, 1.2000000476837158], [-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-0.3141592741012573, 1.326450228691101, 7.194072723388672, 1.2000000476837158], [-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-1.5446163415908813, -0.03490658476948738, 7.194072723388672, 1.2000000476837158], [-1.1452850103378296, 0.7407177090644836, 4.161737442016602, 3.200000047683716], [-0.37943458557128906, 0.7904596328735352, 4.161737442016602, 3.200000047683716], [-1.535889744758606, 0.4839797914028168, 6.40239143371582, 3.200000047683716], [-0.09232791513204575, 2.112546443939209, 6.40239143371582, 3.200000047683716], [-1.1894419193267822, 0.9225810170173645, 6.40239143371582, 3.200000047683716], [-0.3977605402469635, 0.7689920663833618, 4.161737442016602, 3.200000047683716], [-1.1452850103378296, 0.7407177090644836, 4.161737442016602, 3.200000047683716], [-0.37943458557128906, 0.7904596328735352, 4.161737442016602, 3.200000047683716], [-1.535889744758606, 0.4839797914028168, 6.40239143371582, 3.200000047683716], [-0.09232791513204575, 2.112546443939209, 6.40239143371582, 3.200000047683716], [-1.1894419193267822, 0.9225810170173645, 6.40239143371582, 3.200000047683716], [-0.3977605402469635, 0.7689920663833618, 4.161737442016602, 3.200000047683716], [-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-0.3141592741012573, 1.326450228691101, 7.194072723388672, 1.2000000476837158], [-2.0856685638427734, 2.0856685638427734, 8.267973899841309, 1.2000000476837158], [-1.5446163415908813, -0.03490658476948738, 7.194072723388672, 1.2000000476837158]], #not tested "H25":[[-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.671951770782 , 0.514872133732 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.314159274101 , 1.32645022869 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-1.54461634159 , -0.0349065847695 , 7.19407272339 , 1.20000004768 ], [-1.82386910915 , 1.82386910915 , 24.6229305267 , 0.759999990463 ], [0.0 , 1.0 , 8.32999992371 , 0.550000011921 ], [-1.1452850103378296, 0.7407177090644836, 4.161737442016602, 3.200000047683716], [-0.37943458557128906, 0.7904596328735352, 4.161737442016602, 3.200000047683716], [-1.535889744758606, 0.4839797914028168, 6.40239143371582, 3.200000047683716], [-0.09232791513204575, 2.112546443939209, 6.40239143371582, 3.200000047683716], [-1.1894419193267822, 0.9225810170173645, 6.40239143371582, 3.200000047683716], [-0.3977605402469635, 0.7689920663833618, 4.161737442016602, 3.200000047683716], [-1.1452850103378296, 0.7407177090644836, 4.161737442016602, 3.200000047683716], [-0.37943458557128906, 0.7904596328735352, 4.161737442016602, 3.200000047683716], [-1.535889744758606, 0.4839797914028168, 6.40239143371582, 3.200000047683716], [-0.09232791513204575, 2.112546443939209, 6.40239143371582, 3.200000047683716], [-1.1894419193267822, 0.9225810170173645, 6.40239143371582, 3.200000047683716], [-0.3977605402469635, 0.7689920663833618, 4.161737442016602, 3.200000047683716], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-0.314159274101 , 1.32645022869 , 7.19407272339 , 1.20000004768 ], [-2.08566856384 , 2.08566856384 , 8.26797389984 , 1.20000004768 ], [-1.54461634159 , -0.0349065847695 , 7.19407272339 , 1.20000004768 ], [-1.82386910915 , 1.82386910915 , 24.6229305267 , 0.759999990463 ], [0.0 , 1.0 , 8.32999992371 , 0.550000011921 ]] } self.ledMnM={'RightFaceLed8':"eye1D", 'RightFaceLed7':"eye2D", 'RightFaceLed6':"eye3D", 'RightFaceLed5':"eye4D", 'RightFaceLed4':"eye5D", 'RightFaceLed3':"eye6D", 'RightFaceLed2':"eye7D", 'RightFaceLed1':"eye8D", 'LeftFaceLed8':"eye8G", 'LeftFaceLed7':"eye7G", 'LeftFaceLed6':"eye6G", 'LeftFaceLed5':"eye5G", 'LeftFaceLed4':"eye4G", 'LeftFaceLed3':"eye3G", 'LeftFaceLed2':"eye2G", 'LeftFaceLed1':"eye1G" } self.ledIntensities={'RightFaceLed1':[.0,.0,.0], 'RightFaceLed2':[.0,.0,.0], 'RightFaceLed3':[.0,.0,.0], 'RightFaceLed4':[.0,.0,.0], 'RightFaceLed5':[.0,.0,.0], 'RightFaceLed6':[.0,.0,.0], 'RightFaceLed7':[.0,.0,.0], 'RightFaceLed8':[.0,.0,.0], 'LeftFaceLed8':[.0,.0,.0], 'LeftFaceLed7':[.0,.0,.0], 'LeftFaceLed6':[.0,.0,.0], 'LeftFaceLed5':[.0,.0,.0], 'LeftFaceLed4':[.0,.0,.0], 'LeftFaceLed3':[.0,.0,.0], 'LeftFaceLed2':[.0,.0,.0], 'LeftFaceLed1':[.0,.0,.0]} self.ledColors={'RightFaceLed1': ['Face/Led/Red/Right/0Deg/Actuator/Value', 'Face/Led/Green/Right/0Deg/Actuator/Value', 'Face/Led/Blue/Right/0Deg/Actuator/Value'], 'RightFaceLed3': ['Face/Led/Red/Right/90Deg/Actuator/Value', 'Face/Led/Green/Right/90Deg/Actuator/Value', 'Face/Led/Blue/Right/90Deg/Actuator/Value'], 'RightFaceLed2': ['Face/Led/Red/Right/45Deg/Actuator/Value', 'Face/Led/Green/Right/45Deg/Actuator/Value', 'Face/Led/Blue/Right/45Deg/Actuator/Value'], 'RightFaceLed5': ['Face/Led/Red/Right/180Deg/Actuator/Value', 'Face/Led/Green/Right/180Deg/Actuator/Value', 'Face/Led/Blue/Right/180Deg/Actuator/Value'], 'RightFaceLed4': ['Face/Led/Red/Right/135Deg/Actuator/Value', 'Face/Led/Green/Right/135Deg/Actuator/Value', 'Face/Led/Blue/Right/135Deg/Actuator/Value'], 'RightFaceLed7': ['Face/Led/Red/Right/270Deg/Actuator/Value', 'Face/Led/Green/Right/270Deg/Actuator/Value', 'Face/Led/Blue/Right/270Deg/Actuator/Value'], 'RightFaceLed6': ['Face/Led/Red/Right/225Deg/Actuator/Value', 'Face/Led/Green/Right/225Deg/Actuator/Value', 'Face/Led/Blue/Right/225Deg/Actuator/Value'], 'RightFaceLed8': ['Face/Led/Red/Right/315Deg/Actuator/Value', 'Face/Led/Green/Right/315Deg/Actuator/Value', 'Face/Led/Blue/Right/315Deg/Actuator/Value'], 'LeftFaceLed1': ['Face/Led/Red/Left/0Deg/Actuator/Value', 'Face/Led/Green/Left/0Deg/Actuator/Value', 'Face/Led/Blue/Left/0Deg/Actuator/Value'], 'LeftFaceLed3': ['Face/Led/Red/Left/90Deg/Actuator/Value', 'Face/Led/Green/Left/90Deg/Actuator/Value', 'Face/Led/Blue/Left/90Deg/Actuator/Value'], 'LeftFaceLed2': ['Face/Led/Red/Left/45Deg/Actuator/Value', 'Face/Led/Green/Left/45Deg/Actuator/Value', 'Face/Led/Blue/Left/45Deg/Actuator/Value'], 'LeftFaceLed5': ['Face/Led/Red/Left/180Deg/Actuator/Value', 'Face/Led/Green/Left/180Deg/Actuator/Value', 'Face/Led/Blue/Left/180Deg/Actuator/Value'], 'LeftFaceLed4': ['Face/Led/Red/Left/135Deg/Actuator/Value', 'Face/Led/Green/Left/135Deg/Actuator/Value', 'Face/Led/Blue/Left/135Deg/Actuator/Value'], 'LeftFaceLed7': ['Face/Led/Red/Left/270Deg/Actuator/Value', 'Face/Led/Green/Left/270Deg/Actuator/Value', 'Face/Led/Blue/Left/270Deg/Actuator/Value'], 'LeftFaceLed6': ['Face/Led/Red/Left/225Deg/Actuator/Value', 'Face/Led/Green/Left/225Deg/Actuator/Value', 'Face/Led/Blue/Left/225Deg/Actuator/Value'], 'LeftFaceLed8': ['Face/Led/Red/Left/315Deg/Actuator/Value', 'Face/Led/Green/Left/315Deg/Actuator/Value', 'Face/Led/Blue/Left/315Deg/Actuator/Value']} self.language="french" self.volume=0 self.listLimits={"Body":[]} self.animation = Animation() #test ok @staticmethod def associateVirtualRobot(nao): ALProxy.virtualNao=nao @staticmethod def associateStaticNao(nao): ALProxy.staticNao=nao @staticmethod def getFunction(functionName): functionsByName={ "onWordRecognized":ALProxy.staticNao._wordRecognizedEvent, "onPictureDetected":ALProxy.staticNao._pictureDetectedEvent, "onFaceDetected":ALProxy.staticNao._faceDetectedEvent, "onTactileDetected":ALProxy.staticNao._tactileEvent, "onWordDetected":ALProxy.staticNao._speechDetectedEvent} return functionsByName[functionName] @staticmethod def eventCall(function, args): ##try: if function != "onWordDetected": ALProxy.getFunction(function)(*args) return 1 else : for mot in args[0].split(): if mot.strip() in ALProxy.vocabList : ALProxy.getFunction(function)() return 1 else : print(mot.strip()+" is not in Vocabulary list") ##except: ## print("Pas de AbstractNaoEvenement instancié") return 0 @staticmethod def setType(robot="T14"): ALProxy.typeRobot=robot #reconstruction des membres ALProxy.membres={} for a in range(len(ALProxy.jointsAll[robot])): ALProxy.membres[a]=ALProxy.jointsAll[robot][a] if robot=="T14": ALProxy.membresVirtual={0:"teteG2", 1:"teteG0",#ok 2:"bicepsG0", 3:"bicepsG2", 4:"coudeG1", 5:"coudeG2", 6:"mainG1", 7:"doigt1G0",#ok 8:"bicepsD0", 9:"bicepsD2", 10:"coudeD1", 11:"coudeD2", 12:"mainD1", 13:"doigt1D0"#ok } elif robot=="H21": ALProxy.membresVirtual={0:"teteG2", 1:"teteG0",#ok 2:"bicepsG0", 3:"bicepsG2", 4:"coudeG1", 5:"coudeG2",#ok 6:'hancheG1', 7:'cuisseG1', 8:'cuisseG0', 9:'molletG0', 10:'piedG0', 11:'piedG1', 12:'hancheD1', 13:'cuisseD1', 14:'cuisseD0', 15:'molletD0', 16:'piedD0', 17:'piedD1', 18:"bicepsD0", 19:"bicepsD2",20:"coudeD1",21:"coudeD2" } elif robot=="H25": ALProxy.membresVirtual={0:"teteG2", 1:"teteG0",#ok 2:"bicepsG0", 3:"bicepsG2", 4:"coudeG1", 5:"coudeG2", 6:"mainG1", 7:"doigt1G0", 8:'hancheG1', 9:'cuisseG1', 10:'cuisseG0', 11:'molletG0', 12:'piedG0', 13:'piedG1', 14:'hancheD1', 15:'cuisseD1', 16:'cuisseD0', 17:'molletD0', 18:'piedD0', 19:'piedD1', 20:"bicepsD0", 21:"bicepsD2", 22:"coudeD1", 23:"coudeD2", 24:"mainD1", 25:"doigt1D0" } @staticmethod def getKeys(): l = [] Virtual={0:"teteG2", 1:"teteG0",#ok 2:"bicepsG0", 3:"bicepsG2", 4:"coudeG1", 5:"coudeG2", 6:"mainG1", 7:"doigt1G0", 8:'hancheG1', 9:'cuisseG1', 10:'cuisseG0', 11:'molletG0', 12:'piedG0', 13:'piedG1', 14:'hancheD1', 15:'cuisseD1', 16:'cuisseD0', 17:'molletD0', 18:'piedD0', 19:'piedD1', 20:"bicepsD0", 21:"bicepsD2", 22:"coudeD1", 23:"coudeD2", 24:"mainD1", 25:"doigt1D0" } for a in range(len(Virtual)): l.append(Virtual[a]) return l @staticmethod def setParallelism(paral): ALProxy.parallelism = paral #test ok def setLanguage(self, language): self.language=language #test ok def getLanguage(self): return self.language #test ok def say(self, text): #print("NAO dit : "+str(text)) self.virtualNao.addSpeaking(text) if not ALProxy.parallelism: self.timePerCharacter=0.1 TimerT.sleep(len(text)*self.timePerCharacter) def setVolume(self, value): self.volume=value def getVolume(self): return self.volume #test ok def getJointNames(self, part="Body"): return self.jointsAll[self.typeRobot] #test ok def getLimits(self, part="Body"): return self.limitsAll[self.typeRobot] #test ok def getStiffnesses(self, part="Body"): r=[] for a in self.membres.keys(): num=self.getNumberFromName(a) nom=self.membresVirtual[num][:-1] r.append(self.virtualNao.getMembre(nom).stiffness) return r def getStiffness(self, numeroMoteur): print("not implemented") def setStiffnesses(self, part="Body", value=1): names=self.getNamesFromPart(part) for a in names: self.virtualNao.getMembre(a[:-1]).stiffness=value def setStiffness(self, numeroMoteur, taux): print("not implemented") def getAngles(self, part="Body", isStg=True): return [0,0,0,0] #a verifier def getMinAngle(self, numero): return self.limitsAll[self.typeRobot][0] #a verifier def getMaxAngle(self, numero): return self.limitsAll[self.typeRobot][1] def angleInterpolation(self, name, motorAngle, time, isAbsolute): num=self.getNumberFromName(name) nom=self.membresVirtual[num][:-1] n=int(self.membresVirtual[num][-1]) #print(self.virtualNao.getMembre(nom).rotate, nom) if nom[:5] == "doigt": self.virtualNao.getMembre("doigt3"+nom[-1]).setAngleFromPercent(0,100-motorAngle) self.virtualNao.getMembre("doigt2"+nom[-1]).setAngleFromPercent(0,100-motorAngle) self.virtualNao.getMembre("doigt1"+nom[-1]).setAngleFromPercent(0,100)#=fixe else : self.virtualNao.getMembre(nom).setAngle(n,motorAngle/3.14*180,time) if not ALProxy.parallelism: TimerT.sleep(time) def getAnimationData(self): names = self.animation.getNames() values = self.animation.getValues() times = self.animation.getTimes() return names, angles, times def addMotionAnimation(self, numeroMoteur, position, temps): self.animation.addValue(self.getNameFromNumber(numeroMoteur), position, temps); def resetAnimation(self): self.animation.reset(); #test OK def playAnimation(self): names = self.animation.getNames(); values = self.animation.getValues(); times = self.animation.getTimes(); threads = []; i = 0; for name in names : valuesTab = values[i]; timesTab = times[i]; thread = threading.Thread(None, self.__playMotorAnimation, None, (name, valuesTab, timesTab), {}); threads.append(thread); i=i+1; for thread in threads: thread.start(); #test OK def __playMotorAnimation(self, name, values, times): assert len(values) == len(times); durations = self.__getDurations(times); for i in range(len(times)): duration = durations[i]; motorAngle = values[i]; time.sleep(duration); self.angleInterpolation(name, motorAngle, duration, True); #test OK def __getDurations(self, timesTab): durationTab = []; previousTime = -1; if len(timesTab)>0: previousTime = timesTab[0]; durationTab.append(previousTime); for i in range(1, len(timesTab)): currentTime = timesTab[i]; if currentTime <= previousTime : string = "Times must be inscreasing at index %s : %s" %(i, timesTab[i]) raise Exception("TimeError", string); else: duration = currentTime - previousTime; previousTime = currentTime; durationTab.append(duration); return durationTab; def getNumberFromName(self, name): num=0 for x in self.membres: if name==self.membres[x]: return x print("error numberName") return num def getNameFromNumber(self, number): return self.membres[number] def getNamesFromPart(self, part): if part.lower()=="body": return self.membresVirtual.values() for x in self.membres.keys(): if self.membres[x]==part: return [self.membresVirtual[x]] print("error Names part", part) return [] def getAvailableLanguages(self): return ["fr"] ###############" LED def getListFromName(self, name): result=[] if name in self.ledMnM.keys(): return [self.ledMnM[name]] elif "Right" in name: for x in self.ledMnM.keys(): if "Right" in x: result.append(self.ledMnM[x]) elif "Left" in name: for x in self.ledMnM.keys(): if "Left" in x: result.append(self.ledMnM[x]) else:result=self.ledMnM.values() return result def getListNamesFromName(self, name): result=[] if name in self.ledMnM.keys(): return [name] elif "Right" in name: for x in self.ledMnM.keys(): if "Right" in x: result.append(x) elif "Left" in name: for x in self.ledMnM.keys(): if "Left" in x: result.append(x) else:result=self.ledMnM.values() return result def setIntensity(self, name, intensity): #print(intensity) if name in self.ledMnM.keys(): a=self.ledMnM[name] color=[intensity,intensity,intensity] self.ledIntensities[name]=color else: for b in self.ledColors.keys(): if name in self.ledColors[b]: #detection de la composante de couleur pos=self.ledColors[b].index(name) name=b a=self.ledMnM[b] self.ledIntensities[name][pos]=intensity break self.virtualNao.setEye(self.ledIntensities[name],a) def getIntensity(self,name): return self.ledIntensities[name] def on(self,name): a=self.getListFromName(name) self.virtualNao.setEyes(1,a) def off(self,name): a=self.getListFromName(name) self.virtualNao.setEyes(0,a) def fade(self,name, intensity, duration): pass def fadeRGB (self, name, color, duration): pass def setWordListAsVocabulary(self, vocabList): ALProxy.vocabList = vocabList def startSpeechRecognition(self): pass ### SOUND def playFile(self, fichier): self.virtualNao.addSinging(fichier,5) if not ALProxy.parallelism: self.timePerCharacter=1 TimerT.sleep(5) def stop(self): pass def playSine(self, frequence, gain, pan, duree): self.virtualNao.addSinging(" frequence : "+str(frequence), duree) if not ALProxy.parallelism: self.timePerCharacter=1 TimerT.sleep(duree)
# checked out the code and can't get the bloody thing to # work!) continue bonemap = Props.getanimbonemap(a) # FIXME: if action in props.whatever.don't-do-this: next putlog(NBLog.INFO, "Processing animation %s" % a) action = actions[a] ipos = action.getAllChannelIpos() putlog(NBLog.DEBUG, "BoneIpos: %s" % ipos.keys()) # NOTE: Channel names != bone names. F**k. anim = Animation() anim.setName(a) anim.setModelName(model) # Note: we're iterating Bones instead of Objects. # Thus, the goddamn Objects have to have same name as # their controlling Bones. (NOTE: this comment has no bearing # whatsoever to the reality. Reality is MUCH WORSE.) for boneipo in ipos: anode = AnimationNode() # The Theory: Now we're f*****g with the Ipo channel here. # We figure out what object the channel corresponds to. # (that seems to be the REALLY DAMN DIFFICULT part right now.) # Then, we just eval the ipo on keyframes OR at set intervals # (depending on what mode we're working on)