def __init__(self, cfg): # Replay memory self.memory = ReplayBuffer(**cfg['agent']['memory']) # Environment configuration self.action_shape = cfg['env']['action_shape'] # Algorithm parameters self.exploration_mu, self.exploration_theta, self.exploration_sigma = cfg['agent']['noise'] self.noise = OUNoise(self.action_shape, self.exploration_mu, self.exploration_theta, self.exploration_sigma) self.gamma = cfg['agent']['gamma'] self.tau = cfg['agent']['tau'] state_flatten_shape = [np.prod(self.memory.flatten_state_shape)] # Actor Model self.actor = Actor(state_flatten_shape, self.action_shape, cfg['env']['action_range'], self.tau, self.memory.batch_size, cfg['actor']) # Critic Model self.critic = Critic(state_flatten_shape, self.action_shape, self.tau, cfg['critic']) # Flag & Counter self.add_noise = True self.episode = 0 self.max_episode_explore = 100
def __init__(self, mother_ship, melee, body): self.body = body Actor.__init__(self, melee) self.mother_ship = mother_ship # Register shapes for collision callbacks for s in self.body.shapes: melee.contact_register[hash(s)] = self
def __init__(self, surface): image_file = 'resources/sprites/bear.png' bullet = Bullet('resources/sprites/bullet02.png', surface, 60) railgun = Railgun(bullet, 100000, self) Actor.__init__(self, image_file=image_file, surface=surface, health=100, damage=5, fire_direction=globals.DIRECTION["TOP"], speed=8, weapon=railgun) scaled_size = self._scale(self._size, 2) self._image = pygame.transform.scale(self._img, scaled_size) self._rect.size = scaled_size
def __init__(self, surface): image_file = 'resources/sprites/chungus.jpg' bullet = Bullet('resources/sprites/enemy_bullet01.png', surface, 60) railgun = Railgun(bullet, 100000, self) Actor.__init__(self, image_file=image_file, surface=surface, health=80, damage=1, fire_direction=globals.DIRECTION["BOTTOM"], speed=6, weapon=railgun) scaled_size = self._scale(self._size, 6) self._image = pygame.transform.scale(self._img, scaled_size) self._rect.size = scaled_size
def __init__(self, height, width): tile_names = [ "Resources/images/roadA.png", "Resources/images/treesA.png", "Resources/images/grassA.png" ] self.height = height self.width = width tiles = [0] * self.width for i in range(0, self.width): tiles[i] = [0] * self.height for j in range(0, self.height): tiles[i][j] = open_image(tile_names[randint(0, 2)]) board_texture = merge_images(tiles) board_actor = Actor() board_actor.set_sprite(board_texture)
def player(self, x, y): sprites = self.sprites alive = True pc = creatures.Creature('Bert', 40) container = containers.Container() player = Actor(x, y, sprites.width, sprites.height, sprites.S_PLAYER, 'Human', self.log, alive, pc, None, container) return player
def debugItem(self, x, y): sprites = self.sprites alive = False creature = None ai = None item = items.Item(self.level, identified=True) container = None debugItem = Actor(x, y, sprites.width, sprites.height, sprites.S_DBG_ITEM, 'Debug_Item', self.log, alive, creature, ai, container, item) return debugItem
def blode(self, x, y): sprites = self.sprites on_death = deaths.drop_corpse() alive = True creature = creatures.Creature('Blode', 5, on_death) ai = ais.Ai_Test() container = None item = items.Item(self.level) blode = Actor(x, y, sprites.width, sprites.height, sprites.S2_BLODE, 'Slime', self.log, alive, creature, ai, container, item) return blode
def heal_potion(self, x, y): on_use = heal sprites = self.sprites alive = False creature = None ai = None item = items.Item(self.level, 0, 0, 1, on_use) container = None heal_potion = Actor(x, y, sprites.width, sprites.height, sprites.S_HEAL_POTION, 'Potion of Minor Healing', self.log, alive, creature, ai, container, item) return heal_potion
def beano(self, x, y): sprites = self.sprites on_death = deaths.drop_corpse() alive = True creature = creatures.Creature('Beano', 15, on_death) ai = ais.basic_chase(4) container = None item = items.Item(self.level) beano = Actor(x, y, sprites.width, sprites.height, sprites.S2_BEANO, 'Bean', self.log, alive, creature, ai, container, item) return beano
def __init__(self, melee): Actor.__init__(self, melee) # Set max linear and angular velocity self.max_linear_velocity = 50 self.max_angular_velocity = pi # Physics (based on SVG shapes) self.translate = calc_center(self.lines[self.parts.index(self.center_part)]) self.svg.init(self.translate, self.scale) bodydef = Body() bodydef.ccd = True bodydef.position = self.initial_position self.body = melee.world.append_body(bodydef) self.body.linear_velocity = self.initial_velocity self.body.angular_velocity = self.initial_ang_vel for p in self.lines: polygondef = Polygon() polygondef.density = self.density # Ensure points are oriented ccw ccw = convex_hull(p) # Translate and scale points verts = [] for v in ccw: x = (v[0] - self.translate[0]) * self.scale y = (v[1] - self.translate[1]) * self.scale verts.append(Vec2(x, y)) polygondef.vertices = verts polygondef.collision_group = self.group shape = self.body.append_shape(polygondef) # Register shapes for collision callbacks melee.contact_register[hash(shape)] = self self.body.set_mass_from_shapes()
def commence_battle(attacker: PlayerCharacter, defender: Actor) -> bool: attacker_roll = attacker.attack() defender_roll = defender.defend() dealt_damage = attacker_roll - defender_roll print("{} attacks {}: {} against {}.".format(attacker, defender, attacker_roll, defender_roll)) if dealt_damage >= 0: print("{} defeats {}.".format(attacker, defender)) return True else: print("{} was defeated by {}.".format(attacker, defender)) return False
def add_members(self, gender='male', num=1): """ Add members into family :param gender: male/female. if num > 1 then randomize :param num: default 1. :return: list of node ids added, new node id """ node_ct = self.node_ct added_nodes = [] for x in range(num): if num > 1: gender = random.choice(['male', 'female']) # select a name that is not taken name = names.get_first_name(gender=gender) while name in self.taken_names: name = names.get_first_name(gender=gender) self.taken_names.add(name) node = Actor( name=name, gender=gender, node_id=node_ct) added_nodes.append(node) self.family.add_node(node_ct, data=node) node_ct += 1 self.node_ct = node_ct return added_nodes
def advantage(self, obs: Arrayable, action: Tensorable, actor: Actor) -> Tensor: return self._dt * (self.critic(obs, action) - self.critic(obs, actor.act(obs)))
def __init__(self, x, y, sprite): self.actor = Actor() self.actor.set_position(x, y) self.actor.set_sprite(sprite) world.add(self.actor)
def initialize(): camera.position = Vector3(0.0, 0.0, 5.0) board = Board(30, 25) cursor = Actor() cursor.set_position(3, 3) cursor.set_size(1.25) world.update_layer(cursor, 5) cursor.set_sprite("Resources/Images/cursor.png") soldier = Actor() soldier.load_sprite_frames("Resources/Images/soldierA") soldier.set_size(1.0, 1.0) soldier.set_position(3.0, 3.0) soldier.play_sprite_animation(1.0, 0, 1) world.add(soldier) count = Actor() count.set_position(3.0, 3.0) count.set_sprite("Resources/Images/10.png") world.add(count)
class Agent(): def __init__(self, cfg): # Replay memory self.memory = ReplayBuffer(**cfg['agent']['memory']) # Environment configuration self.action_shape = cfg['env']['action_shape'] # Algorithm parameters self.exploration_mu, self.exploration_theta, self.exploration_sigma = cfg['agent']['noise'] self.noise = OUNoise(self.action_shape, self.exploration_mu, self.exploration_theta, self.exploration_sigma) self.gamma = cfg['agent']['gamma'] self.tau = cfg['agent']['tau'] state_flatten_shape = [np.prod(self.memory.flatten_state_shape)] # Actor Model self.actor = Actor(state_flatten_shape, self.action_shape, cfg['env']['action_range'], self.tau, self.memory.batch_size, cfg['actor']) # Critic Model self.critic = Critic(state_flatten_shape, self.action_shape, self.tau, cfg['critic']) # Flag & Counter self.add_noise = True self.episode = 0 self.max_episode_explore = 100 def init_actor_critic(self): # Initialize target model self.critic.copy_local_in_target() self.actor.copy_local_in_target() def reset(self): self.memory.reset_past() self.noise = OUNoise(self.action_shape, self.exploration_mu, self.exploration_theta, self.exploration_sigma) def step(self, action, reward, next_state, done): # Save experience / reward self.memory.add(self.last_state, action, reward, next_state, done) if done: self.reset() def act(self, state): self.last_state = state window_states = self.memory.get_state_vector(state).reshape(1, -1) action = self.actor.predict(window_states) if self.add_noise and self.episode < self.max_episode_explore: p = self.episode / self.max_episode_explore action = np.clip(action*p + (1-p)*self.noise.sample(), a_max=1, a_min=-1) return action def learn(self): if self.memory.is_sufficient(): experiences = self.memory.sample() states = experiences['state'][:, 0].reshape(self.memory.batch_size, -1) actions = experiences['action'] rewards = experiences['reward'] dones = experiences['done'] next_states = experiences['next_state'][:, 0].reshape(self.memory.batch_size, -1) # get predicted next state action and Q values from target models actions_next = self.actor.get_targets(next_states) Q_targets_next = self.critic.get_targets(next_states, actions_next) # Compute Q targets for current states and train critic model Q_targets = rewards + self.gamma * Q_targets_next * (1 - dones) critic_summaries = self.critic.fit(states, actions, Q_targets) # Train actor model action_gradients = self.critic.get_actions_grad(states, actions)[0] actor_summaries = self.actor.fit(states, action_gradients) # Soft-update target models self.critic.soft_update() self.actor.soft_update() summary_reward = summary('sample_rewards', rewards) return critic_summaries, actor_summaries, summary_reward
def __init__(self, melee, body): self.body = body Actor.__init__(self, melee)