def __init__(self,parent,bl,tr,points,callback):
super(Slider,self).__init__(parent,bl,tr)
self.points = sorted(points,lambda x,y:cmp(x[0],y[0]))
self.callback = callback
self.lines = []
self.uilevel = utils.ui_level+1
self.enabled = False
self.clickable_area = UIElement(self,Point(0.05,0),Point(0.95,1))
line = drawing.Quad(globals.ui_buffer)
line_bl = self.clickable_area.absolute.bottom_left + self.clickable_area.absolute.size*Point(0,0.3)
line_tr = line_bl + self.clickable_area.absolute.size*Point(1,0) + Point(0,2)
line.SetVertices(line_bl,line_tr,self.uilevel)
line.Disable()
low = self.points[ 0][0]
high = self.points[-1][0]
self.offsets = [float(value - low)/(high-low) if low != high else 0 for value,index in self.points]
self.lines.append(line)
self.index = 0
self.pointer_quad = drawing.Quad(globals.ui_buffer)
self.pointer_colour = (1,0,0,1)
self.lines.append(self.pointer_quad)
self.pointer_ui = UIElement(self.clickable_area,Point(0,0),Point(0,0))
self.SetPointer()
self.pointer_quad.Disable()
self.dragging = False
#now do the blips
for offset in self.offsets:
line = drawing.Quad(globals.ui_buffer)
line_bl = self.clickable_area.absolute.bottom_left + Point(offset,0.3)*self.clickable_area.absolute.size
line_tr = line_bl + self.clickable_area.absolute.size*Point(0,0.2) + Point(2,0)
line.SetVertices(line_bl,line_tr,self.uilevel)
line.Disable()
self.lines.append(line)
def __init__(self):
self.atlas = globals.atlas = drawing.texture.TextureAtlas(
'tiles_atlas_0.png', 'tiles_atlas.txt')
self.sentry_lights = []
self.enemies = []
globals.ui_atlas = drawing.texture.TextureAtlas('ui_atlas_0.png',
'ui_atlas.txt',
extra_names=False)
self.enemy_positions = []
self.map = GameMap('level1.txt', self)
self.map.world_size = self.map.size * globals.tile_dimensions
self.viewpos = Viewpos(Point(100, 400))
self.player_direction = Point(0, 0)
self.game_over = False
self.mouse_world = Point(0, 0)
self.mouse_pos = Point(0, 0)
#pygame.mixer.music.load('music.ogg')
#self.music_playing = False
super(GameView, self).__init__(Point(0, 0), globals.screen)
#skip titles for development of the main game
self.mode = modes.Titles(self)
self.light = drawing.Quad(globals.light_quads)
self.light.SetVertices(Point(0, 0), globals.screen_abs - Point(0, 0),
0)
self.nightlight = drawing.Quad(globals.nightlight_quads)
self.nightlight.SetVertices(Point(0, 0),
globals.screen_abs - Point(0, 0), 0.01)
self.timeofday = TimeOfDay(0.1)
#self.mode = modes.LevelOne(self)
self.StartMusic()
self.fixed_light = actors.FixedLight(Point(11, 38), Point(26, 9))
self.interact_box = ui.Box(parent=globals.screen_root,
pos=Point(0.3, 0.0),
tr=Point(0.5, 0.08),
colour=(0.5, 0.5, 0.5, 0.7))
self.interact_box.title = ui.TextBox(
self.interact_box,
bl=Point(0, 0),
tr=Point(1, 1),
text='Opening...',
textType=drawing.texture.TextTypes.SCREEN_RELATIVE,
colour=(0, 0, 0, 1),
scale=9,
alignment=drawing.texture.TextAlignments.CENTRE)
self.interact_box.progress = ui.PowerBar(
self.interact_box,
pos=Point(0.1, 0.3),
tr=Point(0.9, 0.6),
level=0.6,
bar_colours=(drawing.constants.colours.red,
drawing.constants.colours.yellow,
drawing.constants.colours.green),
border_colour=drawing.constants.colours.white)
self.interact_box.Disable()
for pos in self.enemy_positions:
self.enemies.append(actors.Enemy(self.map, pos))
def __init__(self, parent):
self.parent = parent
self.pos = Point(20, 43)
self.size = globals.atlas.SubimageSprite(self.name).size
self.quad = drawing.Quad(globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.name))
self.flag_quad = drawing.Quad(
globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords('flag.png'))
self.flag_size = globals.atlas.SubimageSprite('flag.png').size
self.bars = [
drawing.Quad(
globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords('wheel_bar.png')),
drawing.Quad(globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords('mid_bar.png')),
drawing.Quad(
globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords('piston_bar.png'))
]
self.pressure_gauge = PressureGauge(self)
self.speedo = Speedo(self)
self.regulator = Regulator(self)
self.reverser = Reverser(self)
self.brake = Brake(self)
self.coal_dial = CoalDial(self)
self.clock = Clock(self)
self.clouds = []
self.distance_text = ui.TextBox(globals.screen_root,
Point(0.9, 0.83),
Point(1.0, 0.93),
'????.??',
scale=2,
colour=(0, 0, 0, 1.0))
self.Reset()
self.health_dial = HealthDial(self, self.health)
self.wheels = [
Wheel(self, 20 + x, y, r)
for (x, y, r) in ((99, 43, 0), (141, 43, math.pi))
]
self.add_coal_text = ui.TextBoxButton(globals.screen_root,
'Add',
Point(0.475, 0.770),
Point(0.575, 0.83),
size=2,
callback=self.add_coal_button,
colour=(0.0, 0.0, 0.0, 1.0))
self.Disable()
self.spout_pos = self.pos + Point(53, 67)
self.vent_pos = self.pos + Point(133, 49)
def __init__(self, parent, start, end):
self.parent = parent
self.start_object, self.start_pos = start
self.end_object, self.end_pos = end
self.quad = drawing.Quad(
globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords('arm.png'))
def __init__(self, train, initial_level=0.0):
self.train = train
self.quad = drawing.Quad(globals.screen_texture_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.name))
self.size = globals.atlas.SubimageSprite(self.name).size
self.arrow_quad = drawing.Quad(globals.screen_texture_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.arrow_name))
self.arrow_size = globals.atlas.SubimageSprite(self.arrow_name).size
bl = self.start_pos * globals.screen
tr = bl + self.size
self.pos = bl
self.arrow_pos = bl + self.centre
self.quad.SetVertices(bl, tr, 5.4)
self.Update(initial_level, 0)
def __init__(self, parent):
self.parent = parent
self.quad_buffer = drawing.QuadBuffer(4)
self.quad = drawing.Quad(self.quad_buffer)
self.colour = (1, 1, 1)
self.radius = 30
self.intensity = 1
self.on = True
globals.non_shadow_lights.append(self)
def __init__(self, start, vector, duration):
self.start_pos = start
self.vector = vector
self.duration = duration
self.start_time = globals.time
self.end_time = self.start_time + duration
self.quad = drawing.Quad(
globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords("cloud.png"))
def __init__(self,parent,pos,tr,colour):
super(Box,self).__init__(parent,pos,tr)
self.quad = drawing.Quad(globals.ui_buffer)
self.colour = colour
self.unselectable_colour = tuple(component*0.6 for component in self.colour)
self.quad.SetColour(self.colour)
self.quad.SetVertices(self.absolute.bottom_left,
self.absolute.top_right,
drawing.constants.DrawLevels.ui)
self.Enable()
def __init__(self, pos, radius=400, intensity=1):
self.radius = radius
self.width = self.height = radius
self.quad_buffer = drawing.QuadBuffer(4)
self.quad = drawing.Quad(self.quad_buffer)
self.shadow_quad = globals.shadow_quadbuffer.NewLight()
self.shadow_index = self.shadow_quad.shadow_index
self.colour = (1, 1, 1)
self.intensity = float(intensity)
self.set_pos(pos)
self.on = True
self.append_to_list()
def __init__(self,parent,pos,tr,level,bar_colours,border_colour):
super(PowerBar,self).__init__(parent,pos,tr)
self.low_power_colour = bar_colours[0]
self.medium_power_colour = bar_colours[1]
self.high_power_colour = bar_colours[2]
self.border = drawing.QuadBorder(globals.ui_buffer,line_width = 1)
self.border_colour = border_colour
self.border.SetColour(self.border_colour)
self.quad = drawing.Quad(globals.ui_buffer)
self.power_level = level
self.UpdatePosition()
self.Enable()
def __init__(self, train):
self.train = train
if self.name:
self.quad = drawing.Quad(globals.screen_texture_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.name))
self.size = globals.atlas.SubimageSprite(self.name).size
self.knob_quad = drawing.Quad(globals.screen_texture_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.knob_name))
if not self.name:
self.size = globals.atlas.SubimageSprite(self.knob_name).size
self.knob_coords = ((-10, -28), (-10, 20), (54, 20), (54, -28))
bl = self.start_pos * globals.screen
tr = bl + self.size
self.knob_pos = bl + Point(5, 28)
self.pos = bl
if self.name:
self.quad.SetVertices(bl, tr, 5.6)
self.level = 0
self.Update(self.start_angle)
def __init__(self, pos):
self.name, self.offset = self.texture_names[self.type]
self.pos = pos + self.offset
self.size = (
(globals.atlas.TextureSubimage(self.name).size.to_float()) /
globals.tile_dimensions)
self.tr = self.pos + self.size
self.quad = drawing.Quad(globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.name))
bl = self.pos * globals.tile_dimensions
tr = bl + self.size * globals.tile_dimensions
self.quad.SetVertices(bl, tr, self.level)
def __init__(self, parent, offset):
self.quad_buffer = drawing.QuadBuffer(4)
self.quad = drawing.Quad(self.quad_buffer)
self.shadow_quad = globals.shadow_quadbuffer.NewLight()
self.shadow_index = self.shadow_quad.shadow_index
self.parent = parent
self.last_update = None
self.colour = (1, 1, 1)
self.angle = 0.0
self.offset = cmath.polar(offset.x + offset.y * 1j)
self.angle_width = 0.5
self.on = False
self.level = self.max_level
globals.cone_lights.append(self)
def __init__(self, pos, z, name, sf):
self.pos = pos
self.name = name
self.z = z
self.sf = sf
self.quads = [drawing.Quad(globals.quad_buffer) for i in xrange(4)]
self.size = globals.atlas.SubimageSprite(self.name).size
self.centre = self.pos + (self.size * 0.5)
self.tc = globals.atlas.TextureSpriteCoords(self.name)
for quad in self.quads:
quad.SetTextureCoordinates(self.tc)
self.moved = 10
self.angle = 0
self.set_coords()
def __init__(self, train):
self.train = train
self.last_screech = 0
self.size = Point(64, 48)
self.knob_quad = drawing.Quad(globals.screen_texture_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.knob_name))
self.knob_coords = ((-30, -29), (-30, 19), (34, 19), (34, -29))
self.knob_settings = (0.45, 0.13, -0.25)
bl = self.start_pos * globals.screen
#tr = bl + self.size
self.knob_pos = bl + Point(30, 29)
self.pos = bl
self.level = 0
self.Reset()
def Init():
"""Initialise everything. Run once on startup"""
#w,h = (1600,1100)
w, h = (1280, 720)
globals.tile_scale = Point(1, 1)
globals.scale = Point(2, 2)
globals.screen_abs = Point(w, h)
globals.screen = globals.screen_abs / globals.scale
globals.screen_root = ui.UIRoot(Point(0, 0), globals.screen_abs)
globals.mouse_screen = Point(0, 0)
globals.lights = []
globals.cone_lights = []
globals.non_shadow_lights = []
globals.uniform_lights = []
globals.quad_buffer = drawing.QuadBuffer(131072)
globals.screen_texture_buffer = drawing.QuadBuffer(131072, ui=True)
globals.ui_buffer = drawing.QuadBuffer(131072, ui=True)
globals.nonstatic_text_buffer = drawing.QuadBuffer(131072, ui=True)
globals.light_quads = drawing.QuadBuffer(16384)
globals.nightlight_quads = drawing.QuadBuffer(16)
globals.temp_mouse_light = drawing.QuadBuffer(16)
globals.colour_tiles = drawing.QuadBuffer(131072)
globals.mouse_relative_buffer = drawing.QuadBuffer(1024,
ui=True,
mouse_relative=True)
globals.line_buffer = drawing.LineBuffer(16384)
globals.shadow_quadbuffer = drawing.ShadowQuadBuffer(256 * 4)
globals.temp_mouse_shadow = globals.shadow_quadbuffer.NewLight()
globals.tile_dimensions = Point(16, 16) * globals.tile_scale
globals.sounds = sounds.Sounds()
globals.zoom_scale = None
globals.time_step = 0.05
#WTF?
globals.mouse_light_quad = drawing.Quad(globals.temp_mouse_light)
#globals.mouse_light_quad.SetVertices(Point(0,0),
# Point(500,500),10)
#globals.mouse_light_quad.Disable()
globals.dirs = globals.types.Directories('resource')
pygame.init()
screen = pygame.display.set_mode((w, h), pygame.OPENGL | pygame.DOUBLEBUF)
pygame.display.set_caption('Rogue Planet')
drawing.Init(globals.screen.x, globals.screen.y)
globals.text_manager = drawing.texture.TextManager()
def __init__(self, pos, size):
#self.world_pos = pos
self.pos = pos * globals.tile_dimensions
self.size = size
self.quad_buffer = drawing.QuadBuffer(4)
self.quad = drawing.Quad(self.quad_buffer)
self.colour = (0.2, 0.2, 0.2)
self.on = True
globals.uniform_lights.append(self)
self.pos = (self.pos.x, self.pos.y, self.z)
box = (self.size * globals.tile_dimensions)
bl = Point(*self.pos[:2])
tr = bl + box
bl = bl.to_int()
tr = tr.to_int()
self.quad.SetVertices(bl, tr, 4)
def __init__(self, type, pos):
self.pos = pos
self.type = type
try:
self.name = self.texture_names[type]
except KeyError:
self.name = self.texture_names[TileTypes.GRASS]
#How big are we?
self.size = ((globals.atlas.TextureSubimage(self.name).size) /
globals.tile_dimensions).to_int()
self.quad = drawing.Quad(globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.name))
bl = pos * globals.tile_dimensions
tr = bl + self.size * globals.tile_dimensions
self.quad.SetVertices(bl, tr, 0)
def __init__(self, start, duration, pos, steam):
self.x_coord = pos
self.start_pos = start
self.duration = duration
self.z = 0.35
if not steam:
self.z += Cloud.cloud_index * 0.001
Cloud.cloud_index = (Cloud.cloud_index + 1) & 0xff
self.start_time = globals.time
self.end_time = self.start_time + duration
self.spin = random.random() * math.pi * 2
self.final_size = Point(64, 64) * (0.6 + random.random() * 0.4)
self.rise_speed = Cloud.rise_speed * (0.6 + random.random() * 0.4)
self.quad = drawing.Quad(globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords(
'steam.png' if steam else 'smoke.png'))
def __init__(self, type, pos):
super(WhiteBoard, self).__init__(type, pos)
try:
self.full_name = self.fulltexture_names[type]
except KeyError:
self.full_name = self.fulltexture_names[TileTypes.GRASS]
self.guide = ui.UIElement(parent=globals.screen_root,
pos=Point(0.15, 0.15),
tr=Point(0.85, 0.85))
size = globals.atlas.TextureSubimage(self.full_name).size
self.quad = drawing.Quad(globals.screen_texture_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.full_name))
bl = (globals.screen - size) / 2
tr = bl + size
self.quad.SetVertices(bl, tr, drawing.constants.DrawLevels.ui + 800)
self.quad.Disable()
def __init__(self, type, pos):
self.pos = pos
self.type = type
self.actors = {}
try:
self.name = self.texture_names[type]
except KeyError:
self.name = self.texture_names[TileTypes.GRASS]
#How big are we?
self.size = Point(1, 1)
self.tex_size = (globals.atlas.SubimageSprite(
self.name).size) / globals.tile_dimensions
#what tcs do we want?
full_tc = globals.atlas.TextureSpriteCoords(self.name)
bl_tc = Point(pos.x % self.tex_size.x,
pos.y % self.tex_size.y) / (self.tex_size.to_float())
tr_tc = bl_tc + Point(1, 1) / (self.tex_size.to_float())
full_tc_size = (full_tc[2][0] - full_tc[0][0],
full_tc[2][1] - full_tc[0][1])
tc = [[
full_tc[0][0] + bl_tc[0] * full_tc_size[0],
full_tc[0][1] + bl_tc[1] * full_tc_size[1]
],
[
full_tc[0][0] + bl_tc[0] * full_tc_size[0],
full_tc[0][1] + tr_tc[1] * full_tc_size[1]
],
[
full_tc[0][0] + tr_tc[0] * full_tc_size[0],
full_tc[0][1] + tr_tc[1] * full_tc_size[1]
],
[
full_tc[0][0] + tr_tc[0] * full_tc_size[0],
full_tc[0][1] + bl_tc[1] * full_tc_size[1]
]]
#print tc
self.quad = drawing.Quad(globals.quad_buffer, tc=tc)
bl = pos * globals.tile_dimensions
tr = bl + self.size * globals.tile_dimensions
self.quad.SetVertices(bl, tr, 0)
def __init__(self, train, x, y, angle):
self.train = train
self.x = x
self.y = y
self.angle = angle
self.initial_angle = angle
self.height = 28
self.radius = self.height / 2
self.pos = Point(x + self.radius, y + self.radius)
self.quad = drawing.Quad(globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords(
os.path.join('wheel.png')))
self.coords = ((-self.radius, -self.radius), (-self.radius,
self.radius),
(self.radius, self.radius), (self.radius, -self.radius))
self.vertices = [0, 0, 0, 0]
self.set_vertices()
self.circumference = math.pi * 2 * self.radius
def __init__(self, parent, level=None):
self.parent = parent
self.dead = False
self.subimage = globals.atlas.SubimageSprite(self.texture_name)
self.quad = drawing.Quad(globals.quad_buffer,
tc=globals.atlas.TextureSpriteCoords(
self.texture_name))
self.half_size = self.subimage.size * 0.5 * self.parent.physics.scale_factor
self.bl = self.parent.midpoint * Point(0.3, 2.4) - self.half_size
self.middle = self.bl + self.half_size
self.shape = self.parent.CreateShape(self.half_size, self.bl)
self.shape.userData = self
self.shapeI = self.parent.body.CreateShape(self.shape)
self.angle = 0
self.level = self.max_level if level == None else level
self.squirters = []
self.last_squirt_quad = None
self.SetPositions()
self.squirting = False
self.UpdateLevel(0)
def __init__(self, pos, angle, width):
self.quad_buffer = drawing.QuadBuffer(4)
self.quad = drawing.Quad(self.quad_buffer)
self.shadow_quad = globals.shadow_quadbuffer.NewLight()
self.shadow_index = self.shadow_quad.shadow_index
self.colour = (1, 1, 1)
self.initial_angle = angle
self.angle = angle
self.angle_width = width
self.on = True
pos = pos * globals.tile_dimensions
self.world_pos = pos
self.pos = (pos.x, pos.y, self.z)
box = (globals.tile_scale * Point(self.width, self.height))
bl = Point(*self.pos[:2]) - box * 0.5
tr = bl + box
bl = bl.to_int()
tr = tr.to_int()
self.quad.SetVertices(bl, tr, 4)
globals.cone_lights.append(self)
def __init__(self):
self.selected_player = None
self.floating_objects = []
self.atlas = globals.atlas = drawing.texture.TextureAtlas('tiles_atlas_0.png','tiles_atlas.txt')
self.game_over = False
self.dragging = None
self.max_zoom = 2.0
self.min_zoom = 0.5
self.backdrop_texture = drawing.texture.Texture('starfield.png')
pygame.mixer.music.load('music.ogg')
pygame.mixer.music.set_volume(self.music_volume)
self.music_playing = True
super(GameView,self).__init__(Point(0,0),Point(2000,2000))
tiles = (self.absolute.size.to_float())/self.backdrop_texture.size
self.backdrop = drawing.Quad(globals.backdrop_buffer,tc = numpy.array([(0,0),(0,tiles.y),(tiles.x,tiles.y),(tiles.x,0)]))
self.backdrop.SetVertices(Point(0,0),
self.absolute.size,
drawing.constants.DrawLevels.grid)
self.physics = Physics(self)
#skip titles for development of the main game
#self.mode = modes.Titles(self)
self.players = []
self.mode = modes.LevelOne(self)
self.paused = False
self.StartMusic()
self.zoom = 1
self.viewpos = Viewpos(Point(670,870))
self.walls = [actors.StaticBox(self.physics,
bl = Point(0,0),
tr = Point(1,self.absolute.size.y)),
actors.StaticBox(self.physics,
bl = Point(self.absolute.size.x,0),
tr = Point(self.absolute.size.x+1,self.absolute.size.y)),
actors.StaticBox(self.physics,
bl = Point(0,self.absolute.size.y),
tr = Point(self.absolute.size.x,self.absolute.size.y+1)),
actors.StaticBox(self.physics,
bl = Point(0,0),
tr = Point(self.absolute.size.x,1)),
]
def __init__(self,map,pos):
self.map = map
self.dirsa = ((Directions.UP ,'back' ),
(Directions.DOWN ,'front'),
(Directions.LEFT ,'left' ),
(Directions.RIGHT,'right'))
self.dirs_pos = {Directions.UP : Point(0,1),
Directions.DOWN : Point(0,-1),
Directions.LEFT : Point(-1,0),
Directions.RIGHT : Point(1,0)}
self.dirs = {}
for dir,name in self.dirsa:
try:
tc = globals.atlas.TextureSpriteCoords('%s_%s.png' % (self.texture,name))
except KeyError:
tc = globals.atlas.TextureSpriteCoords('%s_front.png' % self.texture)
self.dirs[dir] = tc
#self.dirs = dict((dir,globals.atlas.TextureSpriteCoords('%s_%s.png' % (self.texture,name))) for (dir,name) in self.dirs)
self.dir = Directions.DOWN
self.quad = drawing.Quad(globals.quad_buffer,tc = self.dirs[self.dir])
self.size = Point(float(self.width)/16,float(self.height)/16)
self.corners = Point(0,0),Point(self.size.x,0),Point(0,self.size.y),self.size
self.SetPos(pos)
self.current_sound = None
def __init__(self, map, pos):
self.map = map
self.tc = globals.atlas.TextureSpriteCoords('%s.png' % self.texture)
self.quad = drawing.Quad(globals.quad_buffer, tc=self.tc)
self.size = Point(float(self.width) / 16, float(self.height) / 16)
self.corners = self.size, Point(-self.size.x, self.size.y), Point(
-self.size.x, -self.size.y), Point(self.size.x, -self.size.y)
self.corners = [p * 0.5 for p in self.corners]
self.corners_polar = [(p.length(), ((1 + i * 2) * math.pi) / 4)
for i, p in enumerate(self.corners)]
self.radius_square = (self.size.x / 2)**2 + (self.size.y / 2)**2
self.radius = math.sqrt(self.radius_square)
self.corners_euclid = [p for p in self.corners]
self.current_sound = None
self.last_update = None
self.dead = False
self.move_speed = Point(0, 0)
self.move_direction = Point(0, 0)
self.pos = None
self.last_damage = 0
self.health = self.initial_health
self.interacting = None
self.SetPos(pos)
self.set_angle(3 * math.pi / 2)
def __init__(self):
self.enabled = False
self.quad = drawing.Quad(globals.screen_texture_buffer,tc = globals.atlas.TextureTextureCoords(self.texture_name))
self.quad.SetTextureCoordinates(globals.atlas.TextureTextureCoords(self.texture_name))
self.quad.Disable()
self.sound = getattr(globals.sounds,self.sound)
def ReallocateResources(self):
super(TextBoxButton,self).ReallocateResources()
self.hover_quads = [drawing.Quad(globals.ui_buffer) for i in xrange(4)]
def __init__(self, map, pos):
self.mouse_pos = Point(0, 0)
self.has_key = False
super(Player, self).__init__(map, pos)
self.light = ActorLight(self)
self.tilium = False
self.flare = None
self.comms = None
self.last_damage_sound = 0
self.torch = Torch(
self, Point(-(self.width / globals.tile_dimensions.x) * 0.6, 0))
self.info_box = ui.Box(parent=globals.screen_root,
pos=Point(0, 0),
tr=Point(1, 0.08),
colour=(0, 0, 0, 0.7))
self.info_box.health_text = ui.TextBox(
self.info_box,
bl=Point(0.8, 0),
tr=Point(1, 0.7),
text='\x81:%d' % self.initial_health,
textType=drawing.texture.TextTypes.SCREEN_RELATIVE,
colour=(1, 0, 0, 1),
scale=10,
alignment=drawing.texture.TextAlignments.CENTRE)
self.info_box.torch_data = ui.UIElement(self.info_box,
pos=Point(0.5, 0),
tr=Point(0.85, 1))
self.info_box.torch_data.text = ui.TextBox(
self.info_box.torch_data,
bl=Point(0, 0),
tr=Point(0.57, 0.7),
text='Torch power:',
textType=drawing.texture.TextTypes.SCREEN_RELATIVE,
colour=(1, 0, 0, 1),
scale=8,
alignment=drawing.texture.TextAlignments.CENTRE)
self.info_box.torch_data.power = ui.PowerBar(
self.info_box.torch_data,
pos=Point(0.5, 0.36),
tr=Point(1, 0.66),
level=0.6,
bar_colours=(drawing.constants.colours.red,
drawing.constants.colours.yellow,
drawing.constants.colours.green),
border_colour=drawing.constants.colours.white)
self.info_box.torch_data.Disable()
self.inv_quads = [
drawing.Quad(globals.screen_texture_buffer,
tc=globals.ui_atlas.TextureUiCoords('empty.png'))
for i in xrange(4)
]
self.sel_quads = [
drawing.Quad(globals.screen_texture_buffer,
tc=globals.ui_atlas.TextureUiCoords('selected.png'))
for i in xrange(4)
]
box_size = 48
sep_x = int((self.info_box.absolute.size.x * 0.2 - box_size * 3) / 4)
sep_y = int((self.info_box.absolute.size.y - box_size) / 2)
for i in xrange(4):
bl = self.info_box.absolute.bottom_left + Point(
self.info_box.absolute.size.x * 0.03, 0) + Point(
((i + 1) * sep_x) + (i * box_size), sep_y)
tr = bl + Point(box_size, box_size)
self.inv_quads[i].SetVertices(bl, tr, 9000)
self.sel_quads[i].SetVertices(bl, tr, 9001)
self.inv_quads[i].Enable()
self.sel_quads[i].Disable()
self.inventory = [None, None, None, None]
self.num_items = 0
self.current_item = 0
self.attacking = False
self.AddItem(Hand(self))
#self.AddItem(CommsItem(self))
self.Select(self.num_items - 1)
self.weapon = self.inventory[self.current_item]
self.interacting = None
