def setup():
global base
global alt_buffer
global alt_render
global alt_texture
global alt_cam
base = ShowBase()
winprops = WindowProperties.size(2 * WIDTH, 2 * HEIGHT)
props = FrameBufferProperties()
props.setRgbColor(1)
props.setAlphaBits(1)
props.setDepthBits(1)
alt_buffer = base.graphicsEngine.makeOutput(
base.pipe, "offscreenBuffer", -200, props, winprops,
GraphicsPipe.BFFbPropsOptional | GraphicsPipe.BFRefuseWindow,
base.win.getGsg(), base.win)
alt_texture = Texture()
alt_texture.setMinfilter(Texture.FTLinear)
alt_texture.setFormat(Texture.FRgba32)
alt_buffer.addRenderTexture(alt_texture, GraphicsOutput.RTMCopyRam)
alt_cam = base.makeCamera(alt_buffer)
alt_buffer.setClearColor(VBase4(1.0, 1.0, 1.0, 1.0))
alt_render = NodePath("new render")
if args.mode == 'rgb':
pass
elif args.mode == 'normals':
shader = Shader.load(Shader.SLGLSL, 'shaders/normrgb.vert',
'shaders/normrgb.frag')
alt_render.setShader(shader)
elif args.mode == 'depth':
shader = Shader.load(Shader.SLGLSL, 'shaders/depth.vert',
'shaders/depth.frag')
alt_render.setShader(shader)
alt_render.setAntialias(AntialiasAttrib.MMultisample)
lens = PerspectiveLens()
lens.setFov(FOV_ANGLE_DEG)
lens.setFocalLength(FOCAL_LENGTH_IN)
alt_cam.node().setLens(lens)
alt_cam.node().setScene(alt_render)
def setup():
global base
global alt_buffer
global alt_render
global alt_texture
global alt_cam
base = ShowBase()
winprops = WindowProperties.size(2*WIDTH, 2*HEIGHT)
props = FrameBufferProperties()
props.setRgbColor(1)
props.setAlphaBits(1)
props.setDepthBits(1)
alt_buffer = base.graphicsEngine.makeOutput(base.pipe, "offscreenBuffer",
-200, props, winprops,
GraphicsPipe.BFFbPropsOptional | GraphicsPipe.BFRefuseWindow,
base.win.getGsg(), base.win)
alt_texture = Texture()
alt_texture.setMinfilter(Texture.FTLinear)
alt_texture.setFormat(Texture.FRgba32)
alt_buffer.addRenderTexture(alt_texture, GraphicsOutput.RTMCopyRam)
alt_cam = base.makeCamera(alt_buffer)
alt_buffer.setClearColor(VBase4(1.0,1.0,1.0,1.0))
alt_render= NodePath("new render")
if args.mode=='rgb':
pass
elif args.mode=='normals':
shader = Shader.load(Shader.SLGLSL, 'shaders/normrgb.vert', 'shaders/normrgb.frag')
alt_render.setShader(shader)
elif args.mode=='depth':
shader = Shader.load(Shader.SLGLSL, 'shaders/depth.vert', 'shaders/depth.frag')
alt_render.setShader(shader)
alt_render.setAntialias(AntialiasAttrib.MMultisample)
lens = PerspectiveLens()
lens.setFov(FOV_ANGLE_DEG)
lens.setFocalLength(FOCAL_LENGTH_IN)
alt_cam.node().setLens(lens)
alt_cam.node().setScene(alt_render)
class ColorWorld(object):
def __init__(self, config=None):
# keep track of velocity, this allows me to counteract joystick with keyboard
self.velocity = LVector3(0)
if config is None:
self.config = {}
execfile('config.py', self.config)
else:
self.config = config
self.reward = None
if pydaq:
self.reward = pydaq.GiveReward()
self.reward_count = 0
# self.color_map always corresponds to (r, g, b)
# does not change during game, each game uses a particular color space
self.color_dict = square.make_color_map(self.config['colors'])
# sets the range of colors for this map
self.c_range = self.config['c_range']
# color variables (make dictionary?)
# color_list is set in beginning, and then after that this is only
# called again for non-random (training)
self.color_list = square.set_start_position_colors(self.config)
self.color_match = [0, 0, 0]
self.color_tolerance = []
self.last_avt, self.avt_factor = square.translate_color_map(
self.config, self.color_dict, self.color_list)
print 'starting avt position', self.last_avt
print 'map avatar factor', self.avt_factor
self.random = True
if self.config.get('match_direction'):
self.random = False
# adjustment to speed so corresponds to gobananas task
# 7 seconds to cross original environment
# speed needs to be adjusted to both speed in original
# environment and c_range of colors
# self.speed = 0.05 * (self.c_range[1] - self.c_range[0])
# speed is own variable, so can be changed during training.
self.speed = self.config['speed']
# map avatar variables
self.render2d = None
self.match_square = None
self.map_avt_node = []
# need a multiplier to the joystick output to tolerable speed
self.vel_base = 3
self.max_vel = [500, 500, 0]
self.card = None
self.base = ShowBase()
self.base.disableMouse()
# assume we are showing windows unless proven otherwise
if self.config.get('win', True):
# only need inputs if we have a window
self.inputs = Inputs(self.base)
props = WindowProperties()
props.setCursorHidden(True)
props.setForeground(True)
print self.config.get('resolution')
if self.config.get('resolution'):
props.set_size(int(self.config['resolution'][0]),
int(self.config['resolution'][1]))
props.set_origin(0, 0)
else:
props.set_size(600, 600)
props.set_origin(400, 50)
self.base.win.requestProperties(props)
# print self.base.win.get_size()
# setup color map on second window
sq_node = square.setup_square(self.config)
self.setup_display2(sq_node)
# print 'background color', self.base.getBackgroundColor()
# create the avatar
self.avatar = NodePath(ActorNode("avatar"))
self.avatar.reparentTo(self.base.render)
self.avatar.setH(self.base.camera.getH())
self.base.camera.reparentTo(self.avatar)
self.base.camera.setPos(0, 0, 0)
# initialize task variables
self.frame_task = None
self.started_game = None
self.showed_match = None
self.gave_reward = None
# initialize and start the game
self.set_next_trial()
# print 'end init'
def start_loop(self):
# need to get new match
print 'start loop'
self.started_game = self.base.taskMgr.doMethodLater(
5, self.start_play, 'start_play')
self.showed_match = self.base.taskMgr.add(self.show_match_sample,
'match_image')
# Task methods
def show_match_sample(self, task):
print 'show match sample'
print self.color_match[:]
# match_image.fill(*self.color_match[:])
card = CardMaker('card')
color_match = self.color_match[:]
# add alpha channel
color_match.append(1)
print color_match
card.set_color(*color_match[:])
card.set_frame(-12, -8, 0, 4)
# log this
self.card = self.base.render.attach_new_node(card.generate())
return task.done
def start_play(self, task):
print 'start play'
# log this
self.base.taskMgr.remove('match_image')
self.card.removeNode()
# print self.base.render.ls()
self.frame_task = self.base.taskMgr.add(self.game_loop, "game_loop")
self.frame_task.last = 0 # initiate task time of the last frame
# log this
self.base.setBackgroundColor(self.color_list[:])
return task.done
def game_loop(self, task):
dt = task.time - task.last
task.last = task.time
self.velocity = self.inputs.poll_inputs(self.velocity)
move = self.move_avatar(dt)
stop = self.change_background(move)
self.move_map_avatar(move, stop)
match = self.check_color_match()
if match:
self.give_reward()
return task.done
return task.cont
def reward_loop(self, task):
self.reward_count += 1
if self.reward_count <= self.config['num_beeps']:
if self.reward:
# log this
print 'give a bloody reward already'
self.reward.pumpOut()
print 'give reward'
return task.again
else:
self.end_loop()
return task.done
def move_avatar(self, dt):
# print 'velocity', self.velocity
# this makes for smooth (correct speed) diagonal movement
# print 'velocity', self.velocity
magnitude = max(abs(self.velocity[0]), abs(self.velocity[1]))
move = None
if self.velocity.normalize():
# go left in increasing amount
# print 'dt', dt
# print 'normalized'
# print 'velocity', self.velocity
# print 'magnitude', magnitude
self.velocity *= magnitude
# print 'velocity', self.velocity
# this makes for smooth movement
move = self.velocity * self.vel_base * dt
# print move
self.avatar.setFluidPos(self.avatar, move)
return move
def change_background(self, move):
stop = [True, True, True]
if move:
# print move
move *= self.speed
for i in range(3):
value = self.color_dict[i]
if value is not None:
stop[i] = False
# keys correspond to x,y,z
# values correspond to r,g,b
if i == 2:
# z axis is treated differently
# need to work on this. z should
# be at min when both x and y are at max
# taking the average is not quite right...
z_move = (move[0] + move[1]) / 2
# print z_move
self.color_list[value] -= z_move
else:
self.color_list[value] += move[i]
if self.color_list[value] < self.c_range[0]:
self.color_list[value] = self.c_range[0]
stop[i] = True
elif self.color_list[value] > self.c_range[1]:
self.color_list[value] = self.c_range[1]
stop[i] = True
# log this
self.base.setBackgroundColor(self.color_list[:])
# print self.base.getBackgroundColor()
return stop
def move_map_avatar(self, move, stop):
# print move
# avatar is mapped assuming c_range of 0.5. What do I need to
# change to use a different c_range? c_range of one is twice
# the
if move:
avt = LineSegs()
avt.setThickness(1)
avt.setColor(1, 1, 1)
# print 'last', self.last_avt
avt.move_to(self.last_avt[0], -5, self.last_avt[1])
# print 'move', move
new_move = [
i + (j * self.avt_factor) for i, j in zip(self.last_avt, move)
]
# new_move = [i + j for i, j in zip(self.last_avt, move)]
# would it be better to have a local stop condition?
if stop[0]:
new_move[0] = self.last_avt[0]
# print 'stop x', self.last_avt[0]
if stop[1]:
new_move[1] = self.last_avt[1]
# print 'stop y', self.last_avt[1]
# print 'new', new_move
self.last_avt = [new_move[0], new_move[1]]
avt.draw_to(new_move[0], -5, new_move[1])
self.map_avt_node.append(
self.render2d.attach_new_node(avt.create()))
# print self.map_avt_node[-1]
# can't let too many nodes pile up
if len(self.map_avt_node) > 299:
# removing the node does not remove the object from the list
for i, j in enumerate(self.map_avt_node):
j.removeNode()
if i > 49:
break
del self.map_avt_node[0:50]
def check_color_match(self):
# print 'match this', self.color_tolerance
# print self.color_list
check_color = [
j[0] < self.color_list[i] < j[1]
for i, j in enumerate(self.color_tolerance)
]
# print check_color
if all(check_color):
return True
else:
return False
def give_reward(self):
# clear the background
self.base.setBackgroundColor(0.41, 0.41, 0.41)
print 'give first reward'
self.reward_count = 1
if self.reward:
# log this
self.reward.pumpOut()
self.gave_reward = self.base.taskMgr.doMethodLater(
self.config['pump_delay'], self.reward_loop, 'reward_loop')
def end_loop(self):
print 'end loop'
# clear avatar map
self.clear_avatar_map()
# if there is a match set, return to center of color gradient,
# set new match, if applicable
self.set_next_trial()
def clear_avatar_map(self):
for i, j in enumerate(self.map_avt_node):
j.removeNode()
self.map_avt_node = []
def plot_match_square(self, corners):
print 'plot match square'
print corners
match = LineSegs()
match.setThickness(1.5)
match.setColor(0, 0, 0)
match.move_to(corners[0][0], -5, corners[1][0])
match.draw_to(corners[0][1], -5, corners[1][0])
match.draw_to(corners[0][1], -5, corners[1][1])
match.draw_to(corners[0][0], -5, corners[1][1])
match.draw_to(corners[0][0], -5, corners[1][0])
# print self.render2d
self.match_square = self.render2d.attach_new_node(match.create())
def create_avatar_map_match_square(self, config=None):
print 'make new square for map'
if config is not None:
config_dict = config
else:
config_dict = self.config
# create square on avatar map for new color match
map_color_match, factor = square.translate_color_map(
config_dict, self.color_dict, self.color_match)
tolerance = config_dict['tolerance'] * factor
map_color_tolerance = [(i - tolerance, i + tolerance)
for i in map_color_match]
print map_color_tolerance
if self.render2d:
if self.match_square:
self.match_square.removeNode()
self.plot_match_square(map_color_tolerance)
def set_next_trial(self):
print 'set next trial'
# move avatar back to beginning position, only matters for
# showing card for next color match
self.avatar.set_pos(-10, -10, 2)
# set color_list with starting color
# if random, won't use this again, but for manual, will
# return to center
# need to update self.config to new direction, if there is one
if self.config.get('match_direction'):
self.check_key_map()
# return to center, otherwise random will start where you left off
self.color_list = square.set_start_position_colors(self.config)
# starting position for map avatar, just translate new color_list
self.last_avt, self.avt_factor = square.translate_color_map(
self.config, self.color_dict, self.color_list)
print 'start color', self.color_list
print self.color_dict
# again need to update self.config for match if using keys
self.color_match = square.set_match_colors(self.config,
self.color_dict)
# sets the tolerance for how close to a color for reward
self.color_tolerance = [(i - self.config['tolerance'],
i + self.config['tolerance'])
for i in self.color_match]
print 'color match', self.color_match
print 'color tolerance', self.color_tolerance
self.create_avatar_map_match_square(self.config)
# start the game
self.start_loop()
def check_key_map(self):
if self.config['colors'][0]:
if self.inputs.key_map['r']:
self.config['match_direction'] = ['right']
elif self.inputs.key_map['r'] is not None:
self.config['match_direction'] = ['left']
elif self.config['colors'][1]:
if self.inputs.key_map['f']:
self.config['match_direction'] = ['front']
elif self.inputs.key_map['f'] is not None:
self.config['match_direction'] = ['back']
def setup_display2(self, display_node):
print 'setup display2'
props = WindowProperties()
props.set_cursor_hidden(True)
props.set_foreground(False)
if self.config.get('resolution'):
props.setSize(700, 700)
props.setOrigin(-int(self.config['resolution'][0] - 5), 5)
else:
props.setSize(300, 300)
props.setOrigin(10, 10)
window2 = self.base.openWindow(props=props, aspectRatio=1)
lens = OrthographicLens()
lens.set_film_size(2, 2)
lens.setNearFar(-100, 100)
self.render2d = NodePath('render2d')
self.render2d.attach_new_node(display_node)
camera2d = self.base.makeCamera(window2)
camera2d.setPos(0, -10, 0)
camera2d.node().setLens(lens)
camera2d.reparentTo(self.render2d)
class PlayWorld(object):
def __init__(self, config=None):
if config is None:
self.config = {}
execfile('play_config.py', self.config)
else:
self.config = config
self.reward = None
print self.config['pydaq']
if pydaq and self.config.setdefault('pydaq', True) is not None:
self.reward = pydaq.GiveReward()
self.reward_count = 0
# adjustment to speed so corresponds to gobananas task
# 7 seconds to cross original environment
# speed needs to be adjusted to both speed in original
# environment and c_range of colors
# self.speed = 0.05 * (self.c_range[1] - self.c_range[0])
# speed is own variable, so can be changed during training.
self.speed = self.config['speed']
# need a multiplier to the joystick output to tolerable speed
self.vel_base = 4
self.max_vel = [500, 500, 0]
self.base = ShowBase()
self.base.disableMouse()
# self.base.setFrameRateMeter(True)
# assume we are showing windows unless proven otherwise
if self.config.get('win', True):
# only need inputs if we have a window
self.inputs = Inputs(self.base)
props = WindowProperties()
props.setCursorHidden(True)
props.setForeground(True)
print self.config.get('resolution')
if self.config.get('resolution'):
# main window
props.set_size(int(self.config['resolution'][0]), int(self.config['resolution'][1]))
# props.set_origin(1920, 0)
props.set_origin(500, 0)
else:
props.set_size(600, 600)
props.set_origin(400, 50)
self.base.win.requestProperties(props)
# print 'background color', self.base.getBackgroundColor()
# field = self.base.loader.loadModel("../goBananas/models/play_space/field.bam")
field = self.base.loader.loadModel("../goBananas/models/play_space/round_courtyard.bam")
field.setPos(0, 0, 0)
field.reparent_to(self.base.render)
field_node_path = field.find('**/+CollisionNode')
field_node_path.node().setIntoCollideMask(0)
sky = self.base.loader.loadModel("../goBananas/models/sky/sky_kahana2.bam")
sky.setPos(0, 0, 0)
sky.setScale(1.6)
sky.reparentTo(self.base.render)
windmill = self.base.loader.loadModel("../goBananas/models/windmill/windmill.bam")
windmill.setPos(-10, 30, -1)
windmill.setScale(0.03)
windmill.reparentTo(self.base.render)
# mountain = self.base.loader.loadModel("../goBananas/models/mountain/mountain.bam")
# mountain.setScale(0.0005)
# mountain.setPos(10, 30, -0.5)
# create the avatar
self.avatar = NodePath(ActorNode("avatar"))
self.avatar.reparentTo(self.base.render)
self.avatar.setPos(0, 0, 1)
self.avatar.setScale(0.5)
pl = self.base.cam.node().getLens()
pl.setFov(60)
self.base.cam.node().setLens(pl)
self.base.camera.reparentTo(self.avatar)
# initialize task variables
self.frame_task = None
self.started_game = None
self.showed_match = None
self.gave_reward = None
# initialize and start the game
self.set_next_trial()
# print 'end init'
def start_loop(self):
# need to get new match
self.start_play()
def start_play(self):
print 'start play'
# log this
# print self.base.render.ls()
self.frame_task = self.base.taskMgr.add(self.game_loop, "game_loop")
self.frame_task.last = 0 # initiate task time of the last frame
def game_loop(self, task):
dt = task.time - task.last
task.last = task.time
velocity = self.inputs.poll_inputs(LVector3(0))
self.move_avatar(dt, velocity)
return task.cont
def reward_loop(self, task):
self.reward_count += 1
if self.reward_count <= self.config['num_beeps']:
if self.reward:
# log this
print 'give a bloody reward already'
self.reward.pumpOut()
print 'give reward'
return task.again
else:
self.end_loop()
return task.done
def move_avatar(self, dt, velocity):
# print 'velocity', self.velocity
self.avatar.setH(self.avatar.getH() - velocity[0] * 1.1)
move = LVector3(0, velocity[1], 0)
self.avatar.setPos(self.avatar, move * dt * self.vel_base)
def give_reward(self):
# clear the background
self.base.setBackgroundColor(0.41, 0.41, 0.41)
print 'give first reward'
self.reward_count = 1
if self.reward:
# log this
self.reward.pumpOut()
self.gave_reward = self.base.taskMgr.doMethodLater(self.config['pump_delay'], self.reward_loop, 'reward_loop')
def end_loop(self):
print 'end loop'
# clear avatar map
# if there is a match set, return to center of color gradient,
# set new match, if applicable
self.set_next_trial()
def set_next_trial(self):
print 'set next trial'
# move avatar back to beginning position, only matters for
# showing card for next color match
# self.avatar.set_pos(-10, -10, 2)
# start the game
self.start_loop()
def check_key_map(self):
if self.config['colors'][0]:
if self.inputs.key_map['r']:
self.config['match_direction'] = ['right']
elif self.inputs.key_map['r'] is not None:
self.config['match_direction'] = ['left']
elif self.config['colors'][1]:
if self.inputs.key_map['f']:
self.config['match_direction'] = ['front']
elif self.inputs.key_map['f'] is not None:
self.config['match_direction'] = ['back']
def setup_display2(self, display_node):
print 'setup display2'
props = WindowProperties()
props.set_cursor_hidden(True)
props.set_foreground(False)
if self.config.get('resolution'):
props.setSize(700, 700)
props.setOrigin(-int(self.config['resolution'][0] - 5), 5)
else:
props.setSize(300, 300)
props.setOrigin(10, 10)
window2 = self.base.openWindow(props=props, aspectRatio=1)
lens = OrthographicLens()
lens.set_film_size(2, 2)
lens.setNearFar(-100, 100)
self.render2d = NodePath('render2d')
self.render2d.attach_new_node(display_node)
camera2d = self.base.makeCamera(window2)
camera2d.setPos(0, -10, 0)
camera2d.node().setLens(lens)
camera2d.reparentTo(self.render2d)
class SceneGenerator():
def __init__(self):
self.base = ShowBase()
#wp = WindowProperties()
#wp.setSize(640, 480)
#self.base.win.requestProperties(wp)
self.base.camera.setPos(0, 0, 0)
self.base.camLens.setNearFar(0.01, 1000.0)
self.base.camLens.setFov(50)
self.base.setBackgroundColor(1, 1, 1)
if not self.base.win.getGsg().getSupportsBasicShaders():
print(
"Toon Shader: Video driver reports that Cg shaders are not supported."
)
return
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(
self.base.loader.loadShader("shader/lightingGen.sha"))
self.base.cam.node().setInitialState(tempnode.getState())
light = self.base.render.attachNewNode("light")
light.setPos(30, -50, 0)
self.base.render.setShaderInput("light", light)
normalsBuffer = self.base.win.makeTextureBuffer("normalsBuffer", 0, 0)
normalsBuffer.setClearColor(LVecBase4(0.5, 0.5, 0.5, 1))
self.normalsBuffer = normalsBuffer
normalsCamera = self.base.makeCamera(
normalsBuffer, lens=self.base.cam.node().getLens())
normalsCamera.node().setScene(self.base.render)
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(self.base.loader.loadShader("shader/normalGen.sha"))
normalsCamera.node().setInitialState(tempnode.getState())
drawnScene = normalsBuffer.getTextureCard()
drawnScene.setTransparency(1)
drawnScene.setColor(1, 1, 1, 0)
drawnScene.reparentTo(self.base.render2d)
#self.base.drawnScene = drawnScene
self.separation = 0.00065
self.cutoff = 0.3
inkGen = self.base.loader.loadShader("shader/inkGen.sha")
drawnScene.setShader(inkGen)
drawnScene.setShaderInput(
"separation", LVecBase4(self.separation, 0, self.separation, 0))
drawnScene.setShaderInput("cutoff", LVecBase4(self.cutoff))
# Load a model
#self.smiley = self.loader.loadModel('smiley')
#self.smiley.reparentTo(self.render)
#self.smiley.setPos(0, 10.0, 0)
self.actors = [Actor(), Actor(), Actor(), Actor()]
self.actors[0].loadModel('models/dekiruo/dekiruo')
self.actors[0].reparentTo(self.base.render)
self.actors[0].loadAnims(
{'normal': 'models/dekiruo/dekiruo-Anim_normal'})
self.actors[0].loadAnims(
{'anger': 'models/dekiruo/dekiruo-Anim_anger'})
self.actors[0].loadAnims(
{'sadness2crying': 'models/dekiruo/dekiruo-Anim_sadness2crying'})
self.actors[0].loadAnims(
{'sleep': 'models/dekiruo/dekiruo-Anim_sleep'})
self.actors[0].loadAnims(
{'smile': 'models/dekiruo/dekiruo-Anim_smile'})
self.actors[0].loadAnims(
{'surprised': 'models/dekiruo/dekiruo-Anim_surprised'})
for i in range(1, len(self.actors)):
self.actors[i].loadModel('models/dekinaio/dekinaio')
self.actors[i].reparentTo(self.base.render)
self.actors[i].loadAnims(
{'normal': 'models/dekinaio/dekinaio-Anim_normal'})
self.actors[i].loadAnims(
{'anger': 'models/dekinaio/dekinaio-Anim_anger'})
self.actors[i].loadAnims({
'sadness2crying':
'models/dekinaio/dekinaio-Anim_sadness2crying'
})
self.actors[i].loadAnims(
{'sleep': 'models/dekinaio/dekinaio-Anim_sleep'})
self.actors[i].loadAnims(
{'smile': 'models/dekinaio/dekinaio-Anim_smile'})
self.actors[i].loadAnims(
{'surprised': 'models/dekinaio/dekinaio-Anim_surprised'})
self.info = None # frame集合体(page)のxml
self.actors_dict = {} # 名前付けされた役者
# xmlから場面を作る。(現時点では登場人物の列挙)
def buildScene(self, reverse=False):
characters = self.info.findall('.//character')
if reverse is True: characters.reverse()
if len(characters) > len(self.actors):
print('character numbers over')
return
if len(characters) == 1:
self.actors[0].setPos((0, -100.0, 0))
self.actors_dict[characters[0].find('name').text] = self.actors[0]
elif len(characters) == 2:
self.actors[0].setPos((-10.0, -100.0, 0))
self.actors[1].setPos((10.0, -100.0, 0))
self.actors_dict[characters[0].find('name').text] = self.actors[0]
self.actors_dict[characters[1].find('name').text] = self.actors[1]
elif len(characters) == 3:
self.actors[0].setPos((0.0, -100.0, 0))
self.actors[1].setPos((-15.0, -100.0, 0))
self.actors[2].setPos((15.0, -100.0, 0))
self.actors_dict[characters[0].find('name').text] = self.actors[0]
self.actors_dict[characters[1].find('name').text] = self.actors[1]
self.actors_dict[characters[2].find('name').text] = self.actors[2]
elif len(characters) == 4:
self.actors[0].setPos((10.0, -100.0, 0))
self.actors[1].setPos((-10.0, -100.0, 0))
self.actors[2].setPos((20.0, -100.0, 0))
self.actors[3].setPos((-20.0, -100.0, 0))
self.actors_dict[characters[0].find('name').text] = self.actors[0]
self.actors_dict[characters[1].find('name').text] = self.actors[1]
self.actors_dict[characters[2].find('name').text] = self.actors[2]
self.actors_dict[characters[3].find('name').text] = self.actors[3]
def makeFrames(self):
for i, frame in enumerate(self.info.findall('.//frame')):
# コマ内の登場人物の表情の変更
for chara in frame.findall('character'):
actor = self.actors_dict[chara.find('name').text]
emo = chara.find('face').attrib['emo']
# 表情をセット
actor.play('normal')
actor.pose(self.actors[i].getCurrentAnim(), 0)
actor.play(emo)
actor.pose(self.actors[i].getCurrentAnim(),
random.randrange(0, 99))
print('frame_' + f'zero padding: {i:02}' + '.png')
self.saveImage('frame_' + f'zero padding: {i:02}' + '.png')
def make(self, xml_path, reverse=False):
self.loadXml(xml_path)
for actor in self.actors:
actor.setPos((0, -100.0, 0))
characters = self.info.findall('character')
if reverse is True: characters.reverse()
for i, chara in enumerate(characters):
if i >= len(self.actors):
name = os.path.splitext(xml_path)[0].split('/')[-1]
print(name)
break
actor = self.actors[i]
coord = chara.find('face').attrib
dir = coord.get('dir')
emo = coord.get('emo')
x1 = float(coord.get('x1')) * 2.0 - 1.0
y1 = float(coord.get('y1')) * -2.0 + 1.0
x2 = float(coord.get('x2')) * 2.0 - 1.0
y2 = float(coord.get('y2')) * -2.0 + 1.0
# set position
p1, p2 = ((x1 + x2) / 2.0, y2), ((x1 + x2) / 2.0, y1)
self._fit(actor, p1, p2)
# set direction front = 0.0, left = -45.0, right = 45.0, rear = 180.0
h = random.uniform(-10.0, 10.0)
if dir == 'left':
h = random.uniform(-45.0, -100.0)
elif dir == 'right':
h = random.uniform(45.0, 100.0)
elif dir == 'front':
h = random.uniform(-10.0, 10.0)
elif dir == 'rear':
h = random.uniform(170.0, 190.0)
actor.setHpr(h, 0.0, 0.0)
# set emotion
actor.play('normal')
actor.pose(self.actors[i].getCurrentAnim(), 0)
actor.play(emo)
actor.pose(self.actors[i].getCurrentAnim(),
random.randrange(0, 99))
# debug
#print dir, emo
#OnscreenText(text='+', fg=(0, 0, 1, 1), pos=(x1, y1), scale=.05)
#OnscreenText(text='+', fg=(0, 0, 1, 1), pos=(x1, y2), scale=.05)
#OnscreenText(text='+', fg=(0, 0, 1, 1), pos=(x2, y2), scale=.05)
#OnscreenText(text='+', fg=(0, 0, 1, 1), pos=(x2, y1), scale=.05)
#OnscreenText(text='P1', fg=(0, 0, 1, 1), pos=(p1[0], p1[1]), scale=.05)
#OnscreenText(text='P2', fg=(0, 0, 1, 1), pos=(p2[0], p2[1]), scale=.05)
#OnscreenText(text='camera: ' + str(self.camera.getPos()), fg=(1, 0, 0, 1), pos=(-0.5, -0.95), scale=.05)
self.saveImage()
def loadXml(self, xmlpath):
self.info = ComicInfo.read_page(xmlpath)
def saveImage(self, path='testImg.png'):
self.base.graphicsEngine.renderFrame() # Rendering the frame
self.base.graphicsEngine.renderFrame() # Rendering the frame
image = PNMImage()
dr = self.base.camNode.getDisplayRegion(0)
dr.getScreenshot(image)
image.removeAlpha()
image.write(Filename(path))
# pre process for skeltonization
gray = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
gray[gray < 150] = 0
gray[gray >= 150] = 255
kernel = np.ones((3, 3), np.uint8)
gray = cv2.erode(gray, kernel)
#gray = cv2.dilate(gray, kernel)
#gray = cv2.resize(gray, (gray.shape[1]/2, gray.shape[0]/2))
cv2.imwrite(path, gray)
'''
'''
def _fit(self, c, p1, p2):
#bound = c.getBounds()
#r = bound.getRadius()
#cp = c.getPos(self.render)
#offset = Point3(0.0, r, 0.0)
#dist3d = r * 2.0
n1 = c.exposeJoint(None, "modelRoot", "Head")
n2 = c.exposeJoint(None, "modelRoot", "Eyes")
n_root = c.exposeJoint(None, "modelRoot", "ParentNode")
offset = n_root.getPos(n1)
dist3d = n2.getPos(n1).length()
if p1[0] != 0.0:
hfov = self.base.camLens.getHfov()
w = math.fabs(self.base.a2dRight)
a = p1[0]
Q = math.fabs(p2[1] - p1[1])
O = dist3d
n = p1[1] * O / Q
A = a * O / Q
theta = (hfov / 2.0) * (a / w)
d = A / math.tan(deg2Rad(theta))
p_1 = Point3(A, d, n)
p_2 = Point3(A, d, n + O)
p = Point3(A, d, n + offset[1])
else:
vfov = self.base.camLens.getVfov()
h = math.fabs(self.base.a2dTop)
theta = (vfov / 2.0) * (p1[1] / h)
Q = math.fabs(p2[1] - p1[1])
O = dist3d
n = p1[1] * O / Q
d = n / math.tan(deg2Rad(theta))
p_1 = Point3(p1[0], d, p1[1])
p_2 = Point3(p2[0], d, p2[1])
p = Point3(p1[0], d, n + offset[1])
c.setPos(p)
class PlayWorld(object):
def __init__(self, config=None):
if config is None:
self.config = {}
execfile('play_config.py', self.config)
else:
self.config = config
self.reward = None
print self.config['pydaq']
if pydaq and self.config.setdefault('pydaq', True) is not None:
self.reward = pydaq.GiveReward()
self.reward_count = 0
# adjustment to speed so corresponds to gobananas task
# 7 seconds to cross original environment
# speed needs to be adjusted to both speed in original
# environment and c_range of colors
# self.speed = 0.05 * (self.c_range[1] - self.c_range[0])
# speed is own variable, so can be changed during training.
self.speed = self.config['speed']
# need a multiplier to the joystick output to tolerable speed
self.vel_base = 4
self.max_vel = [500, 500, 0]
self.base = ShowBase()
self.base.disableMouse()
# self.base.setFrameRateMeter(True)
# assume we are showing windows unless proven otherwise
if self.config.get('win', True):
# only need inputs if we have a window
self.inputs = Inputs(self.base)
props = WindowProperties()
props.setCursorHidden(True)
props.setForeground(True)
print self.config.get('resolution')
if self.config.get('resolution'):
# main window
props.set_size(int(self.config['resolution'][0]),
int(self.config['resolution'][1]))
# props.set_origin(1920, 0)
props.set_origin(500, 0)
else:
props.set_size(600, 600)
props.set_origin(400, 50)
self.base.win.requestProperties(props)
# print 'background color', self.base.getBackgroundColor()
# field = self.base.loader.loadModel("../goBananas/models/play_space/field.bam")
field = self.base.loader.loadModel(
"../goBananas/models/play_space/round_courtyard.bam")
field.setPos(0, 0, 0)
field.reparent_to(self.base.render)
field_node_path = field.find('**/+CollisionNode')
field_node_path.node().setIntoCollideMask(0)
sky = self.base.loader.loadModel(
"../goBananas/models/sky/sky_kahana2.bam")
sky.setPos(0, 0, 0)
sky.setScale(1.6)
sky.reparentTo(self.base.render)
windmill = self.base.loader.loadModel(
"../goBananas/models/windmill/windmill.bam")
windmill.setPos(-10, 30, -1)
windmill.setScale(0.03)
windmill.reparentTo(self.base.render)
# mountain = self.base.loader.loadModel("../goBananas/models/mountain/mountain.bam")
# mountain.setScale(0.0005)
# mountain.setPos(10, 30, -0.5)
# create the avatar
self.avatar = NodePath(ActorNode("avatar"))
self.avatar.reparentTo(self.base.render)
self.avatar.setPos(0, 0, 1)
self.avatar.setScale(0.5)
pl = self.base.cam.node().getLens()
pl.setFov(60)
self.base.cam.node().setLens(pl)
self.base.camera.reparentTo(self.avatar)
# initialize task variables
self.frame_task = None
self.started_game = None
self.showed_match = None
self.gave_reward = None
# initialize and start the game
self.set_next_trial()
# print 'end init'
def start_loop(self):
# need to get new match
self.start_play()
def start_play(self):
print 'start play'
# log this
# print self.base.render.ls()
self.frame_task = self.base.taskMgr.add(self.game_loop, "game_loop")
self.frame_task.last = 0 # initiate task time of the last frame
def game_loop(self, task):
dt = task.time - task.last
task.last = task.time
velocity = self.inputs.poll_inputs(LVector3(0))
self.move_avatar(dt, velocity)
return task.cont
def reward_loop(self, task):
self.reward_count += 1
if self.reward_count <= self.config['num_beeps']:
if self.reward:
# log this
print 'give a bloody reward already'
self.reward.pumpOut()
print 'give reward'
return task.again
else:
self.end_loop()
return task.done
def move_avatar(self, dt, velocity):
# print 'velocity', self.velocity
self.avatar.setH(self.avatar.getH() - velocity[0] * 1.1)
move = LVector3(0, velocity[1], 0)
self.avatar.setPos(self.avatar, move * dt * self.vel_base)
def give_reward(self):
# clear the background
self.base.setBackgroundColor(0.41, 0.41, 0.41)
print 'give first reward'
self.reward_count = 1
if self.reward:
# log this
self.reward.pumpOut()
self.gave_reward = self.base.taskMgr.doMethodLater(
self.config['pump_delay'], self.reward_loop, 'reward_loop')
def end_loop(self):
print 'end loop'
# clear avatar map
# if there is a match set, return to center of color gradient,
# set new match, if applicable
self.set_next_trial()
def set_next_trial(self):
print 'set next trial'
# move avatar back to beginning position, only matters for
# showing card for next color match
# self.avatar.set_pos(-10, -10, 2)
# start the game
self.start_loop()
def check_key_map(self):
if self.config['colors'][0]:
if self.inputs.key_map['r']:
self.config['match_direction'] = ['right']
elif self.inputs.key_map['r'] is not None:
self.config['match_direction'] = ['left']
elif self.config['colors'][1]:
if self.inputs.key_map['f']:
self.config['match_direction'] = ['front']
elif self.inputs.key_map['f'] is not None:
self.config['match_direction'] = ['back']
def setup_display2(self, display_node):
print 'setup display2'
props = WindowProperties()
props.set_cursor_hidden(True)
props.set_foreground(False)
if self.config.get('resolution'):
props.setSize(700, 700)
props.setOrigin(-int(self.config['resolution'][0] - 5), 5)
else:
props.setSize(300, 300)
props.setOrigin(10, 10)
window2 = self.base.openWindow(props=props, aspectRatio=1)
lens = OrthographicLens()
lens.set_film_size(2, 2)
lens.setNearFar(-100, 100)
self.render2d = NodePath('render2d')
self.render2d.attach_new_node(display_node)
camera2d = self.base.makeCamera(window2)
camera2d.setPos(0, -10, 0)
camera2d.node().setLens(lens)
camera2d.reparentTo(self.render2d)
startPos=Point3(0, -10, 0))
hprInterval1 = pandaActor.hprInterval(1,
Point3(180, 0, 0),
startHpr=Point3(0, 0, 0))
hprInterval2 = pandaActor.hprInterval(1,
Point3(0, 0, 0),
startHpr=Point3(180, 0, 0))
# Create and play the sequence that coordinates the intervals.
pandaPace = Sequence(posInterval1, hprInterval1,
posInterval2, hprInterval2,
name="pandaPace")
pandaPace.loop()
# set cameras up (first camera = default)
cameras = [framework.cam, framework.makeCamera(framework.win), framework.makeCamera(framework.win)]
# initially first camera is on and second one is off
cameras[1].node().getDisplayRegion(0).setActive(0)
activeCam = 0
# locate cameras
cameras[1].reparentTo(pandaActor)
cameras[1].setPos(0, 10, 15)
cameras[1].lookAt(cameras[1].getPos() + (0,-2,-1))
cameras[0].setPos(30, -30, 20)
cameras[0].lookAt(0, 0, 6)
cameras[2].setPos(40, -40, 40)
def main():
base = ShowBase(windowType='offscreen')
options = parse_args()
model_id = get_model_id_from_file_path(options.file_in, options.rsp_path,
[options.mc_base_rsp_path])
model = load_model_json(model_id, options.rsp_path,
options.mc_base_rsp_path)
fill_frame_data(model, options.rsp_path, options.mc_base_rsp_path)
egg_file_text = convert_mc_model_to_egg(options.rsp_path,
options.mc_base_rsp_path, model,
os.path.split(options.file_in)[1],
options.texture_overrides)
if not os.path.exists('./temp'):
os.mkdir('./temp')
with open('./temp/temp.egg', 'w') as fileout:
fileout.write(egg_file_text)
pandaModel = loader.loadModel('./temp/temp.egg')
if not 'item/generated' in model.full_id_path and not 'minecraft:item/generated' in model.full_id_path:
pandaModel.setHpr(0, -90, 0)
pandaModel.flattenLight()
if options.view not in model.display:
print(
'Position "' + options.view +
'" not found; Using default view (no rotation, scale, or translation)'
)
model.display[options.view] = ModelJSONPosition()
pandaModel.setScale(model.display[options.view].scale[0],
model.display[options.view].scale[1],
model.display[options.view].scale[2])
pandaModel.flattenLight()
pandaModel.setHpr(model.display[options.view].rotation[2], 0, 0)
pandaModel.flattenLight()
pandaModel.setHpr(0, 0, model.display[options.view].rotation[1])
pandaModel.flattenLight()
pandaModel.setHpr(0, model.display[options.view].rotation[0], 0)
pandaModel.flattenLight()
pandaModel.setPos(model.display[options.view].translation[0],
model.display[options.view].translation[1],
model.display[options.view].translation[2])
pandaModel.flattenLight()
# pandaModel.setTwoSided(True)
mybuffer = base.win.makeTextureBuffer("buffer", options.size, options.size,
None, True)
base.set_background_color(0, 0, 0, 0)
mybuffer.setSort(-100)
lens = OrthographicLens()
if options.scale_to_fit:
min_point, max_point = pandaModel.getTightBounds()
film_size = max(max_point.getX() - min_point.getX(),
max_point.getY() - min_point.getY())
lens.setFilmSize(film_size, film_size)
else:
lens.setFilmSize(16, 16)
lens.setCoordinateSystem(CSYupRight)
lens.setFar(100)
lens.setNear(0)
mycamera = base.makeCamera(mybuffer, lens=lens)
if options.scale_to_fit:
min_point, max_point = pandaModel.getTightBounds()
mycamera.setPos(
(max_point.getX() - min_point.getX()) / 2 + min_point.getX(),
(max_point.getY() - min_point.getY()) / 2 + min_point.getY(), 32)
else:
mycamera.setPos(0, 0, 32)
myscene = NodePath("MyScene")
mycamera.reparentTo(myscene)
pandaModel.reparentTo(myscene)
if model.gui_light == 'front':
l0_vec = get_light_zero_item_vec().getXyz()
l1_vec = get_light_one_item_vec().getXyz()
else:
l0_vec = get_light_zero_vec().getXyz()
l1_vec = get_light_one_vec().getXyz()
lightzero = DirectionalLight('lightone')
lightzero.setDirection(l0_vec)
lightzero.setColor((0.6, 0.6, 0.6, 1))
lightone = DirectionalLight('lightone')
lightone.setDirection(l1_vec)
lightone.setColor((0.6, 0.6, 0.6, 1))
alight = AmbientLight('alight')
alight.setColor((0.5, 0.5, 0.5, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
l0 = render.attachNewNode(lightzero)
l1 = render.attachNewNode(lightone)
if model.gui_light == 'front':
l0.setHpr(0, -90, 0)
l1.setHpr(0, -90, 0)
else:
l0.setHpr(90, 0, 0)
l1.setHpr(90, 0, 0)
pandaModel.setLight(l1)
pandaModel.setLight(l0)
myscene.reparentTo(render)
frame = 0
if os.path.exists(options.file_out):
os.remove(options.file_out)
def copyAndClose(task):
nonlocal frame
if frame >= 1:
base.screenshot(source=mybuffer,
namePrefix=options.file_out,
defaultFilename=0)
sys.exit(0)
frame += 1
return Task.cont
taskMgr.add(copyAndClose, "copyAndClose")
base.run()
class ColorWorld(object):
def __init__(self, config=None):
# keep track of velocity, this allows me to counteract joystick with keyboard
self.velocity = LVector3(0)
if config is None:
self.config = {}
execfile('config.py', self.config)
else:
self.config = config
self.reward = None
if pydaq:
self.reward = pydaq.GiveReward()
self.reward_count = 0
# self.color_map always corresponds to (r, g, b)
# does not change during game, each game uses a particular color space
self.color_dict = square.make_color_map(self.config['colors'])
# sets the range of colors for this map
self.c_range = self.config['c_range']
# color variables (make dictionary?)
# color_list is set in beginning, and then after that this is only
# called again for non-random (training)
self.color_list = square.set_start_position_colors(self.config)
self.color_match = [0, 0, 0]
self.color_tolerance = []
self.last_avt, self.avt_factor = square.translate_color_map(self.config, self.color_dict, self.color_list)
print 'starting avt position', self.last_avt
print 'map avatar factor', self.avt_factor
self.random = True
if self.config.get('match_direction'):
self.random = False
# adjustment to speed so corresponds to gobananas task
# 7 seconds to cross original environment
# speed needs to be adjusted to both speed in original
# environment and c_range of colors
# self.speed = 0.05 * (self.c_range[1] - self.c_range[0])
# speed is own variable, so can be changed during training.
self.speed = self.config['speed']
# map avatar variables
self.render2d = None
self.match_square = None
self.map_avt_node = []
# need a multiplier to the joystick output to tolerable speed
self.vel_base = 3
self.max_vel = [500, 500, 0]
self.card = None
self.base = ShowBase()
self.base.disableMouse()
# assume we are showing windows unless proven otherwise
if self.config.get('win', True):
# only need inputs if we have a window
self.inputs = Inputs(self.base)
props = WindowProperties()
props.setCursorHidden(True)
props.setForeground(True)
print self.config.get('resolution')
if self.config.get('resolution'):
props.set_size(int(self.config['resolution'][0]), int(self.config['resolution'][1]))
props.set_origin(0, 0)
else:
props.set_size(600, 600)
props.set_origin(400, 50)
self.base.win.requestProperties(props)
# print self.base.win.get_size()
# setup color map on second window
sq_node = square.setup_square(self.config)
self.setup_display2(sq_node)
# print 'background color', self.base.getBackgroundColor()
# create the avatar
self.avatar = NodePath(ActorNode("avatar"))
self.avatar.reparentTo(self.base.render)
self.avatar.setH(self.base.camera.getH())
self.base.camera.reparentTo(self.avatar)
self.base.camera.setPos(0, 0, 0)
# initialize task variables
self.frame_task = None
self.started_game = None
self.showed_match = None
self.gave_reward = None
# initialize and start the game
self.set_next_trial()
# print 'end init'
def start_loop(self):
# need to get new match
print 'start loop'
self.started_game = self.base.taskMgr.doMethodLater(5, self.start_play, 'start_play')
self.showed_match = self.base.taskMgr.add(self.show_match_sample, 'match_image')
# Task methods
def show_match_sample(self, task):
print 'show match sample'
print self.color_match[:]
# match_image.fill(*self.color_match[:])
card = CardMaker('card')
color_match = self.color_match[:]
# add alpha channel
color_match.append(1)
print color_match
card.set_color(*color_match[:])
card.set_frame(-12, -8, 0, 4)
# log this
self.card = self.base.render.attach_new_node(card.generate())
return task.done
def start_play(self, task):
print 'start play'
# log this
self.base.taskMgr.remove('match_image')
self.card.removeNode()
# print self.base.render.ls()
self.frame_task = self.base.taskMgr.add(self.game_loop, "game_loop")
self.frame_task.last = 0 # initiate task time of the last frame
# log this
self.base.setBackgroundColor(self.color_list[:])
return task.done
def game_loop(self, task):
dt = task.time - task.last
task.last = task.time
self.velocity = self.inputs.poll_inputs(self.velocity)
move = self.move_avatar(dt)
stop = self.change_background(move)
self.move_map_avatar(move, stop)
match = self.check_color_match()
if match:
self.give_reward()
return task.done
return task.cont
def reward_loop(self, task):
self.reward_count += 1
if self.reward_count <= self.config['num_beeps']:
if self.reward:
# log this
print 'give a bloody reward already'
self.reward.pumpOut()
print 'give reward'
return task.again
else:
self.end_loop()
return task.done
def move_avatar(self, dt):
# print 'velocity', self.velocity
# this makes for smooth (correct speed) diagonal movement
# print 'velocity', self.velocity
magnitude = max(abs(self.velocity[0]), abs(self.velocity[1]))
move = None
if self.velocity.normalize():
# go left in increasing amount
# print 'dt', dt
# print 'normalized'
# print 'velocity', self.velocity
# print 'magnitude', magnitude
self.velocity *= magnitude
# print 'velocity', self.velocity
# this makes for smooth movement
move = self.velocity * self.vel_base * dt
# print move
self.avatar.setFluidPos(self.avatar, move)
return move
def change_background(self, move):
stop = [True, True, True]
if move:
# print move
move *= self.speed
for i in range(3):
value = self.color_dict[i]
if value is not None:
stop[i] = False
# keys correspond to x,y,z
# values correspond to r,g,b
if i == 2:
# z axis is treated differently
# need to work on this. z should
# be at min when both x and y are at max
# taking the average is not quite right...
z_move = (move[0] + move[1])/2
# print z_move
self.color_list[value] -= z_move
else:
self.color_list[value] += move[i]
if self.color_list[value] < self.c_range[0]:
self.color_list[value] = self.c_range[0]
stop[i] = True
elif self.color_list[value] > self.c_range[1]:
self.color_list[value] = self.c_range[1]
stop[i] = True
# log this
self.base.setBackgroundColor(self.color_list[:])
# print self.base.getBackgroundColor()
return stop
def move_map_avatar(self, move, stop):
# print move
# avatar is mapped assuming c_range of 0.5. What do I need to
# change to use a different c_range? c_range of one is twice
# the
if move:
avt = LineSegs()
avt.setThickness(1)
avt.setColor(1, 1, 1)
# print 'last', self.last_avt
avt.move_to(self.last_avt[0], -5, self.last_avt[1])
# print 'move', move
new_move = [i + (j * self.avt_factor) for i, j in zip(self.last_avt, move)]
# new_move = [i + j for i, j in zip(self.last_avt, move)]
# would it be better to have a local stop condition?
if stop[0]:
new_move[0] = self.last_avt[0]
# print 'stop x', self.last_avt[0]
if stop[1]:
new_move[1] = self.last_avt[1]
# print 'stop y', self.last_avt[1]
# print 'new', new_move
self.last_avt = [new_move[0], new_move[1]]
avt.draw_to(new_move[0], -5, new_move[1])
self.map_avt_node.append(self.render2d.attach_new_node(avt.create()))
# print self.map_avt_node[-1]
# can't let too many nodes pile up
if len(self.map_avt_node) > 299:
# removing the node does not remove the object from the list
for i, j in enumerate(self.map_avt_node):
j.removeNode()
if i > 49:
break
del self.map_avt_node[0:50]
def check_color_match(self):
# print 'match this', self.color_tolerance
# print self.color_list
check_color = [j[0] < self.color_list[i] < j[1] for i, j in enumerate(self.color_tolerance)]
# print check_color
if all(check_color):
return True
else:
return False
def give_reward(self):
# clear the background
self.base.setBackgroundColor(0.41, 0.41, 0.41)
print 'give first reward'
self.reward_count = 1
if self.reward:
# log this
self.reward.pumpOut()
self.gave_reward = self.base.taskMgr.doMethodLater(self.config['pump_delay'], self.reward_loop, 'reward_loop')
def end_loop(self):
print 'end loop'
# clear avatar map
self.clear_avatar_map()
# if there is a match set, return to center of color gradient,
# set new match, if applicable
self.set_next_trial()
def clear_avatar_map(self):
for i, j in enumerate(self.map_avt_node):
j.removeNode()
self.map_avt_node = []
def plot_match_square(self, corners):
print 'plot match square'
print corners
match = LineSegs()
match.setThickness(1.5)
match.setColor(0, 0, 0)
match.move_to(corners[0][0], -5, corners[1][0])
match.draw_to(corners[0][1], -5, corners[1][0])
match.draw_to(corners[0][1], -5, corners[1][1])
match.draw_to(corners[0][0], -5, corners[1][1])
match.draw_to(corners[0][0], -5, corners[1][0])
# print self.render2d
self.match_square = self.render2d.attach_new_node(match.create())
def create_avatar_map_match_square(self, config=None):
print 'make new square for map'
if config is not None:
config_dict = config
else:
config_dict = self.config
# create square on avatar map for new color match
map_color_match, factor = square.translate_color_map(config_dict, self.color_dict, self.color_match)
tolerance = config_dict['tolerance'] * factor
map_color_tolerance = [(i - tolerance, i + tolerance) for i in map_color_match]
print map_color_tolerance
if self.render2d:
if self.match_square:
self.match_square.removeNode()
self.plot_match_square(map_color_tolerance)
def set_next_trial(self):
print 'set next trial'
# move avatar back to beginning position, only matters for
# showing card for next color match
self.avatar.set_pos(-10, -10, 2)
# set color_list with starting color
# if random, won't use this again, but for manual, will
# return to center
# need to update self.config to new direction, if there is one
if self.config.get('match_direction'):
self.check_key_map()
# return to center, otherwise random will start where you left off
self.color_list = square.set_start_position_colors(self.config)
# starting position for map avatar, just translate new color_list
self.last_avt, self.avt_factor = square.translate_color_map(self.config, self.color_dict, self.color_list)
print 'start color', self.color_list
print self.color_dict
# again need to update self.config for match if using keys
self.color_match = square.set_match_colors(self.config, self.color_dict)
# sets the tolerance for how close to a color for reward
self.color_tolerance = [(i - self.config['tolerance'], i + self.config['tolerance']) for i in self.color_match]
print 'color match', self.color_match
print 'color tolerance', self.color_tolerance
self.create_avatar_map_match_square(self.config)
# start the game
self.start_loop()
def check_key_map(self):
if self.config['colors'][0]:
if self.inputs.key_map['r']:
self.config['match_direction'] = ['right']
elif self.inputs.key_map['r'] is not None:
self.config['match_direction'] = ['left']
elif self.config['colors'][1]:
if self.inputs.key_map['f']:
self.config['match_direction'] = ['front']
elif self.inputs.key_map['f'] is not None:
self.config['match_direction'] = ['back']
def setup_display2(self, display_node):
print 'setup display2'
props = WindowProperties()
props.set_cursor_hidden(True)
props.set_foreground(False)
if self.config.get('resolution'):
props.setSize(700, 700)
props.setOrigin(-int(self.config['resolution'][0] - 5), 5)
else:
props.setSize(300, 300)
props.setOrigin(10, 10)
window2 = self.base.openWindow(props=props, aspectRatio=1)
lens = OrthographicLens()
lens.set_film_size(2, 2)
lens.setNearFar(-100, 100)
self.render2d = NodePath('render2d')
self.render2d.attach_new_node(display_node)
camera2d = self.base.makeCamera(window2)
camera2d.setPos(0, -10, 0)
camera2d.node().setLens(lens)
camera2d.reparentTo(self.render2d)
from panda3d.core import TextureStage, TexGenAttrib, TransparencyAttrib
from panda3d.core import AmbientLight, DirectionalLight, Vec4
from random import uniform
# try uncommenting these 2 lines if the sprites have opaque gray background
#from pandac.PandaModules import loadPrcFileData
#loadPrcFileData('', 'gl-force-pixfmt 6')
app = ShowBase()
app.setBackgroundColor(0.6, 0.65, 1.0)
# render-to-texture stuff
altBuffer = app.win.makeTextureBuffer("spritebuf", 256, 256)
#altBuffer.setInverted(True)
altRender = NodePath("alt render")
altCam = app.makeCamera(altBuffer)
altCam.reparentTo(altRender)
#altCam.setPos(0.25, -12, 0)
teapot = loader.loadModel('model/banana.egg')
teapot.reparentTo(altRender)
teapot.setPos(0, 5, -0.1)
teapot.setH(270) # lazy way to compensate for the inverted buffer
teapot.setP(180)
app.accept("v", app.bufferViewer.toggleEnable)
app.bufferViewer.setPosition("llcorner")
app.bufferViewer.setCardSize(1.0, 0.0)
# lighting
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = altRender.attachNewNode(dlight)
