def testInvalidInput(self): fsm = FiniteStateMachine("0,1", "EVEN:pass,ODD:fail,BAD:fail", "EVEN:ODD:1,ODD:EVEN:1,ODD:BAD:0") didFail = False try: fsm.execute("00a10") except Exception: didFail = True pass assert didFail
def testBaseCase(self): fsm = FiniteStateMachine("0,1", "EVEN:pass,ODD:fail,BAD:fail", "EVEN:ODD:1,ODD:EVEN:1,ODD:BAD:0") assert fsm.execute("00110") == 'pass' fsm.reset() # put it back into initial state assert "fail" == fsm.execute("00111") fsm.reset() assert "fail" == fsm.execute("001110000110011") pass
def __init__(self, packet=None): super().__init__(packet) self.interact_label = 'Talk' self.health = 80 self.faction = -841 #self.localScale = self.localScale * (1+random.random*.3) self.update_time = time.time() + random.random() self.ticker = 1.0 self.ai_state = None self.alert_radius = 80 self.target_enemy = None self.alerted = False self.path = 0.0 self.speed = 5 # Animations self.animations = { 'walk': 0, 'run': 0, 'attack': 0, 'reload': 0, 'idle': 1, 'cround': 0 } # FSM States self.movement_state_machine = FiniteStateMachine(self) self.movement_state_machine.add_state('idle', self.handle_idle_state) self.movement_state_machine.add_state('walk', self.handle_walk_state) self.movement_state_machine.add_state('attack', self.handle_attack_state) self.movement_state_machine.add_state('dead', self.handle_dead_state) self.movement_state_machine.current_state = "idle" # FSM Transitions self.movement_state_machine.add_transition('idle', 'walk', self.is_alerted) self.movement_state_machine.add_transition_c('attack', 'walk', self.is_close) self.movement_state_machine.add_transition_u('dead', self.is_dead) # self.interact_label = "Morgoar" self.interact_icon = None
def _wrap(self, object): entities.EntityBase._wrap(self, object) # Spread self.ryn = random.randrange(-5, 5) self.rxn = random.randrange(-5, 5) # Children self.armature = [ child for child in self.childrenRecursive if 'Armature' in child ][0] self.aimer = [ child for child in self.childrenRecursive if 'aimer' in child ][0] self.bullet_spread = [ child for child in self.childrenRecursive if 'spread' in child ][0] self.weapon_pos = [ child for child in self.childrenRecursive if 'weapon_pos' in child ][0] self.head_track = [ child for child in self.childrenRecursive if 'head_track' in child ][0] # Inventory self.inventory = Inventory() self.inventory.replace_weapon("F2000") # Starting weapon self.inventory.primary_weapon.equip(self, weapon_type="3rd") # FSM self.ai_state_machine = FiniteStateMachine(self) self.ai_state_machine.add_state('idle', self.handle_idle) self.ai_state_machine.add_state('dead', self.handle_dead) self.ai_state_machine.add_state('attack', self.handle_attack) self.ai_state_machine.add_state('talk', self.handle_talk) #self.ai_state_machine.add_state('move', self.handle_move) #self.movement_state_machine.add_transition('attack', self.transition_to_attack) self.ai_state_machine.current_state = "idle" ### self._data['entity_base'] = self
class MachineRunner(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.machine = FiniteStateMachine() self._start_keyboard_listener() def run(self): self.machine.set_current_state(MachineCommand.START) data = self.machine.collect_data(size=SQUARE_ARRAY_LENGTH) print('Data collected!') processed_data = self.machine.process_data(data) print(processed_data) def _on_press(self, key): if key == keyboard.Key.enter: print(self.machine.get_current_state()) def _start_keyboard_listener(self): print('Press ENTER to get machine state') listener = keyboard.Listener(on_press=self._on_press) listener.daemon = True listener.start()
def _wrap(self, object1): entities.EntityBase._wrap(self, object1) ### self.ray_pos = [ child for child in self.childrenRecursive if 'ray' in child ][0] self.rotation_speed = 0.0 self.last_rotation = 0.0 self.rotation_difference = 0.0 ### Activate Vehicle Controls self.vehicle_on = False # HACK self._data['entity_base'] = self self.camera = [ child for child in self.childrenRecursive if 'vcam' in child ][0] for child in self.childrenRecursive: if 'remove' in child: child.removeParent() #pass ### FSM self.FSM = FiniteStateMachine(self) self.FSM.add_state('on', self.handle_on) self.FSM.add_state('off', self.handle_off) self.FSM.add_transition('off', 'on', self.is_active) self.FSM.current_state = 'off' ### BUILD VEHICLE self.assembleVehicle(self._data) self._data['build'] = True
class Player(entities.Actor): def __init__(self): print("player.__init__()") super().__init__() # Player Stats self.health = 100 self.faction = 0 # Default Faction = Player faction #self.name = 'player' self.hunger = 0.0 self.fatigue = 0.0 self.alert = 0 self.last_shot = 0.0 self.reloading = False self.reload_start_time = 0.0 self.roll = 0.0 self.walk_speed = 5.0 self.run_speed = 25.0 self.walk_temp = 0.0 self.last_move = 0.0 self.jump_speed = 10.0 # Stops mouse events from triggering for a frame # Used for when a UI screen is exited self.hold_mouse_update = False self.init_1 = False self.animations = { 'walk': 0, 'run': 0, 'attack': 0, 'reload': 0, 'idle': 1, 'cround': 0 } self.recoil_time = None self.recoiled = False self.bullets_auto = 10 self.bullets_shotgun = 10 self.bullets_pistol = 10 # Smooth Camera self.oldX = None # self.impants = [] self.stats = {'temp': 'temp'} # self.current_weapon = None # TODO - outdated reference, has this been moved to inventory? self.current_animations = { 'walk': None, 'run': None, 'reload': None, 'attack': None, 'switch': None, 'aim': None, } self.talking = False self.is_in_combat = False self.stored_state = None self.camera_on = True # Inventory self.inventory = Inventory() self.inventory.id = 'Player' # adding some items for testing: # TODO - remove self.inventory.add_item('cube', item_amount=9) self.inventory.add_item('wrench', item_amount=9) self.inventory.add_item('p90') # calculating this once for mouse move w = bge.render.getWindowWidth() h = bge.render.getWindowHeight() self.window_middle = [ int((w - int(w) % 2) / 2), int((h - int(h) % 2) / 2) ] def _wrap(self, object): entities.EntityBase._wrap(self, object) # Vehicle self.current_vehicle = None self.in_vehicle = False self.camera = [ child for child in self.children if 'camera_temp' in child ][0] self.lens = self.camera.lens self.armature = [ child for child in self.childrenRecursive if 'Armature' in child ][0] self.bullet_spread = [ child for child in self.childrenRecursive if 'spread' in child ][0] self.weapon_pos = [ child for child in self.childrenRecursive if 'weapon_pos' in child ][0] self.climb_ray = [ child for child in self.childrenRecursive if 'climb_ray' in child ][0] self.c_r_t = [ child for child in self.childrenRecursive if 'c_r_t' in child ][0] self.c_r_b = [ child for child in self.childrenRecursive if 'c_r_b' in child ][0] self.c_r_top = [ child for child in self.childrenRecursive if 'c_r_top' in child ][0] self.squad_position_R = [ child for child in self.childrenRecursive if 'squad_R' in child ][0] self.squad_position_L = [ child for child in self.childrenRecursive if 'squad_L' in child ][0] self.blood_effect = [ child for child in self.childrenRecursive if 'blood_effect' in child ][0] # FSM States self.movement_state_machine = FiniteStateMachine(self) self.movement_state_machine.add_state('walk', self.handle_walk_state) self.movement_state_machine.add_state('fall', self.handle_fall_state) self.movement_state_machine.add_state('vehicle', self.handle_vehicle_state) self.movement_state_machine.add_state('none', self.handle_none_state) # FSM Transitions self.movement_state_machine.add_transition('fall', 'walk', self.is_grounded) self.movement_state_machine.add_transition('walk', 'vehicle', self.is_in_vehicle) # HACKS self.temp_pos = 1 self.set_loc = [ child for child in self.childrenRecursive if 'set_loc' in child ][0] self.lev = None self.saved_armature_localPosition = self.armature.localPosition.copy() # WEAPON STARTING self.inventory.replace_weapon("F2000") self.inventory.primary_weapon.equip(self) # self._data['entity_base'] = self def _unwrap(self): entities.EntityBase._unwrap(self) def damage(self, amount, object=None): self.health += amount bge.logic.getCurrentScene().objects['FX']['hurt'] = 2.0 bge.logic.getCurrentScene().objects['FX']['hurt_s'] += 0.3 self.blood_effect['blood_effect'] = 1.0 print("HURT") def is_in_vehicle(self, FSM): return bool(self.in_vehicle) def handle_walk_state(self, FSM): keyboard = bge.logic.keyboard.events vel = self.getLinearVelocity() move = [0, 0, 0] ### Keys if keyboard[bge.events.LEFTSHIFTKEY]: # and self.fatigue < 10: self.fatigue += 0.2 speed = self.run_speed else: if self.fatigue > 0.0: self.fatigue += -0.2 speed = self.walk_speed if keyboard[bge.events.WKEY]: move[0] += speed if keyboard[bge.events.SKEY]: move[0] -= speed if keyboard[bge.events.AKEY]: move[1] -= speed if keyboard[bge.events.DKEY]: move[1] += speed ### Jump if keyboard[bge.events.SPACEKEY] == bge.logic.KX_INPUT_JUST_ACTIVATED: pos1 = [self.position[0], self.position[1], self.position[2] - 10] ray = self.rayCast(pos1, self.position, 2, '', 0, 0, 0) if ray[0] != None: move[2] = self.jump_speed self.walk_temp = 19 ### com = vel[2] + move[2] self.localLinearVelocity = Vector([move[1], move[0], com]) ### if move[0] != 0 or move[1] != 0: if speed == self.walk_speed: sudo.game.sound_manager.play_sound_on_frame( [5, 15], layer=2, armature=self.armature, sound_name=[ 'walk_grass_s_1.ogg', 'walk_grass_s_2.ogg', 'walk_grass_s_3.ogg', 'walk_grass_s_4.ogg' ], sound_object=None, play_type='play', use_3d=False, lowpass=False, obstructed_lowpass=True, alert_entities=True, volume=1.0) self.roll += 0.5 self.camera.applyRotation([ 0, math.sin(self.roll * 0.5) * 0.002, math.sin(self.roll * 0.5) * 0.003 ], 1) # Y self.camera.localPosition[2] += math.sin(self.roll) * 0.03 self.play_animation('walk') self.walk_temp += 1 elif speed == self.run_speed: self.roll += 0.75 self.camera.applyRotation([math.sin(self.roll) * 0.004, 0, 0], 1) # Y self.play_animation('run') self.walk_temp += 2 else: self.play_animation('idle') #pass if self.walk_temp > 20: self.walk_temp = 0 print("Play Sound") #session.game.sound_manager.play_sound('walk_grass_1.ogg', self) def update_path_follow(self): """ """ super().update_path_follow() self.play_animation('walk') ### ANIMATIONS ### def play_animation(self, name): self.animations[name] = 1 def stop_animation(self, layer): for n in range(0, 7): if n != layer: self.armature.stopAction(n) def handle_animations(self): weapon = self.inventory.primary_weapon if self.animations['reload'] == 1: self.armature.playAction(str(weapon.name) + "_reload", 1, 200, layer=4, priority=2, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_PLAY, speed=1.0) self.stop_animation(4) elif self.animations['attack'] == 1: if self.recoiled == False: x = random.uniform( self.inventory.primary_weapon.recoil_min_x, self.inventory.primary_weapon.recoil_max_x ) #random.randrange(self.inventory.primary_weapon.recoil_min_x,self.inventory.primary_weapon.recoil_max_x) y = random.uniform( self.inventory.primary_weapon.recoil_min_y, self.inventory.primary_weapon.recoil_max_y ) #random.randrange(self.inventory.primary_weapon.recoil_min_y,self.inventory.primary_weapon.recoil_max_y) z = 0 self.armature.localPosition = self.armature.localPosition + Vector( [y, x, z]) #self.camera.applyRotation([abs(y*3.0), 0, 0], 1) self.recoiled = True elif sudo.world.world_time - self.recoil_time < 5.0: print("Here!----------") self.armature.localPosition = self.armature.localPosition.lerp( self.saved_armature_localPosition, 0.25) else: print("Now here!!!!") self.armature.localPosition = self.saved_armature_localPosition self.animations['attack'] = 0 #self.armature.localPosition[1] += math.sin(sudo.world.world_time)*0.03 #self.armature.playAction("F2000_shoot", 4, 10, layer=3, priority=2, blendin=2, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) #self.stop_animation(3) #print("OH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") #frame = self.armature.getActionFrame(3) #if frame > 5: # self.animations['shoot'] = 0 elif self.animations['walk'] == 1: self.armature.playAction(str(weapon.name) + "_walk", 1, 21, layer=2, priority=2, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) self.stop_animation(2) elif self.animations['run'] == 1: self.armature.playAction(str(weapon.name) + "_run", 1, 17, layer=1, priority=3, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) self.stop_animation(1) else: self.stop_animation(0) self.armature.playAction(str(weapon.name) + "_idle", 1, 101, layer=0, priority=5, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) for name in self.animations: if name != "attack": self.animations[name] = 0 def handle_fall_state(self, FSM): pass def handle_vehicle_state(self, FSM): keyboard = bge.logic.keyboard bge.logic.getCurrentScene().active_camera = self.current_vehicle.camera # HACK self.camera_on = False # Turn off player camera self.position = [ self.current_vehicle.position[0], self.current_vehicle.position[1], self.current_vehicle.position[2] + 10 ] # Get out of vehicle if keyboard.events[bge.events.EKEY] == 1: self.camera_on = True self.position = [ self.current_vehicle.position[0], self.current_vehicle.position[1], self.current_vehicle.position[2] + 10 ] # add player above the vehicle self.current_vehicle.vehicle_on = False self.in_vehicle = False self.movement_state_machine.current_state = 'walk' self.current_vehicle.FSM.current_state = 'off' self.current_vehicle = None def is_grounded(self, FSM): pos2 = [self.position[0], self.position[1], self.position[2] - 5] ray2 = self.rayCast(pos2, self._data, 0, '', 0, 0, 0) return bool(ray2[0]) def is_falling(self, FSM): pos2 = [self.position[0], self.position[1], self.position[2] - 5] ray2 = self.rayCast(pos2, self._data, 0, '', 0, 0, 0) return not bool(ray2[0]) def has_entered_vehicle(self, FSM): return bool(self.vehicle) def has_exited_vehicle(self, FSM): return bool(self.vehicle) def handle_none_state(self, FSM): pass """def reload(self): print("Reloading...") if self.inventory.ammo['Assault'] > 0: if self.reload_start_time == 0.0: self.reload_start_time = sudo.game.game_time self.entity.play_animation('reload') self.reloading = True elif self.reload_start_time + self.reload_time < sudo.game.game_time: self.reload_start_time = 0.0 self.in_clip = self.clip_size self.reloading = False if self.inventory.ammo['Assault'] < self.inventory.weapon_slot_1.clip_size: self.inventory.weapon_slot_1.clip = self.inventory.ammo['Assault'] self.inventory.ammo['Assault'] = 0 else: self.inventory.weapon_slot_1.clip = self.inventory.weapon_slot_1.clip_size self.inventory.ammo['Assault'] += -self.inventory.weapon_slot_1.clip_size self.reload_start_time = 0.0 else: self.play_animation('reload') else: print("Out Of Ammo!!") """ def handle_weapon(self): if self.hold_mouse_update != 0: # Don't fire the gun after exiting a screen return weapon = self.inventory.primary_weapon # TODO - add secondary weapon if weapon is not None: weapon.main() def handle_interactions(self): ray = self.camera.controllers[0].sensors['interact_ray'] hit = ray.hitObject keyboard = bge.logic.keyboard if hit != None and 'entity_base' in hit: sudo.ui_manager.screens['hud'].set_interact_text( hit['entity_base'].interact_label, hit['entity_base'].interact_icon) if type(hit['entity_base']) is str: temp = __import__("weapon_pickup") temp = temp.WeaponPickup(hit, hit['info'], hit['name']) # ex hack hit['entity_base'] = temp else: if keyboard.events[bge.events.EKEY] == 1: hit['entity_base'].on_interact(self) else: sudo.ui_manager.screens['hud'].set_interact_text('') pass def fast_travel(self, location): self.position = location_id.position # handle world cells def handle_camera(self): bge.logic.getCurrentScene( ).active_camera = self.camera # set active_camera """ w = R.getWindowWidth()//2 h = R.getWindowHeight()//2 screen_center = (w, h) Mouse = bge.logic.mouse speed = 0.08 # walk speed sensitivity = 0.002 # mouse sensitivity smooth = 0.7 # mouse smoothing (0.0 - 0.99) if self.oldX == None: R.setMousePosition(w + 1, h + 1) self.oldX = 0.0 self.oldY = 0.0 else: scrc = Vector(screen_center) mpos = Vector(Mouse.position) x = scrc.x-mpos.x y = scrc.y-mpos.y # Smooth movement self.oldX = (self.oldX*smooth + x*(1.0-smooth)) self.oldY = (self.oldY*smooth + y*(1.0-smooth)) x = self.oldX* sensitivity y = self.oldY* sensitivity # set the values self.applyRotation([0, 0, x], False) self.applyRotation([y, 0, 0], False) # Center mouse in game window R.setMousePosition(*screen_center) """ smooth = 0.5 sensitivity = 1.5 mpos = bge.logic.mouse.position[:] mouse = bge.logic.mouse if self.oldX == None: self.oldX = [0.0, 0.0] if self.hold_mouse_update != 0: self.hold_mouse_update -= 1 mpos = [0.5, 0.5] if mouse.events[bge.events.RIGHTMOUSE]: #self.camera.lens = self.inventory.primary_weapon.zoom_lens self.camera.lens += (self.inventory.primary_weapon.zoom_lens - self.camera.lens) * 0.1 bge.logic.getCurrentScene().objects['FX']['autofocus'] = True else: bge.logic.getCurrentScene().objects['FX']['autofocus'] = False self.camera.lens = self.lens bge.render.setMousePosition(self.window_middle[0], self.window_middle[1]) if not 'ml_rotx' in self.camera: self.camera['ml_rotx'] = -( self.camera.localOrientation.to_euler().x - (math.pi * 0.5)) else: #mouse_mx = (self.oldX[0]*smooth)+((mpos[0] - 0.5) * 3)*(1.0-smooth)#bge.logic.globalDict['game'].control_options[1]#MOUSE_SENSITIVITY # bge.logic.globalDict['game'].control_options[Game.MOUSE_SENSITIVITY] #mouse_my = (self.oldX[1]*smooth)+((mpos[1] - 0.5) * 3)*(1.0-smooth)#bge.logic.globalDict['game'].control_options[1]#MOUSE_SENSITIVITY self.oldX[0] = (self.oldX[0] * smooth) + ( (mpos[0] - 0.5) * 3) * (1.0 - smooth) self.oldX[1] = (self.oldX[1] * smooth) + ( (mpos[1] - 0.5) * 3) * (1.0 - smooth) mouse_mx = self.oldX[0] * sensitivity mouse_my = self.oldX[1] * sensitivity self.armature.localPosition = self.armature.localPosition + Vector( [mouse_mx * 0.1, mouse_my * 0.1, 0.0]) cap = 1.5 if -(self.camera['ml_rotx'] + mouse_my) < cap and -( self.camera['ml_rotx'] + mouse_my) > -cap: if abs(mouse_mx) > 0.0025 or abs(mouse_my) > 0.0025: self.camera.parent.applyRotation([0, 0, -mouse_mx], 0) # X self.camera.applyRotation([-mouse_my, 0, 0], 1) # Y self.camera['ml_rotx'] += mouse_my self.armature.localPosition = self.armature.localPosition.lerp( self.saved_armature_localPosition, 0.25) def remove_controls(self): self.stored_state = self.movement_state_machine.current_state def restore_controls(self): self.movement_state_machine.current_state = self.stored_state ### def update(self): if bge.logic.globalDict['pause'] == 0 and self._data: if not self.frozen: self.movement_state_machine.main() if self.in_vehicle == False: self.handle_camera() self.handle_interactions() if self.inventory.primary_weapon: self.handle_animations() self.handle_weapon()
def _wrap(self, object): entities.EntityBase._wrap(self, object) # Vehicle self.current_vehicle = None self.in_vehicle = False self.camera = [ child for child in self.children if 'camera_temp' in child ][0] self.lens = self.camera.lens self.armature = [ child for child in self.childrenRecursive if 'Armature' in child ][0] self.bullet_spread = [ child for child in self.childrenRecursive if 'spread' in child ][0] self.weapon_pos = [ child for child in self.childrenRecursive if 'weapon_pos' in child ][0] self.climb_ray = [ child for child in self.childrenRecursive if 'climb_ray' in child ][0] self.c_r_t = [ child for child in self.childrenRecursive if 'c_r_t' in child ][0] self.c_r_b = [ child for child in self.childrenRecursive if 'c_r_b' in child ][0] self.c_r_top = [ child for child in self.childrenRecursive if 'c_r_top' in child ][0] self.squad_position_R = [ child for child in self.childrenRecursive if 'squad_R' in child ][0] self.squad_position_L = [ child for child in self.childrenRecursive if 'squad_L' in child ][0] self.blood_effect = [ child for child in self.childrenRecursive if 'blood_effect' in child ][0] # FSM States self.movement_state_machine = FiniteStateMachine(self) self.movement_state_machine.add_state('walk', self.handle_walk_state) self.movement_state_machine.add_state('fall', self.handle_fall_state) self.movement_state_machine.add_state('vehicle', self.handle_vehicle_state) self.movement_state_machine.add_state('none', self.handle_none_state) # FSM Transitions self.movement_state_machine.add_transition('fall', 'walk', self.is_grounded) self.movement_state_machine.add_transition('walk', 'vehicle', self.is_in_vehicle) # HACKS self.temp_pos = 1 self.set_loc = [ child for child in self.childrenRecursive if 'set_loc' in child ][0] self.lev = None self.saved_armature_localPosition = self.armature.localPosition.copy() # WEAPON STARTING self.inventory.replace_weapon("F2000") self.inventory.primary_weapon.equip(self) # self._data['entity_base'] = self
class NPC2(entities.AIBase): def __init__(self, packet, name="AI_Default"): super().__init__(packet) self.factions = { "Enemies": [2], "Allies": [0, 1, 3] } # Player faction = 0, Human faction = 1, Rebel Faction = 2, Kree Faction = 3 # UI self.interact_label = "NPC" self.interact_icon = None def _wrap(self, object): entities.EntityBase._wrap(self, object) # Spread self.ryn = random.randrange(-5, 5) self.rxn = random.randrange(-5, 5) # Children self.armature = [ child for child in self.childrenRecursive if 'Armature' in child ][0] self.aimer = [ child for child in self.childrenRecursive if 'aimer' in child ][0] self.bullet_spread = [ child for child in self.childrenRecursive if 'spread' in child ][0] self.weapon_pos = [ child for child in self.childrenRecursive if 'weapon_pos' in child ][0] self.head_track = [ child for child in self.childrenRecursive if 'head_track' in child ][0] # Inventory self.inventory = Inventory() self.inventory.replace_weapon("F2000") # Starting weapon self.inventory.primary_weapon.equip(self, weapon_type="3rd") # FSM self.ai_state_machine = FiniteStateMachine(self) self.ai_state_machine.add_state('idle', self.handle_idle) self.ai_state_machine.add_state('dead', self.handle_dead) self.ai_state_machine.add_state('attack', self.handle_attack) self.ai_state_machine.add_state('talk', self.handle_talk) #self.ai_state_machine.add_state('move', self.handle_move) #self.movement_state_machine.add_transition('attack', self.transition_to_attack) self.ai_state_machine.current_state = "idle" ### self._data['entity_base'] = self def _unwrap(self): EntityBase._unwrap(self) def on_interact(self, player): #self.ai_state_machine.current_state = "talk" # Disabled sudo.world.dialogue_manager.display_dialogue('./data/dialogue/' + 'test' + '.xml') """ FSM Transitions """ def transition_to_attack(self, FSM): return self.target_in_sight def is_dead(self, FSM): if self['Health'] < 0: return True else: return False def is_fleeing(self, FSM): moral = 0 moral += -len(self.enemies) moral += len(self.allies) moral += -(self.health - 100) * 0.25 return False """ FSM States """ def handle_idle(self, FSM): self['Steer'] = 0 self.play_animation("idle") # Head tracking self.track(sudo.player.position, tracker=self.head_track, speed=0.8, track_3d=True) def handle_talk(self, FSM): self['Steer'] = 0 self.play_animation("idle") sudo.world.dialogue_manager.display_dialogue('./data/dialogue/' + 'test' + '.xml') def handle_flee(self, FSM): self.move_to(self.target.position) def handle_attack(self, FSM): # If Target Found if self.target: self.track(self.target.position, tracker=self.head_track, speed=0.8, track_3d=True) dist = self.getDistanceTo(self.target.position) # Check if target is in sight if self.is_in_sight(self.target.name): self.target_last_pos = self.target._data.position.copy() self.target_in_sight = True else: self.target_in_sight = False # If everything is Vaild if self.target and self.target_last_pos: # Far away -> move closer if dist > 60: self.move_to(self.target_last_pos) # Close enough to attack else: self.localLinearVelocity = [0.0, 0.0, 0.0] # Stop moving if self.is_in_sight(self.target.name): self.track(self.target.position, speed=0.25) self.track(self.target.position, tracker=self.aimer, speed=0.85, track_3d=True) self.inventory.primary_weapon.ai_fire(self) self.target_in_sight = True print("FIRE!!!") else: self.move_to(self.target_last_pos) def handle_dead(self, FSM): print("Dead") self['Steer'] = 0 self.remove() def find_target(self): if self.enemies: self.target = self.enemies[0][1] else: self.target = None def alert_entities(self): for temp in game.Game.singleton.world.entity_list: temp.alerted = 1 temp.alert_position = self.position.copy() def damage(self, damage_amount=1, object=None): print("HIT") self.target = object self.target_last_pos = self.target.position.copy() self.health += -damage_amount if object.faction in self.factions['Allies']: index = self.factions['Allies'].index(object.faction) self.factions['Allies'].remove(index) if not object.faction in self.factions['Enemies']: self.factions["Enemies"].append(object.faction) # IF dead if self.health < 0: self.ai_state_machine.current_state = 'dead' self.ai_state_machine.current_state = 'attack' def alert_entity(self, object): self.target = object self.target_last_pos = self.target.position.copy() self.track(self.target_last_pos) self.ai_state_machine.current_state = 'handle_no_cover' """ 'Checks' """ def is_scared(): return False def is_in_cover(self, FSM): return bool(self.in_cover) def is_enemy_near(self, FSM): enemies = self.detect_enemies() return bool(enemies != None) def is_in_sight(self, target): sight = False radar = self.aimer.controllers[0].sensors['Radar'] for hit_obj in radar.hitObjectList: if hit_obj.name == target: ray = self.rayCast(hit_obj.position, self.aimer.position, 0, '', 0, 0, 0) if (ray[0]) and ray[0].name == target: sight = True return sight """ ANIMATIONS """ def play_animation(self, name): self.animations[name] = 1 def stop_animation(self, layer): for n in range(0, 7): if n != layer: self.armature.stopAction(n) def handle_animations(self): weapon = self.inventory.primary_weapon if self.animations['reload'] == 1: self.armature.playAction(weapon.name + "_reload_3rd", 1, 64, layer=4, priority=2, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_PLAY, speed=1.0) self.stop_animation(4) elif self.animations['attack'] == 1: self.armature.playAction(weapon.name + "_attack_3rd", 1, 5, layer=3, priority=3, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_PLAY, speed=1.0) self.stop_animation(3) elif self.animations['walk'] == 1: self.armature.playAction(weapon.name + "_walk_3rd", 1, 32, layer=2, priority=2, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) self.stop_animation(2) elif self.animations['run'] == 1: self.armature.playAction(weapon.name + "_run_3rd", 1, 20, layer=1, priority=3, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) self.stop_animation(1) else: self.stop_animation(0) self.armature.playAction(weapon.name + "_idle_3rd", 1, 64, layer=0, priority=5, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) for name in self.animations: self.animations[name] = 0 """ 'Main' """ def update(self): if self._data: self.handle_animations() # Update target if self.target == None: self.update_enitity_list() # Update Enemy/Ally list self.find_target( ) # Update Target with the enemy with the highest threat level self.ai_state_machine.main() else: print("NO DATA")
class Morgoar(entities.EntityBase): """ A simple entity for talking to """ def __init__(self, packet=None): super().__init__(packet) self.interact_label = 'Talk' self.health = 80 self.faction = -841 #self.localScale = self.localScale * (1+random.random*.3) self.update_time = time.time() + random.random() self.ticker = 1.0 self.ai_state = None self.alert_radius = 80 self.target_enemy = None self.alerted = False self.path = 0.0 self.speed = 5 # Animations self.animations = { 'walk': 0, 'run': 0, 'attack': 0, 'reload': 0, 'idle': 1, 'cround': 0 } # FSM States self.movement_state_machine = FiniteStateMachine(self) self.movement_state_machine.add_state('idle', self.handle_idle_state) self.movement_state_machine.add_state('walk', self.handle_walk_state) self.movement_state_machine.add_state('attack', self.handle_attack_state) self.movement_state_machine.add_state('dead', self.handle_dead_state) self.movement_state_machine.current_state = "idle" # FSM Transitions self.movement_state_machine.add_transition('idle', 'walk', self.is_alerted) self.movement_state_machine.add_transition_c('attack', 'walk', self.is_close) self.movement_state_machine.add_transition_u('dead', self.is_dead) # self.interact_label = "Morgoar" self.interact_icon = None def _wrap(self, object1): entities.EntityBase._wrap(self, object1) self.armature = [ child for child in self._data.childrenRecursive if 'Armature' in child ][0] self.ray_b = [ child for child in self._data.childrenRecursive if 'ray_bottom' in child ][0] self.ray_top = [ child for child in self._data.childrenRecursive if 'ray_top' in child ][0] self._data['entity_base'] = self sudo.world.entity_list.append(self) print('ghost init') def is_alerted(self, FSM): if self.target_enemy != None: return True else: return False def is_close(self, FSM): dist = self._data.getDistanceTo(self.target_enemy.position) if dist < 2.0: return True else: return False def is_dead(self, FSM): if self.health < 0.0: return True else: return False def alert_entity(self, object1): self.target_enemy = object1 def on_interact(self, player): pass ### ANIMATIONS ### def play_animation(self, name): self.animations[name] = 1 def stop_animation(self, layer): for n in range(0, 7): if n != layer: self.armature.stopAction(n) def handle_animations(self): if self.animations['attack'] == 1: self.armature.playAction("m_attack", 1, 32, layer=2, priority=2, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) self.stop_animation(2) elif self.animations['walk'] == 1: self.armature.playAction("m_walk", 1, 30, layer=1, priority=2, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) self.stop_animation(1) else: self.armature.playAction("m_idle", 1, 30, layer=0, priority=2, blendin=5, play_mode=bge.logic.KX_ACTION_MODE_LOOP, speed=1.0) self.stop_animation(0) for name in self.animations: self.animations[name] = 0 def handle_dead_state(self, FSM): pass def handle_attack_state(self, FSM): st = self.controllers[0].actuators['Steering'] st.velocity = 0.0 target = self.target_enemy self.track(target.position) target.damage(10) self.play_animation("attack") def handle_walk_state(self, FSM, behavior=3, offset=0, speed='walk'): if speed == 'walk': speed = self.speed elif speed == 'run': speed = self.speed * 2 self.navmesh = bge.logic.getCurrentScene().objects['Navmesh_box'] self.path = self.navmesh.findPath(self.position, self.target_enemy.position) self.path_index = 0 if len(self.path) > 0: current_node = self.path[self.path_index] dist = self._data.getDistanceTo(current_node) if dist < 1.0: self.path_index += 1 self.track(self.path[self.path_index]) self.localLinearVelocity = [0.0, speed, 0.0] self.play_animation("walk") def handle_idle_state(self, FSM): self.play_animation("idle") entities = sudo.world.entity_list enemy_list = [] """ for entity in entities: try: faction = entity.faction except: faction = self.faction if faction != self.faction: dist = self._data.getDistanceTo(entity._data) if dist < 35: ray = self._data.rayCast(entity.position, self.position, 0,'',0,0,0) if ray[0] == entity._data: enemy_list.append([dist, entity]) enemy_list.sort() if len(enemy_list) > 0: self.target_enemy = enemy_list[0][1] else: self.target_enemy = None """ self.target_enemy = sudo.player def track(self, target, speed=1.0): vec = self.getVectTo(target) self.alignAxisToVect(vec[1], 1, speed) self.alignAxisToVect([0, 0, 1], 2, speed) def damage(self, amount, obj): self.health = self.health - amount ### Mist #new = bge.logic.getCurrentScene().addObject("blood_mist",'CELL_MANAGER_HOOK',5) #new.position = self._data.position ### Splatter ray = self._data.rayCast(self.ray_b, self.ray_top, 0, 'Ground', 0, 1, 0) #index = random.randrange(0,len(blood_textures)) #if ray[0] != None: # blood_textures = ["Blood", "Blood_2"] # index = random.randrange(0,len(blood_textures)) """ new = bge.logic.getCurrentScene().addObject(blood_textures[index],'CELL_MANAGER_HOOK',2500) new.position = ray[1]+Vector([0.0,0.0,0.05]) ran = random.randrange(0.0,10.0) new.orientation = new.orientation*Vector([0.0,0.0,ran]) """ if self.health < 0.0: chunks = [ "morgoar_chunk", "morgoar_chunk.001", "morgoar_chunk.002", "morgoar_chunk.003", "morgoar_chunk.004", "morgoar_chunk.005", "morgoar_chunk.006", "morgoar_chunk.007", "morgoar_chunk.008", "morgoar_chunk.009" ] md = bge.logic.getCurrentScene().addObject("morgaor_death", 'CELL_MANAGER_HOOK', 50) md.position = self._data.position for chunk in chunks: c = bge.logic.getCurrentScene().addObject( chunk, 'CELL_MANAGER_HOOK', 2500) c.position = self._data.position for child in md.children: if "prop" in child: if child['prop'] == chunks[chunks.index(chunk)]: c.position = child.position c.orientation = child.orientation if ray[0] != None: new = bge.logic.getCurrentScene().addObject( "Blood_floor", 'CELL_MANAGER_HOOK') new.position = ray[1] + Vector([0.0, 0.0, 0.05]) ran = random.randrange(0.0, 100.0) new.orientation = new.orientation * Vector([0.0, 0.0, ran]) self.remove() def update(self): self.movement_state_machine.main() self.handle_animations()
def __init__(self, object_name): print("-- VehicleBase.__init__() --") entities.EntityBase.__init__(self, None) entities.EntityBase._wrap(self, object_name) self.vehicle_wheels = None ### Vehicle Properties self.speed = 15 self.acceleration = 1.0 self.brake_amount = 0.5 self.steer_amount = 0.5 self.car_susp = 0.70 # suspension factor for the car self.gear = 1 self.engine_sound = 0.0 ### Wheel properties self.wheel_radius = 1.0 self.wheel_suspension = 1.0 self.wheel_roll = 0.1 self.wheel_friction = 1.0 self.wheel_compression = 2.0 self.wheel_damping = 1.5 self.wheel_stiffness = 6.0 self.wheel_susp_angle = [0.0, 0.0, -1.0] self.wheel_axis = [-1.0, 0.0, 0.0] ### DONT MESS WITH THESE self.wheel_max_drive = 1.0 self.wheel_max_reverse_drive = 1.0 self.wheel_max_brake = 0.1 self.wheel_max_left_steer = 0.0 self.wheel_max_right_steer = 0.0 ### self.car_drive = 0.0 self.car_steer = 0.0 self.car_brake = 0.0 self.current_steer = 0 ### self.ray_pos = [ child for child in self.childrenRecursive if 'ray' in child ][0] self.rotation_speed = 0.0 self.last_rotation = 0.0 self.rotation_difference = 0.0 ### Activate Vehicle Controls self.vehicle_on = False # HACK self._data['entity_base'] = self self.camera = [ child for child in self.childrenRecursive if 'vcam' in child ][0] for child in self.childrenRecursive: if 'remove' in child: child.removeParent() #pass self.camera.removeParent() ### FSM self.FSM = FiniteStateMachine(self) self.FSM.add_state('on', self.handle_on) self.FSM.add_state('off', self.handle_off) self.FSM.add_transition('off', 'on', self.is_active) self.FSM.current_state = 'off' ### BUILD VEHICLE self.assembleVehicle(self._data) self._data['build'] = True
class VehicleBase(EntityBase): ### INIT def __init__(self, object_name): print("-- VehicleBase.__init__() --") entities.EntityBase.__init__(self, None) entities.EntityBase._wrap(self, object_name) self.vehicle_wheels = None ### Vehicle Properties self.speed = 15 self.acceleration = 1.0 self.brake_amount = 0.5 self.steer_amount = 0.5 self.car_susp = 0.70 # suspension factor for the car self.gear = 1 self.engine_sound = 0.0 ### Wheel properties self.wheel_radius = 1.0 self.wheel_suspension = 1.0 self.wheel_roll = 0.1 self.wheel_friction = 1.0 self.wheel_compression = 2.0 self.wheel_damping = 1.5 self.wheel_stiffness = 6.0 self.wheel_susp_angle = [0.0, 0.0, -1.0] self.wheel_axis = [-1.0, 0.0, 0.0] ### DONT MESS WITH THESE self.wheel_max_drive = 1.0 self.wheel_max_reverse_drive = 1.0 self.wheel_max_brake = 0.1 self.wheel_max_left_steer = 0.0 self.wheel_max_right_steer = 0.0 ### self.car_drive = 0.0 self.car_steer = 0.0 self.car_brake = 0.0 self.current_steer = 0 ### self.ray_pos = [ child for child in self.childrenRecursive if 'ray' in child ][0] self.rotation_speed = 0.0 self.last_rotation = 0.0 self.rotation_difference = 0.0 ### Activate Vehicle Controls self.vehicle_on = False # HACK self._data['entity_base'] = self self.camera = [ child for child in self.childrenRecursive if 'vcam' in child ][0] for child in self.childrenRecursive: if 'remove' in child: child.removeParent() #pass self.camera.removeParent() ### FSM self.FSM = FiniteStateMachine(self) self.FSM.add_state('on', self.handle_on) self.FSM.add_state('off', self.handle_off) self.FSM.add_transition('off', 'on', self.is_active) self.FSM.current_state = 'off' ### BUILD VEHICLE self.assembleVehicle(self._data) self._data['build'] = True def _unwrap(self): EntityBase._unwrap(self) ### Functions def findWheels(self, vehicle): wheels = [] children = list(vehicle.children) for child in children: if "wheel" in child: wheels.append(child) return wheels def convertToFloatList(self, aList): if type(aList) == type(''): aList = eval(aList) newList = [] for entry in aList: newList.append(float(entry)) return newList ### Build Vehicle def assembleVehicle(self, vehicle): vehicleWrapper = self.createConstraint(vehicle) self.vehicle_wheels = self.findWheels(vehicle) self.assembleWheels(vehicle, vehicleWrapper) def createConstraint(self, carObj): car_PhysicsID = carObj.getPhysicsId() vehicle_constraint = PhysicsConstraints.createConstraint( car_PhysicsID, 0, 11) self.vehicle_constraint = vehicle_constraint constraint_ID = vehicle_constraint.getConstraintId() vehicleWrapper = PhysicsConstraints.getVehicleConstraint(constraint_ID) self.wrapper = vehicleWrapper return vehicleWrapper def assembleWheels(self, vehicle, vehicleWrapper): #wheels = self.vehicle_wheels wheelId = 0 ### for wheel in self.vehicle_wheels: #pos = wheel.localPosition pos = Mathutils.Vector(wheel.localPosition) #pos = Mathutils.Vector(wheel.localPosition)#wheel.position - wheel.parent.position #print (pos) #print (wheel.localPosition) #print (Mathutils.Vector(wheel.localPosition)) wheel.removeParent() vehicleWrapper.addWheel( wheel, pos, self.convertToFloatList(self.wheel_susp_angle), self.convertToFloatList(self.wheel_axis), self.wheel_suspension, wheel['radius'], True) vehicleWrapper.setRollInfluence(self.wheel_roll, wheelId) vehicleWrapper.setTyreFriction(wheel['friction'], wheelId) vehicleWrapper.setSuspensionCompression(self.wheel_compression, wheelId) vehicleWrapper.setSuspensionDamping(self.wheel_damping, wheelId) vehicleWrapper.setSuspensionStiffness(self.wheel_stiffness, wheelId) wheel["wheelId"] = wheelId wheel["vehicle"] = vehicle wheelId += 1 print("STARTED") ### Drive def handle_drive(self, vehicle_wrapper): ### keyboard = bge.logic.keyboard.events speed = 0 ### if keyboard[bge.events.WKEY]: speed = self.speed * self.acceleration if self.acceleration < 1.0: self.acceleration += 0.005 elif keyboard[bge.events.SKEY]: speed = -self.speed * 0.5 else: if self.acceleration > 0.0: self.acceleration += -0.01 for wheel in self.vehicle_wheels: id = self.vehicle_wheels.index(wheel) vehicle_wrapper.applyEngineForce(speed * wheel['maxDrive'], id) ### Brake def handle_brake(self, vehicle_wrapper): ### keyboard = bge.logic.keyboard.events brake = 0 ### if keyboard[bge.events.SPACEKEY]: brake = self.brake_amount for wheel in self.vehicle_wheels: id = self.vehicle_wheels.index(wheel) vehicle_wrapper.applyBraking(brake, id) ### Steering def handle_steering(self, vehicle_wrapper): ### keyboard = bge.logic.keyboard.events ### if keyboard[bge.events.AKEY]: if self.current_steer < self.steer_amount: self.current_steer += 0.075 #self.steer_amount elif keyboard[bge.events.DKEY]: if self.current_steer > -self.steer_amount: self.current_steer += -0.075 #-self.steer_amount else: if self.current_steer > 0.1: self.current_steer += -0.075 elif self.current_steer < -0.1: self.current_steer += 0.075 else: self.current_steer = 0 vehicle_wrapper.setSteeringValue(self.current_steer, 2) vehicle_wrapper.setSteeringValue(self.current_steer, 3) def handle_stablization(self): #ray_pos = [own.position[0],own.position[1],own.position[1]-10] ray = self.rayCast(self.ray_pos, self._data, 0, '', 0, 0, 0) if ray[0] == None: self.alignAxisToVect([0.0, 0.0, 1.0], 2, 0.03) else: self.alignAxisToVect([0.0, 0.0, 1.0], 2, 0.01) ### FSM def handle_on(self, FSM): print("ON") vehicle_wrapper = self.wrapper #_data[self.vehicle_wrapper] ### self.handle_drive(vehicle_wrapper) self.handle_brake(vehicle_wrapper) self.handle_steering(vehicle_wrapper) self.handle_stablization() ### self.last_rotation = self.rotation_speed self.rotation_speed = (vehicle_wrapper.getWheelRotation(0) + vehicle_wrapper.getWheelRotation(1)) / 2 self.rotation_difference = self.last_rotation - self.rotation_speed ### Gears if self.rotation_difference > 1.0: self.gear = 3 elif self.rotation_difference > 0.75: self.gear = 2 elif self.rotation_difference > 0.5: self.gear = 1 #self.engine_sound = self.rotation_difference*self.gear ### TO fix reload crash #bge.constraints.removeConstraint(vehicle_wrapper.getConstraintId()) def handle_off(self, FSM): vehicle_wrapper = self.wrapper #_data[self.vehicle_wrapper] print("OFF") # Brake amount brake = 0.25 # Brake for wheel in self.vehicle_wheels: id = self.vehicle_wheels.index(wheel) vehicle_wrapper.applyBraking(brake, id) def is_active(self, FSM): return bool(self.vehicle_on) ### Interact def on_interact(self, entity): if self.vehicle_on == False: print("TURNING ON ---") self.vehicle_on = True entity.current_vehicle = self entity.in_vehicle = True ### MAIN def main(self): EntityBase.main(self) self.FSM.main()
def __init__(self): threading.Thread.__init__(self) self.machine = FiniteStateMachine() self._start_keyboard_listener()
class VehicleBase(entities.EntityBase): """ A simple entity for talking to """ def __init__(self, packet=None): super().__init__(packet) #def __init__(self, object_name): print("-- VehicleBase.__init__() --") #entities.EntityBase.__init__(self, None) #entities.EntityBase._wrap(self, object_name) self.vehicle_wheels = None ### Vehicle Properties self.speed = 15 self.acceleration = 1.0 self.brake_amount = 0.5 self.steer_amount = 0.5 self.car_susp = 0.70 # suspension factor for the car self.gear = 1 self.engine_sound = 0.0 ### Wheel properties self.wheel_radius = 1.0 self.wheel_suspension = 1.0 self.wheel_roll = 0.1 self.wheel_friction = 1.0 self.wheel_compression = 2.0 self.wheel_damping = 1.5 self.wheel_stiffness = 6.0 self.wheel_susp_angle = [0.0, 0.0, -1.0] self.wheel_axis = [-1.0, 0.0, 0.0] self.last_dust_created = {} ### DONT MESS WITH THESE self.wheel_max_drive = 1.0 self.wheel_max_reverse_drive = 1.0 self.wheel_max_brake = 0.1 self.wheel_max_left_steer = 0.0 self.wheel_max_right_steer = 0.0 ### self.car_drive = 0.0 self.car_steer = 0.0 self.car_brake = 0.0 self.current_steer = 0 # self.interact_label = "Morgoar" self.interact_icon = None def _wrap(self, object1): entities.EntityBase._wrap(self, object1) ### self.ray_pos = [ child for child in self.childrenRecursive if 'ray' in child ][0] self.rotation_speed = 0.0 self.last_rotation = 0.0 self.rotation_difference = 0.0 ### Activate Vehicle Controls self.vehicle_on = False # HACK self._data['entity_base'] = self self.camera = [ child for child in self.childrenRecursive if 'vcam' in child ][0] for child in self.childrenRecursive: if 'remove' in child: child.removeParent() #pass ### FSM self.FSM = FiniteStateMachine(self) self.FSM.add_state('on', self.handle_on) self.FSM.add_state('off', self.handle_off) self.FSM.add_transition('off', 'on', self.is_active) self.FSM.current_state = 'off' ### BUILD VEHICLE self.assembleVehicle(self._data) self._data['build'] = True #self.sound_actuator = self._data.controllers[0].actuators['Sound'] #def _unwrap(self): # entities.EntityBase._unwrap(self) ### Functions def findWheels(self, vehicle): wheels = [] children = list(vehicle.children) for child in children: if "wheel" in child: wheels.append(child) return wheels def convertToFloatList(self, aList): if type(aList) == type(''): aList = eval(aList) newList = [] for entry in aList: newList.append(float(entry)) return newList ### Build Vehicle def assembleVehicle(self, vehicle): vehicleWrapper = self.createConstraint(vehicle) self.vehicle_wheels = self.findWheels(vehicle) self.assembleWheels(vehicle, vehicleWrapper) def createConstraint(self, carObj): car_PhysicsID = carObj.getPhysicsId() vehicle_constraint = PhysicsConstraints.createConstraint( car_PhysicsID, 0, 11) self.vehicle_constraint = vehicle_constraint constraint_ID = vehicle_constraint.getConstraintId() vehicleWrapper = PhysicsConstraints.getVehicleConstraint(constraint_ID) self.wrapper = vehicleWrapper return vehicleWrapper def assembleWheels(self, vehicle, vehicleWrapper): #wheels = self.vehicle_wheels wheelId = 0 ### for wheel in self.vehicle_wheels: pos = wheel.localPosition.copy() wheel.removeParent() vehicleWrapper.addWheel( wheel, pos, self.convertToFloatList(self.wheel_susp_angle), self.convertToFloatList(self.wheel_axis), self.wheel_suspension, wheel['radius'], True) vehicleWrapper.setRollInfluence(self.wheel_roll, wheelId) vehicleWrapper.setTyreFriction(wheel['friction'], wheelId) vehicleWrapper.setSuspensionCompression(self.wheel_compression, wheelId) vehicleWrapper.setSuspensionDamping(self.wheel_damping, wheelId) vehicleWrapper.setSuspensionStiffness(self.wheel_stiffness, wheelId) wheel["wheelId"] = wheelId wheel["vehicle"] = vehicle wheelId += 1 self.last_dust_created[wheel] = sudo.world.world_time print("STARTED **********") ### Drive def handle_drive(self, vehicle_wrapper): ### keyboard = bge.logic.keyboard.events speed = 0 ### if keyboard[bge.events.WKEY]: if self.engine_sound < 1.0: self.engine_sound += 0.01 speed = self.speed * self.acceleration if self.acceleration < 1.0: self.acceleration += 0.005 elif keyboard[bge.events.SKEY]: speed = -self.speed * 0.5 else: if self.engine_sound > 0.0: self.engine_sound += -0.005 if self.acceleration > 0.0: self.acceleration += -0.01 print(dir(self.vehicle_wheels[0])) for wheel in self.vehicle_wheels: id = self.vehicle_wheels.index(wheel) vehicle_wrapper.applyEngineForce(speed * wheel['maxDrive'], id) if keyboard[bge.events.WKEY]: ray = self.rayCast(self.ray_pos, self._data, 0, '', 0, 0, 0) if ray[0]: self.spawn_dust(wheel) ### Brake def handle_brake(self, vehicle_wrapper): ### keyboard = bge.logic.keyboard.events brake = 0 ### if keyboard[bge.events.SPACEKEY]: brake = self.brake_amount for wheel in self.vehicle_wheels: id = self.vehicle_wheels.index(wheel) vehicle_wrapper.applyBraking(brake, id) ### Steering def handle_steering(self, vehicle_wrapper): ### keyboard = bge.logic.keyboard.events ### if keyboard[bge.events.AKEY]: if self.current_steer < self.steer_amount: self.current_steer += 0.075 #self.steer_amount elif keyboard[bge.events.DKEY]: if self.current_steer > -self.steer_amount: self.current_steer += -0.075 #-self.steer_amount else: if self.current_steer > 0.1: self.current_steer += -0.075 elif self.current_steer < -0.1: self.current_steer += 0.075 else: self.current_steer = 0 vehicle_wrapper.setSteeringValue(self.current_steer, 0) vehicle_wrapper.setSteeringValue(self.current_steer, 1) def handle_stablization(self): #ray_pos = [own.position[0],own.position[1],own.position[1]-10] ray = self.rayCast(self.ray_pos, self._data, 0, '', 0, 0, 0) if ray[0] == None: self.alignAxisToVect([0.0, 0.0, 1.0], 2, 0.05) else: self.alignAxisToVect([0.0, 0.0, 1.0], 2, 0.03) ### FSM def handle_on(self, FSM): print("ON") vehicle_wrapper = self.wrapper #_data[self.vehicle_wrapper] ### Camera self.camera.controllers[0].actuators['Edit Object'].object = self._data ### self.handle_drive(vehicle_wrapper) self.handle_brake(vehicle_wrapper) self.handle_steering(vehicle_wrapper) self.handle_stablization() ### self.last_rotation = self.rotation_speed self.rotation_speed = (vehicle_wrapper.getWheelRotation(0) + vehicle_wrapper.getWheelRotation(1)) / 2 self.rotation_difference += -(self.last_rotation - self.rotation_speed) ### Gears if self.rotation_difference > 1.0: self.gear = 3 elif self.rotation_difference > 0.75: self.gear = 2 elif self.rotation_difference > 0.5: self.gear = 1 #self.engine_sound = self.rotation_difference#*self.gear #self.sound_actuator.pitch = 1.0 + (self.engine_sound*2.0) #print (self.sound_actuator) ### TO fix reload crash #bge.constraints.removeConstraint(vehicle_wrapper.getConstraintId()) def handle_off(self, FSM): vehicle_wrapper = self.wrapper #_data[self.vehicle_wrapper] # Brake amount brake = 0.25 # Brake for wheel in self.vehicle_wheels: id = self.vehicle_wheels.index(wheel) vehicle_wrapper.applyBraking(brake, id) print("OFF") def is_active(self, FSM): return bool(self.vehicle_on) ### Interact def on_interact(self, entity): if self.vehicle_on == False: print("TURNING ON ---") self.vehicle_on = True entity.current_vehicle = self entity.in_vehicle = True ### def spawn_dust(self, wheel): if (sudo.world.world_time - self.last_dust_created[wheel] > 0.1): dust = bge.logic.getCurrentScene().addObject( "Dust", "CELL_MANAGER_HOOK", 20) dust.position = wheel.position - Vector( [0.0, 0.0, 1.0]) #Landscape height at position dust.localScale = [3.0, 3.0, 3.0] self.last_dust_created[wheel] = sudo.world.world_time ### MAIN def main(self): entities.EntityBase.main(self) self.FSM.main()
class FiniteStateMachineTests(unittest.TestCase): def setUp(self): self.finite_state_machine = FiniteStateMachine() def test_createNewMachine_withoutParameters_initialStateMustBeStopped(self): actual_state = self.finite_state_machine.get_current_state() assert_that(actual_state).is_equal_to(MachineState.STOPPED) def test_setCurrentState_withInvalidCommand_exceptionMustBeRaised(self): with self.assertRaises(ValueError): self.finite_state_machine.set_current_state('foo') def test_setCurrentState_withValidCommand_stateMustBeSetted(self): self.finite_state_machine.set_current_state(MachineCommand.START) actual_state = self.finite_state_machine.get_current_state() assert_that(actual_state).is_equal_to(MachineState.STARTED) def test_setCollectInStartedMachine_thenGetPreviousState_previousStateMustBeStarted(self): self.finite_state_machine.set_current_state(MachineCommand.START) self.finite_state_machine.set_current_state(MachineCommand.COLLECT) previous_state = self.finite_state_machine.get_previous_state() assert_that(previous_state).is_equal_to(MachineState.STARTED) def test_collectData_mustReturnMultidimensionalArray(self): expected_array_rows = 3 expected_array_columns = 3 expected_min_value = 0 expected_max_value = 9 self.finite_state_machine.set_current_state(MachineCommand.START) actual = self.finite_state_machine.collect_data() assert_that(actual).is_not_empty() assert_that(actual).is_length(expected_array_rows) for row in actual: assert_that(row).is_length(expected_array_columns) for column in row: assert_that(column).is_less_than_or_equal_to(expected_max_value) assert_that(column).is_greater_than_or_equal_to(expected_min_value) def test_processData_mustReturnScalar5TransposedArray(self): target_array = numpy.array( [[1, 2, 3], [4, 5, 6], [7, 8, 9]]) expected_array = numpy.array([[5, 20, 35], [10, 25, 40], [15, 30, 45]]) self.finite_state_machine.set_current_state(MachineCommand.START) self.finite_state_machine.set_current_state(MachineCommand.COLLECT) actual_array = self.finite_state_machine.process_data(target_array) for actual_row, expected_row in zip(actual_array.tolist(), expected_array.tolist()): assert_that(actual_row).is_equal_to(expected_row)
def setUp(self): self.finite_state_machine = FiniteStateMachine()