def __init__(self, directory, run_id, plot_every, restrict_energy,
num_iterations, len_preamble, n_bits, n_hidden, stepsize,
lambda_p, initial_logstd, k, noise_power):
# System Parameters
self.num_iterations = num_iterations
self.preamble = util.generate_preamble(len_preamble, n_bits)
self.restrict_energy = restrict_energy
# Transmitter Parameters
groundtruth = util.schemes[n_bits]
t_args = [
self.preamble, restrict_energy, groundtruth, n_bits, n_hidden,
lambda_p, initial_logstd
]
r_args = [self.preamble, k]
# Receiver Parameters
self.agent_one = actor.Actor(t_args, r_args, stepsize,
directory + 'agent_1/')
self.agent_two = actor.Actor(t_args, r_args, stepsize,
directory + 'agent_2/')
# Parameters to write in the plotted diagrams
p_args_names = 'run_id total_iters len_preamble stepsize lambda_p initial_logstd noise_power restrict_energy'.split(
)
p_args_params = [
run_id, num_iterations, len_preamble, stepsize, lambda_p,
initial_logstd, noise_power, restrict_energy
]
self.p_args = dict(zip(p_args_names, p_args_params))
self.channel = Channel(noise_power)
def __init__(self, env, sess):
self.env = env
self.sess = sess
self.experience = collections.deque(maxlen=gf.experienceLength)
# seed random number
random.seed()
# create placeholders for input action and state
with tf.name_scope('InputPlaceHolders'):
self.inputState = tf.placeholder(
dtype=tf.float32,
shape=(None, self.env.observation_space.shape[0]),
name='inputState')
self.inputAction = tf.placeholder(
dtype=tf.float32,
shape=(None, self.env.action_space.shape[0]),
name='inputAction')
# create critic and target critic
self.critic = cr.Critic(sess, env, 'critic', self.inputState,
self.inputAction, True)
self.targetCritic = cr.Critic(sess, env, 'targetCritic',
self.inputState, self.inputAction, False)
# create actor and target actor
self.actor = ac.Actor(sess, env, 'actor', self.inputState,
self.inputAction, self.critic, True)
self.targetActor = ac.Actor(sess, env, 'targetActor', self.inputState,
self.inputAction, self.targetCritic, False)
# create weight update operations
with tf.name_scope('weightedCopy'):
self.tau = tf.placeholder(dtype=tf.float32, shape=(), name='tau')
self.update_target_actor = [
tf.assign(
self.targetActor.weights[i],
(tf.multiply(self.actor.weights[i], self.tau) +
tf.multiply(self.targetActor.weights[i], 1. - self.tau)))
for i in range(len(self.targetActor.weights))
]
self.update_target_critic = [
tf.assign(
self.targetCritic.weights[i],
(tf.multiply(self.critic.weights[i], self.tau) +
tf.multiply(self.targetCritic.weights[i], 1. - self.tau)))
for i in range(len(self.targetCritic.weights))
]
# create data logs holder variables
self.rewardPerEpisode = tf.placeholder(
dtype=tf.float32, shape=(), name='rewardPerEpisodePlaceHolder')
self.rpe_summary = tf.summary.scalar('rewardPerEpisode',
self.rewardPerEpisode)
# create a fileWriter (only after construction phase is over)
self.fileWriter = tf.summary.FileWriter(gf.logdir,
tf.get_default_graph())
def setup(self):
import actor
import lightSource as light
self.player = actor.Actor(const.mapWidth / 2, const.mapHeight / 2)
self.curMap = Map()
self.player.ID_ = "player"
x = actor.Actor(4, 5, '*')
y = light.LightSource()
x.addComponent(y)
x.register()
def _LoginNewClient(client):
"""
A client logs in. assign it an actor id and send
that in a login acknowldegement. Add a new actor
message for each current actor for the new client,
and tell all current clients about the new actor
that logged in. store the new actor in a mapping
from client to actor instance for future use.
"""
global g_lastActorId
global g_actorDict
newActor = actor.Actor(g_lastActorId)
g_lastActorId += 1
data = struct.pack("<BB", MSG_TYPE_LOGIN_ACK, newActor.GetId())
for priorClient, priorActor in g_actorDict.items():
p, m, a = priorActor.GetAllStateIds()
data += struct.pack("<BBBBB", MSG_TYPE_NEW_ACTOR, priorActor.GetId(),
p, m, a) # their current states
p, m, a = newActor.GetAllStateIds()
priorClient.send(
struct.pack("<BBBBB", MSG_TYPE_NEW_ACTOR, newActor.GetId(), p, m,
a)) # others about this new actor
g_actorDict[client] = newActor # store the new actor
print g_programName + 'new actor [%s] logged in and created' % newActor.GetId(
)
_PrintActorList()
return data
def __init__(self, screen):
self.screen = screen
self.accept_input = True
self.animation = None # current playing animation
self.state = ACTIVE # state that the game starts with. change to experience various features
self.pallet_town_map = map.Map(
pygame.image.load(os.path.join('maps', 'pallet_town.png')),
(-64 * 5, 0))
self.mc = actor.Actor(
pygame.image.load(os.path.join('actors', 'mc_final.png')),
64 * 4 + 4, 64 * 4)
self.actor_group = pygame.sprite.Group(self.mc)
# Initialize a screen transition
self.trans = transition.Transition(screen)
self.trans.order_swirl()
# Initialize a text manager
self.txtmgr = textmanager.Textmanager(screen)
# Do this only if DIALOGUE is the initial game state
if self.state == DIALOGUE:
self.txtmgr.set_string('Boogah boogah boogah!')
# Initiate a battle manager
self.btlmgr = battlemanager.BattleManager(screen)
def __init__(self):
"""
Base class for typers.
"""
pygame.init()
self.font = pygame.font.Font('fonts/determinationmono.ttf', 32)
self.antialias = False
self.color = pygame.Color('white')
self.text = ''
self.actor = actor.Actor()
self.scan_cursor = 0
self.delay = 0.05
self.background = pygame.Color('black')
self.symbols = []
self.display_symbols = []
self.letter_spacing = 0
self.line_spacing = 0
self.column = 0
self.line = 0
self.delay_next = None
self.delay_skipped_step = False
self.surface = pygame.Surface((1, 1))
self.on_symbol = lambda: None
self.to_on_run_loop = None
self.on_run_loop = lambda s, o: None
self.can_skip = True
self.choice_mode = False
self.choice = 0
self.pause = False
def addActor(self):
newActor = actor.Actor(defaults['actor'], defaults['actorName'])
self.script.addActor(newActor)
newActor.state.position = defaults['positions'][len(self.script.actors)
- 2]
newActor.changeBodyPosition()
self.buildFocusSelecter(newActor)
self.script.scriptChanged()
def part1():
# Input File
# filename = "./day15/input.txt"
# Sample Input
filename = "./day15/sample1.txt"
# filename = "./day15/sample2.txt"
# filename = "./day15/sample3.txt"
# filename = "./day15/sample4.txt"
# filename = "./day15/sample5.txt"
# filename = "./day15/sample6.txt"
# Cave system
cave = []
# Read the file line by line
with open(filename, "r") as infile:
for line in infile:
cave.append([ch for ch in line.rstrip()])
# Find all the goblins and elves
actors = []
for y in range(len(cave)):
for x in range(len(cave[y])):
if cave[y][x] in "GE":
actors.append(actor.Actor(x, y, cave[y][x]))
# Sort everything in reading order (first by x, then by y)
actors.sort(key=lambda char: char.x)
actors.sort(key=lambda char: char.y)
# Now find what is in everyone's range to start
for char in actors:
char.calc_in_range(cave)
# OK, let's start - starting with round 0
round = 0
# Get the initial count of goblins and elves
goblins = sum([1 for char in actors if char.actor_type == "G"])
elves = sum([1 for char in actors if char.actor_type == "E"])
# While there is still something to do
while goblins > 0 and elves > 0:
for char in actors:
# I can only move if I'm not in someone's range
if not char.in_someones_range:
# We need the shortest path to an enemy
nearest_enemies = find_nearest(char, actors, cave)
# Add the HP for the everyone left
total_hp = sum([char.HP for char in actors if char.actor_type != "."])
print(
f"Part 1: Total is {round} rounds and {total_hp} HP for {total_hp * round}."
)
def _give(self, val):
match = parens_match.match(val)
if match:
new_actor = actor.Actor(match.group('id'), match.group('name'),
self.scene)
# new_actor = self.scene.new_actor(match.group('name'), match.group('id'))
else:
next_identifier = 1
while self.scene.actors.has_key("%s_%d" %
(actor_name, next_identifier)):
next_identifier += 1
identifier = "%s_%d" % (actor_name, next_identifier)
new_actor = actor.Actor(next_identifier, val, self.scene)
self.scene.ui.inventory.put_item(new_actor)
pyglet.resource.media('sound/give.wav').play()
return True
def pause(self, show_sprites=True):
self.paused = True
if show_sprites:
self.play_sound("pause")
self.new_actor = actor.Actor("paused", "paused", self)
self.new_actor.sprite.x = self.actors["main"].sprite.x
self.new_actor.sprite.y = 600
self.add_actor(self.new_actor)
self.new_actor = actor.Actor("continue", "paused", self, None,
{"start_state": "continue"})
self.new_actor.sprite.x = self.actors["main"].sprite.x
self.new_actor.sprite.y = 450
self.add_actor(self.new_actor)
self.new_actor = actor.Actor("exit", "paused", self, None,
{"start_state": "exit"})
self.new_actor.sprite.x = self.actors["main"].sprite.x
self.new_actor.sprite.y = 350
self.add_actor(self.new_actor)
print "%s is paused." % self.name
def __init__(self):
pyxel.init(255, 255)
self.x = 0
self.time_begin = 1555749269.0
self.icon = {}
# ImageLoaderを利用したアイコンの登録
self.icon["mihon"] = actor.Actor(20, 80)
self.icon["mihon"].imageload("images/search1_8.png")
self.icon["mihon2"] = actor.Actor(40, 80)
self.icon["mihon2"].imageload("images/search2_8.png")
#self.icon["mihon"].imageload("images/mihon.png")
self.icon["arrow"] = actor.Actor(20, 40)
self.icon["arrow"].imageload("images/arrow1_up_8.png")
self.icon["arrow2"] = actor.Actor(40, 40)
self.icon["arrow2"].imageload("images/arrow2_up_8.png")
pyxel.mouse(True)
pyxel.run(self.update, self.draw)
def new_actor(self, actor_name, identifier=None, **kwargs):
if identifier is None:
next_identifier = 1
while self.actors.has_key("%s_%d" % (actor_name, next_identifier)):
next_identifier += 1
identifier = "%s_%d" % (actor_name, next_identifier)
new_actor = actor.Actor(identifier, actor_name, self, **kwargs)
if kwargs.has_key('walkpath_point'):
new_actor.walkpath_point = kwargs['walkpath_point']
new_actor.sprite.position = self.walkpath.points[
new_actor.walkpath_point]
self.actors[identifier] = new_actor
self.zenforcer.init_groups()
return new_actor
def Recv_NewActor(data):
"""
A new client logged into the server. Add it to
our actor lookup and set the initial states to those
specified on the server
"""
global g_actorDict
newActorId, p, m, a = struct.unpack("<BBBB", data[0:4])
print g_programName + 'new actor id is %s' % (newActorId, )
newActor = actor.Actor()
newActor.SetAllStateIds([p, m, a])
g_actorDict[newActorId] = newActor
print g_inputPrompt
return data[4:]
def Recv_LoginAck(data):
"""
Login acknowledgement from server. Assign
the local actor id to the value passed in
the message and create the actor instance.
The instance is stored for subsequent use
"""
global g_actorId
global g_actorDict
(g_actorId, ) = struct.unpack("<B", data[0])
print g_programName + 'Login ok, local actor id is %s' % (g_actorId, )
print g_inputPrompt
g_actorDict[g_actorId] = actor.Actor()
return data[1:]
def addCrewByName(self, name, role):
db = DatabaseConnector.DataBase()
nconst = db.get_person_id_by_name(name)
avgrating = db.get_averagerating_by_id(nconst[0])
if nconst[0] is None:
print("Actor not found!")
return
else:
ordering = len(self.actors) + 1
if ordering > 10:
print("Too many Actors in Movie " + self.title)
else:
actordata = [nconst[0], ordering, role, avgrating]
self.actors.append(actor.Actor(actordata))
db.closeConnection()
def load_actors(self):
"""Initialize actors and update them with any values specified in the info dict"""
for identifier, attrs in self.info['actors'].viewitems():
# Initialize and store
new_actor = actor.Actor(name=attrs['name'],
identifier=identifier,
scene=self,
attrs=attrs)
# Obey walk paths
if attrs.has_key('walkpath_point'):
new_actor.walkpath_point = attrs['walkpath_point']
new_actor.sprite.position = self.walkpath.points[
new_actor.walkpath_point]
self.add_actor(new_actor, reset_shadows=False)
self.update_shadows()
def __init__(self, numChans, states, numSteps):
self.actions = np.zeros((numChans + 1, numChans))
for k in range(0, numChans):
self.actions[k + 1, k] = 1
self.numChans = numChans
self.numActions = np.shape(self.actions)[0]
self.actionTally = np.zeros(numChans + 1)
self.actionHist = np.zeros((numSteps, numChans))
self.actionHistInd = np.zeros(numSteps)
self.goodChans = np.ones(numChans)
self.states = states
self.numStates = np.shape(states)[0]
self.stateHist = np.zeros((numSteps, numChans))
self.stateTally = np.zeros(self.numStates)
self.rewardHist = np.zeros(numSteps)
self.rewardTally = np.zeros(numChans + 1)
self.cumulativeReward = np.zeros(numSteps)
self.rewardTrans = np.zeros(
(self.numActions, self.numStates, self.numStates))
self.exploreHist = []
self.type = "ac"
self.hyperType = "learning"
self.policy = np.zeros(numChans)
self.n_actions = numChans + 1
self.n_features = numChans
sess = tf.Session()
self.actor_ = actor.Actor(self,
sess,
self.n_features,
self.n_actions,
lr=0.001)
self.critic_ = critic.Critic(self, sess, self.n_features, lr=0.01)
sess.run(tf.global_variables_initializer())
def __init__(self):
self.episodes = 1000
self.gamma = 0.99
self.actor = actor.Actor(4)
self.critic = critic.Critic()
actor_learning_rate = 1e-6
critic_learning_rate = 1e-8
self.actor_opt = Adam()
self.critic_opt = Adam()
current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
actor_log_dir = 'logs/gradient_tape/' + current_time + '/actor'
critic_log_dir = 'logs/gradient_tape/' + current_time + '/critic'
reward_log_dir = 'logs/gradient_tape/' + current_time + '/reward'
self.actor_summary_writer = tf.summary.create_file_writer(
actor_log_dir)
self.critic_summary_writer = tf.summary.create_file_writer(
critic_log_dir)
self.reward_summary_writer = tf.summary.create_file_writer(
reward_log_dir)
self.actor_save_dir = 'saved_models/' + current_time + '/actor'
self.critic_save_dir = 'saved_models/' + current_time + '/critic'
def main(args):
with open(args.config, 'r') as f:
config = json.load(f)
market = asset.Market()
assets = [asset.gen_asset() for _ in xrange(config['assets'])]
actors = [actor.Actor(i) for i in xrange(config['actors'])]
for a in assets:
movement_mean = random.uniform(-1.0, 1.0)
movement_std_dev = random.uniform(0.1, 2.0)
for _ in xrange(config['memory']):
for _ in xrange(0, random.randint(0, MAX_TRANSACTIONS)):
buyer, seller = random.sample(range(config['actors']), 2)
change = random.normalvariate(movement_mean, movement_std_dev)
settle_price = (1 + change / 100.) * a.price
if a.symbol not in actors[seller].positions or actors[
seller].positions[a.symbol].quantity == 0:
quantity = random.randint(0, a.outstanding)
a.outstanding -= quantity
actors[buyer].buy(a, quantity, settle_price, [market])
elif actors[seller].positions[a.symbol].quantity > 0:
shares = a.outstanding + actors[seller].positions[
a.symbol].quantity
quantity = random.randint(0, shares)
if quantity > actors[seller].positions[a.symbol].quantity:
quantity_from_seller = actors[seller].positions[
a.symbol].quantity
else:
quantity_from_seller = quantity
a.outstanding -= (quantity - quantity_from_seller)
a.price = settle_price
actors[buyer].buy(a, quantity, settle_price,
[actors[seller], market])
actors[seller].sell(a, quantity_from_seller, settle_price,
actors[buyer])
a.price = settle_price
print a
for a in actors:
print a
def construct(self):
""" Initialize physics world """
self.player = actor.Actor(self, self.game)
self.game.register_actor(self.player)
self.game.display.main_player = self.player
#self.game.register_actor(wall.Wall(self, self.game))
#self.game.register_actor(wall.Wall(self, self.game, (200, 200), (400, 200)))
#self.game.register_actor(wall.Wall(self, self.game, (400, 300), (500, 300)))
#self.game.register_actor(wall.Wall(self, self.game, (10, 10), (1000, 10)))
#self.game.register_actor(wall.Wall(self, self.game, (1000, 10), (1000, 1000)))
#self.game.register_actor(wall.Wall(self, self.game, (10, 10), (10, 1000)))
#self.game.register_actor(mob.Mob(self, self.game, random.randint(15,700), random.randint(15, 1000)))
#self.game.register_actor(mob.Mob(self, self.game, random.randint(15,700), random.randint(15, 1000)))
#self.game.register_actor(mob.Mob(self, self.game, random.randint(15,700), random.randint(15, 1000)))
#self.game.register_actor(wall.Wall(self, self.game, (-10000, 10), (10000, 10)))
self.generate_sector((0, 0))
self.generate_sector((1, 0))
self.generate_sector((-1, 0))
self.generate_sector((0, 1))
self.generate_sector((0, -1))
self.generate_sector((1, 1))
self.generate_sector((1, -1))
self.generate_sector((-1, 1))
self.generate_sector((-1, -1))
def platform_collision_presolve(arbiter, space, data):
#if arbiter.contact_point_set.normal[1] > .5:
# return False
#elif arbiter.contact_point_set.normal[1] < -.5:
# keys = pygame.key.get_pressed()
# if keys[K_s]:
# return False
# return True
return True
platform_handler = self.space.add_collision_handler(1, 2)
platform_handler.pre_solve = platform_collision_presolve
if __name__ == "__main__":
"""
Simple standalone test routine for Leaner class
"""
import json
import actor
with open('parameters.json', 'r') as f:
params = json.load(f)
params['actor']['T'] = 2000
params['actor']['wait_shared_memory_clear'] = False
param_set_id = db_initializer.initialize(params)
mp_manager = mp.Manager()
status_dict = mp_manager.dict()
shared_state = mp_manager.dict()
shared_mem = mp_manager.Queue()
status_dict['quit'] = False
status_dict['Q_state_dict_stored'] = False
status_dict['request_quit'] = False
l = Learner(params, param_set_id, status_dict, shared_state, shared_mem)
actor = actor.Actor(params, param_set_id, 0, status_dict, shared_state, shared_mem)
actor.run()
l.learn()
def spawn(
cls, location: Location, ai_cls: Optional[Type[AI]] = None
) -> actor.Actor:
self = cls()
return actor.Actor(location, self, ai_cls or cls.DEFAULT_AI)
ToDo:
-p Run on specific port
"""
MAINPR = processor.MainProcessor
SETFILE = "settings.json"
if __name__ == '__main__':
try:
with open(SETFILE, "r") as f:
settings = json.loads(f.read())
if sys.argv[1] == 'client':
sole_actor = actor.Actor(targetProcessor=MAINPR,
threads=settings['clientThreads'],
bind_ip=settings['clientIP'],
bind_port=settings['clientPort'],
address_book=settings['addressBook'])
signal.pause()
elif sys.argv[1] == 'server':
if '-r' in sys.argv[2:]:
command = ' '.join(sys.argv[(sys.argv.index('-r') + 1):])
console = actor.Console(targetProcessor=MAINPR,
cmd=command,
threads=settings['serverThreads'],
bind_ip=settings['serverIP'],
bind_port=settings['serverPort'],
address_book=settings['addressBook'])
else:
console = actor.Console(targetProcessor=MAINPR,
threads=settings['serverThreads'],
def main():
random.seed()
pygame.init()
pygame.display.set_caption("hello world")
pygame.font.init()
surface_reg = graphics.SurfaceRegistry()
game = Game()
tile_types = {
'#': TileType(False, '#', 'A hard stone wall.'),
'.': TileType(True, '.', 'A simple stone floor.'),
}
game.tile_grid = TileGridFromString(tile_types,
SILLY_STARTING_MAP_FOR_TESTING)
PLAYER = 0
player = actor.Actor(PLAYER, 'player')
player.UpdatePairs(
(('pos', (5, 5)), ('image', '@'), ('desc', "A very simple dood.")), )
player.PickUp(
Item('human feet', '', 'One right, one left.', [IntAdd('MOV', 4)]))
game.entities.append(player)
SPIDER = 1
spider = actor.Actor(PLAYER, 'spider')
spider.UpdatePairs(
(('pos', (10, 5)), ('image', 'S'), ('desc', "Creepy and crawly.")), )
spider.PickUp(
Item('small health potion', '!', 'Don\'t drop it!',
[FractionAdd('HP', 15, 'smells nice')]))
spider.PickUp(Item('gold', '0', 'Shiny', []))
game.entities.append(spider)
# Spawn a random item to play with.
for _ in range(5):
valid_tiles = ValidTiles(game.tile_grid, game.entities)
valid_pos = random.choice(valid_tiles)
random_item = random.choice(item_compendium)
game.entities.append(SpawnItem(random_item, 1, valid_pos))
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
info_surface = screen.subsurface(
(graphics.TILE_SIZE * 41, graphics.TILE_SIZE * 2,
graphics.TILE_SIZE * 10, graphics.TILE_SIZE * 40))
running = True
map_frame = graphics.Frame(
surface_reg, screen,
(0, 0, graphics.TILE_SIZE * 40, graphics.TILE_SIZE * 40))
selector = RegisterMarkerSurface(surface_reg, [0, 100, 100, 10])
MoveAction.MARKER_SURFACE = RegisterMarkerSurface(surface_reg,
[100, 0, 100, 10])
GetAction.MARKER_SURFACE = RegisterMarkerSurface(surface_reg,
[50, 50, 100, 10])
MeleAction.MARKER_SURFACE = RegisterMarkerSurface(surface_reg,
[200, 50, 50, 10])
actions = None
previous_mouse_grid_pos = None
desc = None
clock = pygame.time.Clock()
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.MOUSEMOTION:
game.mouse_pos = pygame.mouse.get_pos()
elif event.type == pygame.MOUSEBUTTONDOWN:
game.left_mouse = True
if game.KillPending():
# This is probably not necessary in the long run, but for the moment it
# prevents the "attack" marker from appearing after killing an entity.
actions = None
if not actions:
actions = GenerateActions(game, player)
time_delta = clock.tick()
screen_center = map_frame.Dimensions() / 2
center_to_player = Vec2d(
player.pos[0] * graphics.TILE_SIZE,
player.pos[1] * graphics.TILE_SIZE) - screen_center
camera_offset_diff = center_to_player - map_frame.camera_offset
if (Distance(map_frame.camera_offset, center_to_player) >
graphics.TILE_SIZE * 0.5):
map_frame.camera_offset = Lerp(map_frame.camera_offset,
center_to_player,
1.0 / 400 * time_delta)
grid_mouse_pos = graphics.GridPos(map_frame.camera_offset,
game.mouse_pos)
if game.left_mouse:
decided_action = None
for a in actions or []:
if a.Pos() == grid_mouse_pos:
decided_action = a
if decided_action:
decided_action.Run(game, player)
actions = None
else:
# TODO: Eventually, there should be an ingame log and this'll show up
# there.
print('Nothing to do, there.')
game.left_mouse = False
GRID = 0
ACTOR = 1
OVERLAY = 2
# Render the screen: tiles, entities, UI elements.
for pos, type in game.tile_grid.Iterate():
map_frame.AddTask(graphics.TiledPos(pos), GRID,
type.surface_handle())
for e in game.entities:
image = e.GetOr('image')
pos = e.GetOr('pos')
if not (image and pos): continue
map_frame.AddTask(graphics.TiledPos(pos), ACTOR, image)
map_frame.AddTask(graphics.TiledPos(grid_mouse_pos),
OVERLAY,
selector,
rgb_add=True)
for a in actions or []:
for m in a.Markers():
if not (m.pos and m.surface): continue
map_frame.AddTask(graphics.TiledPos(m.pos),
OVERLAY,
m.surface,
rgb_add=True)
if not game.tile_grid.HasTile(grid_mouse_pos):
desc = None
else:
desc = f'{grid_mouse_pos}:\n{game.tile_grid.Get(grid_mouse_pos).desc()}'
for e in game.entities:
pos = e.GetOr('pos')
if pos and pos == grid_mouse_pos:
desc = f'{grid_mouse_pos}:\n{str(e)}'
break
previous_mouse_grid_pos = grid_mouse_pos
if desc:
graphics.BlitText(surface_reg, info_surface, desc)
map_frame.Render()
pygame.display.flip()
screen.fill((0, 0, 0))
def populate_movies():
"""Populates a list of movies."""
world_war_z = media.Movie({
"film_id":
"tt0816711",
"film_title":
"World War Z",
"film_synopsis":
"A epidemiologist struggles to find the cure for the zombie virus "
"battling against time",
"film_poster_url":
"https://upload.wikimedia.org/wikipedia/en/d/dc/World_War_Z_poster"
".jpg",
"film_trailer_url":
"https://www.youtube.com/watch?v=M5Y_nOkFvbY",
"film_actors": [actor.Actor("Brad", "Pitt")],
"film_year":
2013
})
zombieland = media.Movie({
"film_id":
"tt127834",
"film_title":
"Zombieland",
"film_synopsis":
"A zombie comedy about a band of zombie apocalypse survivors "
"looking for a safe haven in the United States.",
"film_poster_url":
"https://upload.wikimedia.org/wikipedia/en/a/a3/"
"Zombieland-poster.jpg",
"film_trailer_url":
"https://www.youtube.com/watch?v=8m9EVP8X7N8",
"film_actors": [
actor.Actor("Woody", "Harrelson"),
actor.Actor("Jesse", "Eisenberg"),
actor.Actor("Emma", "Stone")
],
"film_year":
2009
})
shaun_of_the_dead = media.Movie({
"film_id":
"tt0365748",
"film_title":
"Shaun of the Dead",
"film_synopsis":
"Friends fight their way through zombies in hilarious fashion.",
"film_poster_url":
"http://landmarktheatre.org/wp-content/uploads/"
"2014/10/Shaun-of-the-Dead-Poster.jpg",
"film_trailer_url":
"https://www.youtube.com/watch?v=yfDUv3ZjH2k",
"film_actors":
[actor.Actor("Simon", "Pegg"),
actor.Actor("Nick", "Frost")],
"film_year":
2004
})
twenty_eight_days_later = media.Movie({
"film_id":
"tt0289043",
"film_title":
"28 Days Later",
"film_synopsis":
"A coma patient awakens to discover that infected "
"cannibals have taken over London, and maybe the world.",
"film_poster_url":
"http://www.movierulz.to/wp-content/uploads/2013/"
"07/28-Days-Later.jpg",
"film_trailer_url":
"https://www.youtube.com/watch?v=c7ynwAgQlDQ",
"film_actors": [actor.Actor("Cillian", "Murphy")],
"film_year":
2002
})
dawn_of_the_dead_remake = media.Movie({
"film_id":
"tt0363547",
"film_title":
"Dawn of the Dead",
"film_synopsis":
"A group of survivors takes refuge in a mall.",
"film_poster_url":
"https://upload.wikimedia.org/wikipedia/en/1/16/"
"Dawn_of_the_Dead_2004_movie.jpg",
"film_trailer_url":
"https://www.youtube.com/watch?v=rhsutNfvuAY",
"film_actors":
[actor.Actor("Sarah", "Polley"),
actor.Actor("Ving", "Rhames")],
"film_year":
2004
})
dead_snow = media.Movie({
"film_id":
"tt127834",
"film_title":
"Dead Snow",
"film_synopsis":
"A group of Norweigan friends combats Nazi zombies.",
"film_poster_url":
"https://upload.wikimedia.org/wikipedia/en/1/11/"
"Dodsno.jpg",
"film_trailer_url":
"https://www.youtube.com/watch?v=lEQwEmeWnyI",
"film_actors":
[actor.Actor("Vegar", "Hoel"),
actor.Actor("Charlotte", "Frogner")],
"film_year":
2009
})
# Return the list of the movies to be rendered on the webpage
return [
world_war_z, zombieland, shaun_of_the_dead, twenty_eight_days_later,
dawn_of_the_dead_remake, dead_snow
]
li, = ax.plot(index_list, reward_list, '-')
# draw and show it
fig.canvas.draw()
plt.show(block=False)
epsilon = 0.6
#initialize gym environment
env = gym.make("CartPole-v0")
observation = env.reset()
print observation.shape
rewardList = []
# Monitor Env
#env.monitor.start('cartpole-hill/', force=True)
#Initialize Actor
actor = actor.Actor(4, 2)
actor.createModel()
#Initialize Critic
critic = critic.Critic(4)
critic.createModel()
#for n policies
for i in range(NUM_EPOCHS):
#epsilon=epsilon-0.4*(float(i)/NUM_EPOCHS)
if epsilon > 0.1:
epsilon = epsilon - 0.001
#for each rollout <s,a,r>
observation_old = env.reset()
T = []
tot_reward = 0
for k in range(1000):
#env.render()
vacation = movie.Movie(
"National Lampoon's Christmas Vacation",
"http://upload.wikimedia.org/wikipedia/en/5/53/NationalLampoonsChristmasVacationPoster.JPG",
"www.youtube.com/watch?v=NBTTipJX-h4")
dumb = movie.Movie(
"Dumb & Dumber",
"http://upload.wikimedia.org/wikipedia/en/6/64/Dumbanddumber.jpg",
"www.youtube.com/watch?v=2fvoau0ekWk")
###########################
# Actors :
###########################
leonardo = actor.Actor(
"Leonardo Dicaprio",
"https://pbs.twimg.com/profile_images/344513261567840137/c253a2c039a701b65d5b2e92fc1735cc_normal.jpeg",
"http://en.wikipedia.org/wiki/Leonardo_DiCaprio")
duchess = actor.Actor(
"Margot Robbie",
"https://pbs.twimg.com/profile_images/425523950341218305/DSrCtA3Y_normal.jpeg",
"http://en.wikipedia.org/wiki/Margot_Robbie")
donnie = actor.Actor(
"Jonah Hill",
"https://gp3.googleusercontent.com/-IezDMxxplG8/AAAAAAAAAAI/AAAAAAAAAB8/Tr6-JLpNISE/s48-c-k-no/photo.jpg",
"http://en.wikipedia.org/wiki/Jonah_Hill")
travolta = actor.Actor(
"John Travolta",
"https://gp3.googleusercontent.com/-OgFiKlkXz48/AAAAAAAAAAI/AAAAAAAAACg/JCLtS6y72NQ/s48-c-k-no/photo.jpg",
def train_step(self, progress):
"""
Update policy through the following 4 steps:
1. Generate a batch of episodes
2. Define Q through Critic
3. Define V by minimizing the dual
4. Define a new policy by fitting an actor
Updates:
self.q_critic
self.v_critic
self.actor
Calls:
generate_episode
q_critic.Q_Critic
v_critic.V_Critic
actor.Actor
:return: None
"""
prev_time = time.clock()
for i in range(0, NUMBER_OF_BATCHES):
self.generate_episode()
print("---Generated Episodes in ", int(time.clock() - prev_time),
" Seconds---")
n = 0.0
reward_sum = 0.0
for i in range(0, NUMBER_OF_BATCHES):
rollout = self.rollouts[0]
for j in range(0, rollout.length):
reward_sum += rollout.rewards[j]
n += 1
average_reward = reward_sum / n
print("---------------------")
print("----Average Reward: ", average_reward, "----")
print("---------------------")
prev_time = time.clock()
self.q_critic = q_critic.QCritic(self.rollouts)
print("---------------------")
print("---Q-Critic fitted in ", int(time.clock() - prev_time),
" Seconds---")
print("---------------------")
prev_time = time.clock()
self.v_critic = v_critic.VCritic(self.rollouts, self.q_critic)
print("---------------------")
print("---V-Critic fitted in ", int(time.clock() - prev_time),
" Seconds---")
print("---------------------")
prev_time = time.clock()
self.actor = ac.Actor(self.rollouts, self.q_critic, self.v_critic,
self.actor, progress)
print("---------------------")
print("---Policy fitted in ", int(time.clock() - prev_time),
" Seconds---")
print("---------------------")
self.rollouts = ()
self.average_rewards += (average_reward, )
while not count:
count = input("Enter an integer wordcount greater than 1000: "
) # TODO: verify `count` is over 1000
try:
count = int(count)
break
except ValueError:
print("%s isn’t an integer…" % count)
count = None
output = codecs.open(
os.path.split(current_file_path)[0] + "/output/output.html", "w",
"utf-8")
tng_actors = {
member: actor.Actor(all_tng_text, member, cast, 3)
for member in cast
}
html = "<html lang='en'>\n <head>\n <title>B-9 Indifference</title>\n " + \
"<meta charset='UTF-8'>\n " + \
"<link href='styles.css' rel='stylesheet'/>\n </head>\n <body>"
word_count = count
script = script.Script(1000, tng_actors)
while word_count > 0:
episode_text = script.generate_episode()
episode_length = len(
list(
filter(None,
re.split(r'\s+', re.sub(r'<(.*?)>+', '',
episode_text)))))
print()
checkname(actor)
checkalign(actor)
print("Strength =", actor.get_str(), "Intelligence =", actor.get_int())
print("Vitality =", actor.get_vit(), "Dexterity =", actor.get_dex())
print("Charisma =", actor.get_chr(), "Wisdom =", actor.get_wis())
print("Current level is ",
actor.get_level(),
", HP is ",
actor.get_hp(),
"/",
actor.get_maxhp(),
sep="")
print("Current experience is ", actor.get_exp(), ", ", end='', sep='')
checknextlvl(Hero)
print()
Hero = actor.Actor()
Hero.set_name(strings.defaultname)
Hero.set_alignment(0)
rollme(Hero)
checkstats(Hero)
while True:
Hero.damage(Hero.attack(dice.rollprint(Hero), Hero), Hero)
checkstats(Hero)
if Hero.get_hp() < 1:
break
keyboard.wait(" ")
# time.sleep(5)
