def __init__(self, entity, attr_name, color, offset, vertical = False):
self.entity = entity
self.attr_name = attr_name
if not hasattr(entity, attr_name):
print "WARNING! BarUI can't find attribute %s in entity %s" % (attr_name, entity)
if not hasattr(entity, "max_"+attr_name):
print "WARNING! BarUI can't find attribute %s in entity %s" % ("max_"+attr_name, entity)
self.node = Node()
self.SetOffset(offset, vertical)
if vertical:
self.node.modifier().set_rotation( pi/2.0)
self.node.thisown = 0
self.size = Vector2D(entity.size.get_x(), BAR_SIZE)
self.back_shape = SolidRectangle( self.size )
self.back_shape.set_color( Color(0.0, 0.0, 0.0, 0.5) )
self.back_shape.set_hotspot(Drawable.CENTER)
self.back_node = Node( self.back_shape )
self.node.AddChild(self.back_node)
self.shape = SolidRectangle( self.size )
self.shape.set_color( color )
self.shape.set_hotspot(Drawable.CENTER)
self.bar_node = Node( self.shape )
self.node.AddChild(self.bar_node)
self.type = str(self.__class__)
def __init__(self):
screenSize = Engine_reference().video_manager().video_size()
rect = SolidRectangle(screenSize)
rect.set_color( Color(0.5, 0.5, 0.5) )
self.backNode = Node(rect)
color = self.backNode.modifier().color()
color.set_a(0.5)
self.backNode.modifier().set_color(color)
self.content_node().AddChild(self.backNode)
text = ResourceManager_CreateTextFromLanguageTag("Pause")
self.textNode = Node(text)
x = (screenSize.get_x()/2.0) - (text.width()/2.0)
y = (screenSize.get_y()/2.0) - (text.height()/2.0)
self.textNode.modifier().set_offset( Vector2D(x, y) )
self.interface_node().AddChild(self.textNode)
def __init__(self, managerScene, x, y, stringFunctions, backColor, backAlpha=1.0):
self.managerScene = managerScene
self.node = Node()
#self.node.thisown = 0
self.size = Vector2D(150.0, 75.0)
self.backShape = SolidRectangle( self.size )
self.backShape.set_color( backColor )
self.backNode = Node()
self.backNode.set_drawable( self.backShape )
color = self.backNode.modifier().color()
color.set_a(backAlpha)
self.backNode.modifier().set_color(color)
self.node.AddChild(self.backNode)
self.node.modifier().set_offset( Vector2D(x,y) )
self.texts = []
self.stringsFunctions = stringFunctions
self.strings = [f() for f in self.stringsFunctions]
y = 0
for i in range(len(self.strings)):
self.texts.append( Engine_reference().text_manager().GetText(self.strings[i]) )
textNode = Node()
textNode.set_drawable(self.texts[i])
textNode.modifier().set_offset( Vector2D(0.0, i * 20.0 ) )
#textNode.thisown = 0
self.node.AddChild(textNode)
if self.texts[i].size().get_x() > self.size.get_x():
self.size.set_x(self.texts[i].size().get_x())
y += self.texts[i].size().get_y() + 5
self.size.set_y(y)
self.backShape.set_size(self.size)
def SetAndShowSceneEndText(self, msgTag):
if self.finishTextNode != None: return
text = ResourceManager_CreateTextFromLanguageTag(msgTag)
self.finishTextNode = Node(text)
screenSize = Engine_reference().video_manager().video_size()
x = (screenSize.get_x()/2.0) - (text.width()/2.0)
y = (screenSize.get_y()/2.0) - (text.height()/2.0)
self.finishTextNode.modifier().set_offset( Vector2D(x, y) )
self.interface_node().AddChild(self.finishTextNode)
def __init__(self, x, y, radius):
self.radius = radius
self.is_destroyed = False
self.to_be_removed = False
self.is_collidable = True
self.collision_object = None
self.hud_node = Node()
self.node = Node()
self.SetPos( Vector2D(x,y) )
# Calculating Type
self.type = str(self.__class__)
if len(self.type.split("'")) > 1:
self.type = self.type.split("'")[1]
self.type = self.type.split(".")[1]
# Get Unique ID
self.id = EntityInterface.nextID
EntityInterface.nextID += 1
class PauseScene (Scene):
def __init__(self):
screenSize = Engine_reference().video_manager().video_size()
rect = SolidRectangle(screenSize)
rect.set_color( Color(0.5, 0.5, 0.5) )
self.backNode = Node(rect)
color = self.backNode.modifier().color()
color.set_a(0.5)
self.backNode.modifier().set_color(color)
self.content_node().AddChild(self.backNode)
text = ResourceManager_CreateTextFromLanguageTag("Pause")
self.textNode = Node(text)
x = (screenSize.get_x()/2.0) - (text.width()/2.0)
y = (screenSize.get_y()/2.0) - (text.height()/2.0)
self.textNode.modifier().set_offset( Vector2D(x, y) )
self.interface_node().AddChild(self.textNode)
def Focus(self):
pass
def DeFocus(self):
pass
def Update(self, dt): ###
input = Engine_reference().input_manager()
resume = False
resume = resume or input.KeyPressed(K_ESCAPE)
resume = resume or input.KeyPressed(K_HOME)
resume = resume or input.KeyPressed(K_PAGEUP)
resume = resume or input.KeyPressed(K_PAGEDOWN)
resume = resume or input.KeyPressed(K_p)
resume = resume or input.KeyPressed(K_SPACE)
if resume:
self.Finish()
def End(self):
pass
class BarUI:
def __init__(self, entity, attr_name, color, offset, vertical = False):
self.entity = entity
self.attr_name = attr_name
if not hasattr(entity, attr_name):
print "WARNING! BarUI can't find attribute %s in entity %s" % (attr_name, entity)
if not hasattr(entity, "max_"+attr_name):
print "WARNING! BarUI can't find attribute %s in entity %s" % ("max_"+attr_name, entity)
self.node = Node()
self.SetOffset(offset, vertical)
if vertical:
self.node.modifier().set_rotation( pi/2.0)
self.node.thisown = 0
self.size = Vector2D(entity.size.get_x(), BAR_SIZE)
self.back_shape = SolidRectangle( self.size )
self.back_shape.set_color( Color(0.0, 0.0, 0.0, 0.5) )
self.back_shape.set_hotspot(Drawable.CENTER)
self.back_node = Node( self.back_shape )
self.node.AddChild(self.back_node)
self.shape = SolidRectangle( self.size )
self.shape.set_color( color )
self.shape.set_hotspot(Drawable.CENTER)
self.bar_node = Node( self.shape )
self.node.AddChild(self.bar_node)
self.type = str(self.__class__)
def SetOffset(self, offset, vertical = False):
if vertical:
self.offset = Vector2D(offset + BAR_SIZE, 0.0)
else:
self.offset = Vector2D(0.0, offset + BAR_SIZE)
self.node.modifier().set_offset( self.offset )
def Update(self):
if hasattr(self.entity, self.attr_name) and hasattr(self.entity, "max_"+self.attr_name):
current = self.entity.__dict__[self.attr_name]
max = self.entity.__dict__["max_"+self.attr_name]
if current <= 0: current = 0
#size = current * self.entity.size.get_x() / max
#scale = size / self.entity.size.get_x() # I know this is redundant, by I prefer it in this case to be more verbose
scale = current / max #this is same as the commented above, but without the redundancy
self.bar_node.modifier().set_scale( Vector2D(scale, 1.0) )
def __repr__(self):
return "<%s of entity %s>" % (self.type, self.entity)
def __str__(self): return self.__repr__()
def __init__(self, x, y, texture_name, lifetime, effect, name, effectCreationFunc):
r = 15.0
BasicEntity.__init__(self, x, y, texture_name, r, 1)
self.life_hud.node.set_active(False)
self.max_velocity = 135.0
self.lifespan = lifetime
self.lifetime = lifetime
self.effect = effect
self.effect.creation_func = effectCreationFunc
self.wasApplied = False
self.blink_time = 0.0
self.text = Engine_reference().text_manager().GetText(name)
self.textNode = Node(self.text)
self.textNode.modifier().set_offset( Vector2D(-self.text.width()/2.0, 0.0 ) ) # TODO: text hotspot!
self.textNode.set_active(False)
self.node.AddChild(self.textNode)
class PowerUp (BasicEntity):
def __init__(self, x, y, texture_name, lifetime, effect, name, effectCreationFunc):
r = 15.0
BasicEntity.__init__(self, x, y, texture_name, r, 1)
self.life_hud.node.set_active(False)
self.max_velocity = 135.0
self.lifespan = lifetime
self.lifetime = lifetime
self.effect = effect
self.effect.creation_func = effectCreationFunc
self.wasApplied = False
self.blink_time = 0.0
self.text = Engine_reference().text_manager().GetText(name)
self.textNode = Node(self.text)
self.textNode.modifier().set_offset( Vector2D(-self.text.width()/2.0, 0.0 ) ) # TODO: text hotspot!
self.textNode.set_active(False)
self.node.AddChild(self.textNode)
def setupCollisionObject(self):
self.collision_object = CollisionObject(getCollisionManager(), self) #initialize collision object, second arg is passed to collisionlogic to handle collisions
self.collision_object.InitializeCollisionClass("PowerUp") # define the collision class
self.collision_object.set_shape(self.geometry) # set our shape
self.collision_object.AddCollisionLogic("Entity", BasicColLogic(self) )
self.collision_object.thisown = 0
def Update(self, dt):
if not self.wasApplied:
BasicEntity.Update(self, dt)
self.lifetime -= dt
if self.lifetime < self.lifespan*0.15 and not self.wasApplied:
self.blink_time += dt
if self.blink_time > self.lifetime/self.lifespan:
self.blink_time = 0.0
self.node.set_active( not self.node.active() )
if self.lifetime < 0:
self.Delete()
def HandleCollision(self, target):
if target.CheckType("Ship") and not self.wasApplied:
self.effect.SetTarget(target)
target.ApplyEffect(self.effect)
self.wasApplied = True
self.lifetime = 3.0
self.textNode.set_active(True)
color = self.node.modifier().color()
color.set_a(0.2)
self.node.modifier().set_color(color)
self.node.set_active(True)
def __init__(self, x, y, data):
self.image_w = 420.0
self.image_h = 830.0
BasicEntity.__init__(self, x, y, "images/ship.png", 20.0, data.max_life, self.image_h/self.image_w)
self.radius = (self.size*0.5).Length()
self.node.set_zindex(1.0)
self.graphic_node = Node()
self.node.set_drawable(None)
self.graphic_node.set_drawable(self.shape)
self.graphic_node.set_zindex(1.0)
self.node.AddChild(self.graphic_node)
self.group = Group.SHIP
self.acceleration = Vector2D(0.0, 0.0)
self.data = data
self.max_energy = self.data.max_energy
self.energy = self.max_energy
self.bonus_regen_counter = 0.0
self.bonus_regen_threshold = 3.0
self.speed = 400.0 # |acceleration| in a given frame
self.max_speed = 200.0 # max |velocity| ship can attain.
#self.rangeCheck = RangeCheck(0, 0, 1024.0, "Asteroid")
#self.rangeCheck.AttachToEntity(self)
self.pulse_weapon = Weapons.Pulse()
self.right_weapon = None
self.pulse_weapon.Activate(self)
#self.right_weapon.Activate(self)
offset = self.size.get_y()/2.0
self.life_hud.SetOffset(offset)
self.energy_hud = BarUI(self, "energy", Color(0.0,0.0,1.0,1.0), offset+BAR_SIZE)
self.hud_node.AddChild(self.energy_hud.node)
self.charge_hud = BarUI(self.pulse_weapon, "charge_time", Color(1.0,1.0,0.0,1.0), -offset-2*BAR_SIZE)
self.hud_node.AddChild(self.charge_hud.node)
class EntityInterface (Entity):
nextID = 1
def __init__(self, x, y, radius):
self.radius = radius
self.is_destroyed = False
self.to_be_removed = False
self.is_collidable = True
self.collision_object = None
self.hud_node = Node()
self.node = Node()
self.SetPos( Vector2D(x,y) )
# Calculating Type
self.type = str(self.__class__)
if len(self.type.split("'")) > 1:
self.type = self.type.split("'")[1]
self.type = self.type.split(".")[1]
# Get Unique ID
self.id = EntityInterface.nextID
EntityInterface.nextID += 1
def CheckType(self, typestr):
return self.type.count(typestr) > 0
def ClearNewObjects(self):
self.new_objects = []
def GetNode(self): return self.node
def GetHUDNode(self): return self.hud_node
def GetPos(self):
return self.node.modifier().offset()
def SetPos(self, pos):
self.node.modifier().set_offset(pos)
self.hud_node.modifier().set_offset(pos)
if self.collision_object != None:
self.collision_object.MoveTo(pos)
def GetDirection(self):
return Vector2D(0.0, 1.0)
def GetPointsValue(self):
return 0
def HandleMapBoundaries(self, pos):
max = Config.gamesize
passedBoundary = False
# checking for horizontal map boundaries
if pos.get_x() < 0.0:
pos.set_x( max.get_x() + pos.get_x() )
passedBoundary = True
if pos.get_x() > max.get_x():
pos.set_x( pos.get_x() - max.get_x() )
passedBoundary = True
# checking for vertical map boundaries
if pos.get_y() < 0.0:
pos.set_y( max.get_y() + pos.get_y() )
passedBoundary = True
if pos.get_y() > max.get_y():
pos.set_y( pos.get_y() - max.get_y() )
passedBoundary = True
return passedBoundary
def Update(self, dt):
pass
def HandleCollision(self, target):
print self.type, " HandleCollision NOT IMPLEMENTED"
def Delete(self):
if hasattr(self, "node") and self.node != None:
self.node.set_active(False)
if self.is_destroyed: return
self.is_destroyed = True
def __repr__(self):
return "<%s #%s>" % (self.type, self.id)
def __str__(self): return self.__repr__()
class AsteroidsScene (Scene):
def __init__(self, managerScene, difficultyFactor):
#print "Creating AsteroidsScene"
maxval = Config.MAX_ENTITY_SIZE
mincoords = [-maxval, -maxval]
maxcoords = [Config.gamesize.get_x() + maxval, Config.gamesize.get_y() + maxval]
self.collisionManager = CollisionManager( CreateBox2D(mincoords[0], mincoords[1], maxcoords[0], maxcoords[1]) )
self.objects = []
self.colliding_objects = []
self.startCollisions()
self.asteroid_count = 0
self.ship_alive = True
self.hero = None
self.hero_effects = []
self.finishTextNode = None
self.difficultyFactor = difficultyFactor
#self.AddTask(self.collisionManager.GenerateHandleCollisionTask() )###
self.managerScene = managerScene
strFuncs = [self.managerScene.GetLivesText, self.managerScene.GetDifficultyText, self.managerScene.GetPointsText]
self.stats = BarUI.StatsUI(managerScene, 0.0, 0.0, strFuncs, Color(0.0,0.0,0.0), 0.4)
heroFuncs = [self.HeroPulseStats, self.HeroWeaponStats, self.HeroLifeStats, self.HeroEnergyStats, self.HeroActualEnergyRegenRate, self.HeroLifeRegen, self.HeroEnergyRegen]
self.hero_stats = BarUI.StatsUI(managerScene, Config.resolution.get_x()-150.0, 0.0, heroFuncs, Color(0.0,0.0,0.0), 0.4)
self.hud = Node()
self.interface_node().AddChild(self.hud)
def HeroPulseStats(self):
if self.hero != None and not self.hero.is_destroyed:
return " Pulse: %s x %s : %s " % (self.hero.data.pulse_damage, self.hero.data.pulse_shots, self.hero.data.homing)
return ""
def HeroWeaponStats(self):
if self.hero != None and not self.hero.is_destroyed:
if self.hero.right_weapon != None:
return " Weapon: %s " % (self.hero.right_weapon.type)
else:
return " Weapon: None "
return ""
def HeroLifeStats(self):
if self.hero != None and not self.hero.is_destroyed:
return " Life: %2.2f/%s " % (self.hero.life, self.hero.max_life)
return ""
def HeroEnergyStats(self):
if self.hero != None and not self.hero.is_destroyed:
return " Energy: %2.2f/%s " % (self.hero.energy, self.hero.max_energy)
return ""
def HeroActualEnergyRegenRate(self):
if self.hero != None and not self.hero.is_destroyed:
rate = self.hero.GetActualEnergyRegenRate()
effects = self.hero.GetActiveEffectsList()
for e in effects:
if e.GetDetailString().count("Energy Regen"):
rate += e.amount
return " Energy Regen: %2.2f/sec " % rate
return ""
def HeroLifeRegen(self):
if self.hero != None and not self.hero.is_destroyed:
aedl = self.hero.GetActiveEffectsDetailsList()
for s in aedl:
if s.count("Life Regen"):
return " "+s+" "
return ""
def HeroEnergyRegen(self):
if self.hero != None and not self.hero.is_destroyed:
aedl = self.hero.GetActiveEffectsDetailsList()
for s in aedl:
if s.count("Energy Regen"):
return " "+s+" "
return ""
def startCollisions(self):
self.collisionManager.Generate("Entity")
self.collisionManager.Generate("Gravity")
self.collisionManager.Generate("PowerUp")
self.collisionManager.Generate("RangeCheck")
self.collisionManager.Generate("Beam")
def GetHero(self): return self.hero
def Populate(self, objs):
#print self, " POPULATE: receiving objects ", objs
for obj in objs:
self.AddObject(obj)
def AddObject(self, obj):
self.objects.append(obj)
if obj.is_collidable:
self.colliding_objects.append(obj)
obj.collision_object.StartColliding()
self.AddEntity(obj)
#print self, "GOING TO ADD OBJECT %s [node=%s]" % (obj, obj.node)
if obj.GetNode() != None:
CN = self.content_node()
CN.AddChild(obj.GetNode())
#print "SCENE CONTENT NODE = ", CN
if obj.GetHUDNode():
self.hud.AddChild(obj.hud_node)
#print "FINISHED ADDING OBJECT"
if obj.CheckType("Asteroid"):
self.asteroid_count += 1
if obj.CheckType("Ship"):
self.ship_alive = True
self.hero = obj
def RemoveObject(self, obj):
if obj.CheckType("Asteroid"):
self.asteroid_count -= 1
if obj.CheckType("Ship"):
self.ship_alive = False
self.managerScene.heroData = self.hero.data
if self.hero.right_weapon != None:
self.hero_effects = [self.hero.right_weapon.GetCreationFunc()]
self.hero = None
self.managerScene.UpdatePoints( obj.GetPointsValue() )
self.objects.remove(obj)
if obj in self.colliding_objects:
self.colliding_objects.remove(obj)
self.RemoveEntity(obj)
obj.to_be_removed = True
#print "REMOVING OBJECT %s [%s]" % (obj, obj.node)
if obj.collision_object != None:
obj.collision_object.StopColliding()
obj.node.thisown = 1
del obj.node
obj.hud_node.thisown = 1
del obj.hud_node
del obj
def GenerateMap(self, heroData):
#print "GENERATE MARK 1"
self.Populate( MapGenerator.Generate(self.difficultyFactor, heroData) )
#print "GENERATE MARK 2"
self.content_node().set_drawable(MapGenerator.GetBackgroundDrawable() )
#print "GENERATE MARK 3"
self.interface_node().AddChild(self.stats.node)
self.interface_node().AddChild(self.hero_stats.node)
def ReGenerateMap(self, df, heroData):
self.difficultyFactor = df
# remove old objects
to_delete = [obj for obj in self.objects if not obj.CheckType("Ship")]
for obj in to_delete:
self.RemoveObject(obj)
self.finishTextNode.thisown = 1
del self.finishTextNode
self.finishTextNode = None
# populate the map
data = None
if self.hero == None: data = heroData
self.Populate( MapGenerator.Generate(self.difficultyFactor, data) )
self.content_node().set_drawable(MapGenerator.GetBackgroundDrawable() )
def GetLivePlanetsPoints(self):
v = 0
for obj in self.objects:
if obj.CheckType("Planet") and not obj.is_destroyed:
v += obj.life
return v
def SetAndShowSceneEndText(self, msgTag):
if self.finishTextNode != None: return
text = ResourceManager_CreateTextFromLanguageTag(msgTag)
self.finishTextNode = Node(text)
screenSize = Engine_reference().video_manager().video_size()
x = (screenSize.get_x()/2.0) - (text.width()/2.0)
y = (screenSize.get_y()/2.0) - (text.height()/2.0)
self.finishTextNode.modifier().set_offset( Vector2D(x, y) )
self.interface_node().AddChild(self.finishTextNode)
def CheckForEndGame(self):
if self.finishTextNode != None: return
if self.asteroid_count <= 0:
self.SetAndShowSceneEndText("GameWon")
self.managerScene.SetGameResult(True, []) #SceneFinishTask will take care of passing hero's active effects to the manager
self.managerScene.UpdatePoints( self.GetLivePlanetsPoints() * self.managerScene.difficulty )
phl = 100
if self.hero != None:
phl = self.hero.life * 5
self.managerScene.UpdatePoints( phl )
self.AddTask(SceneFinishTask(5.0, self))
elif not self.ship_alive:
self.SetAndShowSceneEndText("GameOver")
self.managerScene.SetGameResult(False, self.hero_effects)
self.AddTask(SceneFinishTask(5.0, self))
def Focus(self):
self.managerScene.radio.Play()
def DeFocus(self):
pass
def Update(self, dt): ###
to_delete = [o for o in self.objects if o.is_destroyed]
for obj in to_delete:
self.RemoveObject(obj)
self.CheckForEndGame()
self.stats.Update()
self.hero_stats.Update()
self.CheckCommands()
self.managerScene.radio.CheckCommands()
self.HandleCollisions()###
#if self.hero != None:
# offset = self.hero.GetPos()
# self.content_node().modifier().set_offset(offset)
#self.interface_node().modifier().set_offset(offset)
def CheckCommands(self):
input = Engine_reference().input_manager()
if input.KeyPressed(K_ESCAPE):
print "GameScene ESCAPING"
self.managerScene.SetGameQuit()
self.Finish()
elif input.KeyPressed(K_SPACE) or input.KeyPressed(K_p):
Engine_reference().PushScene( PauseScene() )
### cheats
if CHEATS:
if input.KeyPressed(K_PAGEUP):
self.managerScene.difficulty += 1
elif input.KeyPressed(K_PAGEDOWN):
self.managerScene.difficulty -= 1
elif input.KeyPressed(K_HOME):
self.managerScene.lives += 1
elif input.KeyPressed(K_END):
self.hero.invulnerable = True
elif input.KeyPressed(K_1):
cheat = ItemFactory.CreateRepairPack(self.hero.GetPos().get_x(), self.hero.GetPos().get_y())
self.AddObject(cheat)
elif input.KeyPressed(K_2):
cheat = ItemFactory.CreatePulsePack(self.hero.GetPos().get_x(), self.hero.GetPos().get_y())
self.AddObject(cheat)
elif input.KeyPressed(K_3):
cheat = ItemFactory.CreatePassivePack(self.hero.GetPos().get_x(), self.hero.GetPos().get_y())
self.AddObject(cheat)
elif input.KeyPressed(K_4):
cheat = ItemFactory.CreateActivePack(self.hero.GetPos().get_x(), self.hero.GetPos().get_y())
self.AddObject(cheat)
elif input.KeyPressed(K_5):
cheat = ItemFactory.CreateInstantPack(self.hero.GetPos().get_x(), self.hero.GetPos().get_y())
self.AddObject(cheat)
def HandleCollisions(self):
collision_list = CollisionInstanceList()
#print "HandleCollisions COLLISION_LIST = ", collision_list
for obj in self.colliding_objects:
if not obj.is_destroyed:
obj.collision_object.SearchCollisions(collision_list)
for col in collision_list:
#print "HC", col
#print "HANDLE COLLISION:: [%s].Handle(%s)" % (col[0], col[1])
col[0].Handle(col[1])
def End(self):
if self.hero != None:
self.managerScene.heroData = self.hero.data
class Ship (BasicEntity):
def __init__(self, x, y, data):
self.image_w = 420.0
self.image_h = 830.0
BasicEntity.__init__(self, x, y, "images/ship.png", 20.0, data.max_life, self.image_h/self.image_w)
self.radius = (self.size*0.5).Length()
self.node.set_zindex(1.0)
self.graphic_node = Node()
self.node.set_drawable(None)
self.graphic_node.set_drawable(self.shape)
self.graphic_node.set_zindex(1.0)
self.node.AddChild(self.graphic_node)
self.group = Group.SHIP
self.acceleration = Vector2D(0.0, 0.0)
self.data = data
self.max_energy = self.data.max_energy
self.energy = self.max_energy
self.bonus_regen_counter = 0.0
self.bonus_regen_threshold = 3.0
self.speed = 400.0 # |acceleration| in a given frame
self.max_speed = 200.0 # max |velocity| ship can attain.
#self.rangeCheck = RangeCheck(0, 0, 1024.0, "Asteroid")
#self.rangeCheck.AttachToEntity(self)
self.pulse_weapon = Weapons.Pulse()
self.right_weapon = None
self.pulse_weapon.Activate(self)
#self.right_weapon.Activate(self)
offset = self.size.get_y()/2.0
self.life_hud.SetOffset(offset)
self.energy_hud = BarUI(self, "energy", Color(0.0,0.0,1.0,1.0), offset+BAR_SIZE)
self.hud_node.AddChild(self.energy_hud.node)
self.charge_hud = BarUI(self.pulse_weapon, "charge_time", Color(1.0,1.0,0.0,1.0), -offset-2*BAR_SIZE)
self.hud_node.AddChild(self.charge_hud.node)
def setupCollisionGeometry(self):
self.geometry = ConvexPolygon(self.GetVertices())
def GetVertices(self):
pos = self.GetPos()
dir = self.GetDirection().Normalize()
sideDir = Vector2D(-dir.get_y(), dir.get_x())
sideDir = sideDir * (self.size.get_x()/2.0)
#middleL = pos + sideDir
#middleR = pos + (sideDir * -1)
middleL = sideDir
middleR = (sideDir * -1)
offset = dir * self.size.get_y()/2.0
#v1 = middleL + (offset*-1)
#v2 = middleL + offset
#v3 = middleR + offset
#v4 = middleR + (offset * -1)
v1 = middleL
v2 = offset
v3 = middleR
v4 = offset * -1
return Vector2DList([v1, v2, v3, v4])
def UpdateVertices(self):
self.geometry.set_vertices(self.GetVertices())
def set_max_life(self, value):
self.data.max_life = value
self.max_life = value
def set_max_energy(self, value):
self.data.max_energy = value
self.max_energy = value
def RestoreEnergy(self, amount):
if amount < 0: return
self.energy += amount
if self.energy > self.max_energy:
self.energy = self.max_energy
def TakeEnergy(self, amount):
if amount < 0: return
self.energy -= amount
if self.energy < 0:
self.energy = 0.0
def SetRightWeapon(self, weapon):
if self.right_weapon != None:
self.right_weapon.Dismantle()
self.right_weapon = weapon
self.right_weapon.Activate(self)
def GetDirection(self):
return Engine_reference().input_manager().GetMousePosition() - self.GetPos()
def Update(self, dt):
self.CheckCommands(dt)
self.UpdateVertices()
self.velocity = self.velocity + (self.acceleration * dt)
if (self.velocity.Length() > self.max_speed):
self.velocity = self.velocity * (self.max_speed/self.velocity.Length())
self.UpdatePosition(dt)
self.life_hud.Update()
self.energy_hud.Update()
self.charge_hud.Update()
self.CleanUpActiveEffects()
def CheckCommands(self, dt):
input = Engine_reference().input_manager()
mouse_dir = input.GetMousePosition() - self.node.modifier().offset()
mouse_dir = mouse_dir.Normalize()
self.node.modifier().set_rotation( -(mouse_dir.Angle()+pi/2.0) )
accel = Vector2D(0.0, 0.0)
############
#if input.KeyDown(K_w):
# accel += mouse_dir
#if input.KeyDown(K_a):
# left = mouse_dir.Rotate(-pi/2.0)
# left = left.Normalize()
# accel += left
# accel = accel.Normalize()
#if input.KeyDown(K_s):
# accel += -mouse_dir
# accel = accel.Normalize()
#if input.KeyDown(K_d):
# right = mouse_dir.Rotate(pi/2.0)
# right = right.Normalize()
# accel += right
# accel = accel.Normalize()
#############
if input.KeyDown(K_w):
accel += Vector2D(0.0, -1.0)
if input.KeyDown(K_a):
accel += Vector2D(-1.0, 0.0)
if input.KeyDown(K_s):
accel += Vector2D(0.0, 1.0)
if input.KeyDown(K_d):
accel += Vector2D(1.0, 0.0)
accel = accel.Normalize()
accel = accel * self.speed
self.acceleration = accel
#self.pulse_weapon.SetTarget( self.rangeCheck.GetTarget() )
weaponFiring = self.pulse_weapon.Toggle(input.MouseDown(M_BUTTON_LEFT), dt)
if self.right_weapon != None:
weaponFiring = weaponFiring or self.right_weapon.Toggle(input.MouseDown(M_BUTTON_RIGHT), dt)
if not weaponFiring:
if self.energy < self.max_energy:
self.RestoreEnergy(self.GetActualEnergyRegenRate() * dt)
self.bonus_regen_counter += dt
else:
self.bonus_regen_counter = 0.0
def GetActualEnergyRegenRate(self):
regen_rate = self.data.energy_regen_rate
if self.bonus_regen_counter > self.bonus_regen_threshold:
regen_rate += self.data.energy_regen_rate*0.25*((self.bonus_regen_counter-self.bonus_regen_threshold)/self.bonus_regen_threshold)
return regen_rate
def HandleCollision(self, target):
pass
class StatsUI:
def __init__(self, managerScene, x, y, stringFunctions, backColor, backAlpha=1.0):
self.managerScene = managerScene
self.node = Node()
#self.node.thisown = 0
self.size = Vector2D(150.0, 75.0)
self.backShape = SolidRectangle( self.size )
self.backShape.set_color( backColor )
self.backNode = Node()
self.backNode.set_drawable( self.backShape )
color = self.backNode.modifier().color()
color.set_a(backAlpha)
self.backNode.modifier().set_color(color)
self.node.AddChild(self.backNode)
self.node.modifier().set_offset( Vector2D(x,y) )
self.texts = []
self.stringsFunctions = stringFunctions
self.strings = [f() for f in self.stringsFunctions]
y = 0
for i in range(len(self.strings)):
self.texts.append( Engine_reference().text_manager().GetText(self.strings[i]) )
textNode = Node()
textNode.set_drawable(self.texts[i])
textNode.modifier().set_offset( Vector2D(0.0, i * 20.0 ) )
#textNode.thisown = 0
self.node.AddChild(textNode)
if self.texts[i].size().get_x() > self.size.get_x():
self.size.set_x(self.texts[i].size().get_x())
y += self.texts[i].size().get_y() + 5
self.size.set_y(y)
self.backShape.set_size(self.size)
def SetPos(self, x, y):
self.node.modifier().set_offset(Vector2D(x,y))
def UpdateSize(self, w, h):
self.size.set_x(w)
self.size.set_y(h)
self.backShape.set_size(self.size)
screenSize = Engine_reference().video_manager().video_size()
x = self.node.modifier().offset().get_x()
y = self.node.modifier().offset().get_y()
if x + w > screenSize.get_x():
x = screenSize.get_x() - w
if y + h > screenSize.get_y():
y = screenSize.get_y() - h
if x < 0: x = 0
if y < 0: y = 0
self.SetPos(x,y)
def Update(self):
w = self.size.get_x()
h = 0
update_size = False
for i in range(len(self.stringsFunctions)):
newstr = self.stringsFunctions[i]()
if newstr != self.strings[i]:
self.strings[i] = newstr
self.texts[i].SetMessage(newstr)
if self.texts[i].size().get_x() > w:
w = self.texts[i].size().get_x()
update_size = True
h += self.texts[i].size().get_y() + 5
if update_size: self.UpdateSize(w,h)
