def __init__( self, x, y, angle, squirrel=False ):
self.squirrel = squirrel
# Get references
self.videoManager = annchienta.getVideoManager()
self.cacheManager = annchienta.getCacheManager()
# Load sprites...
if self.squirrel:
self.sprite = self.cacheManager.getSurface("data/squirrel1.png")
else:
self.sprite = self.cacheManager.getSurface("data/splatter"+str(random.randint(1,5))+
".png")
# Set X and Y
self.x = x
self.y = y
self.velStart = random.uniform( 0.15, 0.25 )
self.yAccel = random.uniform( 0.0002, 0.0008 )
# Choose start direction
angle += random.uniform(-math.pi/8, math.pi/8)
self.xVel = self.velStart*math.cos( angle )
self.yVel = self.velStart*math.sin( angle )
self.sticksToTree = random.random()<0.5
self.xScale = -1 if random.random()<0.5 else 1
self.yScale = -1 if self.squirrel else 1
def __init__(self,
name="Equipment",
description="Manage and view equipment.",
combatantIndex=0):
# Stuff for sounds
self.cacheManager = annchienta.getCacheManager()
self.audioManager = annchienta.getAudioManager()
self.soundClickRev = self.cacheManager.getSound(
'sounds/click-reverse.ogg')
self.soundClickNeg = self.cacheManager.getSound(
'sounds/click-negative.ogg')
self.soundClickPos = self.cacheManager.getSound(
'sounds/click-positive.ogg')
self.soundClickNeu = self.cacheManager.getSound(
'sounds/click-neutral.ogg')
self.soundSave = self.cacheManager.getSound('sounds/save.ogg')
# Call superclass constructor
Menu.Menu.__init__(self, name, description)
# Get references
self.partyManager = PartyManager.getPartyManager()
# Set index
self.combatantIndex = combatantIndex
def __init__(self, combatants):
self.engine = annchienta.getEngine()
self.videoManager = annchienta.getVideoManager()
self.inputManager = annchienta.getInputManager()
self.mapManager = annchienta.getMapManager()
self.audioManager = annchienta.getAudioManager()
self.cacheManager = annchienta.getCacheManager()
self.mathManager = annchienta.getMathManager()
self.sceneManager = scene.getSceneManager()
self.battleManager = getBattleManager()
self.activeCombatants = self.combatants = combatants
self.running = True
self.enemies = filter(lambda c: c.hostile, self.activeCombatants)
self.allies = filter(lambda c: not c.hostile, self.activeCombatants)
# Set positions for combatants
for i in range(len(self.allies)):
a = self.allies[i]
w, h = a.getSize()
a.setPosition(
self.videoManager.getScreenWidth() / 2 - 30 - i * 10 - w,
100 + i * 40 - h)
for i in range(len(self.enemies)):
e = self.enemies[i]
w, h = e.getSize()
e.setPosition(self.videoManager.getScreenWidth() / 2 + 30 + i * 10,
100 + i * 40 - h)
self.updateCombatantArrays()
self.background = None
def __init__( self ):
self.engine = annchienta.getEngine()
self.videoManager = annchienta.getVideoManager()
self.inputManager = annchienta.getInputManager()
self.cacheManager = annchienta.getCacheManager()
self.mapManager = annchienta.getMapManager()
self.mathManager = annchienta.getMathManager()
self.sceneManager = SceneManager.getSceneManager()
# Background spriteace
self.background = annchienta.Surface( "images/backgrounds/sky.png" )
self.backgroundY = 0.0
# Create a ship for the player
self.ship = GameObject( annchienta.Vector( videoManager.getScreenWidth()/2, videoManager.getScreenHeight()/2 ),
annchienta.Surface( "sprites/ship_small.png" ) )
# Load sprites into cache
self.enemySprite = annchienta.Surface("sprites/ship_pirate.png")
# All enemies
self.enemies = []
# The final enemy
self.captain = None
# Number of miliseconds we need to fly to gain victory
self.victoryTime = 60000
def __init__(self, m_battle, m_combatant):
self.cacheManager = annchienta.getCacheManager()
self.audioManager = annchienta.getAudioManager()
self.mathManager = annchienta.getMathManager()
self.sceneManager = scene.getSceneManager()
self.m_combatant = m_combatant
self.m_battle = m_battle
self.turns = 0
def __init__(self, xmlElement):
# Stuff for sounds
self.cacheManager = annchienta.getCacheManager()
self.audioManager = annchienta.getAudioManager()
self.soundLevelup = self.cacheManager.getSound('sounds/levelup.ogg')
self.soundClickNeu = self.cacheManager.getSound(
'sounds/click-neutral.ogg')
# Base constructor
Combatant.Combatant.__init__(self, xmlElement)
# References
self.partyManager = PartyManager.getPartyManager()
self.logManager = annchienta.getLogManager()
self.inputManager = annchienta.getInputManager()
self.videoManager = annchienta.getVideoManager()
# Get our weapon
weaponElements = xmlElement.getElementsByTagName("weapon")
if len(weaponElements):
# Get the weapon name and search for the corresponding element
weaponName = str(weaponElements[0].getAttribute("name"))
self.setWeapon(weaponName)
else:
self.logManager.warning("No Weapon defined for Ally!")
# Get the position of our hand
handElements = xmlElement.getElementsByTagName("hand")
if len(handElements):
self.hand = annchienta.Vector(
float(handElements[0].getAttribute("x")),
float(handElements[0].getAttribute("y")))
else:
self.hand = None
# Create a dictionary describing the level grades
self.grades = {}
gradesElement = xmlElement.getElementsByTagName("grades")[0]
for k in gradesElement.attributes.keys():
self.grades[k] = int(gradesElement.attributes[k].value)
# Create dictionary describing the level learns
self.learn = {}
learnElement = xmlElement.getElementsByTagName("learn")[0]
text = str(learnElement.firstChild.data)
words = text.split()
for i in range(int(len(words) / 2)):
self.learn[int(words[i * 2])] = words[i * 2 + 1]
# Build the menu.
self.buildMenu()
def __init__( self ):
# Get nessecary references
self.engine = annchienta.getEngine()
self.videoManager = annchienta.getVideoManager()
self.inputManager = annchienta.getInputManager()
self.audioManager = annchienta.getAudioManager()
self.cacheManager = annchienta.getCacheManager()
# Set video mode.
self.videoManager.setVideoMode( 480, 320, "Happy Squirrel Land!" )
self.inputManager.setMouseVisibility( False )
self.game = Game.Game()
def __init__(self):
# Get nessecary references
self.engine = annchienta.getEngine()
self.videoManager = annchienta.getVideoManager()
self.inputManager = annchienta.getInputManager()
self.audioManager = annchienta.getAudioManager()
self.cacheManager = annchienta.getCacheManager()
# Various sprites
self.background = self.cacheManager.getSurface("data/background.png")
self.target = self.cacheManager.getSurface("data/target.png")
# Main font
self.font = annchienta.Font("data/regular.ttf", 14)
def __init__( self, name, toolTip=None ):
# Stuff for sounds
self.cacheManager = annchienta.getCacheManager()
self.audioManager = annchienta.getAudioManager()
self.soundClickRev = self.cacheManager.getSound('sounds/click-reverse.ogg')
self.soundClickNeg = self.cacheManager.getSound('sounds/click-negative.ogg')
self.soundClickPos = self.cacheManager.getSound('sounds/click-positive.ogg')
self.soundClickNeu = self.cacheManager.getSound('sounds/click-neutral.ogg')
self.soundSave = self.cacheManager.getSound('sounds/save.ogg')
# Base constructor
MenuItem.MenuItem.__init__( self, name, toolTip )
# Get references
self.inputManager = annchienta.getInputManager()
self.videoManager = annchienta.getVideoManager()
self.mapManager = annchienta.getMapManager()
self.sceneManager = SceneManager.getSceneManager()
# Flags
self.done = False
self.canceled = False
# Size of the menu
self.width, self.height = 0, 0
# Position on the screen
self.x, self.y = 0, 0
self.columns = 1
self.rows = 1
# If the tooltip should be drawn on top of the screen
self.toolTipOnTop = True
# Kinda self explanatory
self.maxItemsInColumn = 4
# The options in the menu. Use setOptions() to set them!
self.options = []
# The currently selected item index
self.selectedOptionIndex = 0
self.selectedOption = None
def __init__(self, xmlElement):
# Call super constructor.
BattleEntity.__init__(self, xmlElement)
# Set our name
self.description = str(xmlElement.getAttribute("description"))
# Get our sprite
spriteElements = xmlElement.getElementsByTagName("sprite")
if len(spriteElements):
cacheManager = annchienta.getCacheManager()
self.sprite = cacheManager.getSurface(
str(spriteElements[0].getAttribute("filename")))
self.grip = annchienta.Vector(
float(spriteElements[0].getAttribute("gripx")),
float(spriteElements[0].getAttribute("gripy")))
else:
self.sprite = None
self.grip = None
def __init__(self):
# Get references
self.engine = annchienta.getEngine()
self.videoManager = annchienta.getVideoManager()
self.inputManager = annchienta.getInputManager()
self.audioManager = annchienta.getAudioManager()
self.cacheManager = annchienta.getCacheManager()
self.mapManager = annchienta.getMapManager()
# Load our assets
self.defaultFont = annchienta.Font("assets/regular.ttf", 14)
self.italicsFont = annchienta.Font("assets/italics.ttf", 14)
self.largeDefaultFont = annchienta.Font("assets/regular.ttf", 20)
self.largeItalicsFont = annchienta.Font("assets/italics.ttf", 20)
self.boxTextures = map(
lambda i: annchienta.Surface("assets/box" + str(i) + ".png"),
range(9))
self.margin = 6
def __init__( self ):
# Get references
self.videoManager = annchienta.getVideoManager()
self.cacheManager = annchienta.getCacheManager()
self.audioManager = annchienta.getAudioManager()
# Load sprites...
self.sprite = self.cacheManager.getSurface("data/squirrel1.png")
self.balloon = self.cacheManager.getSurface("data/balloon"+str(random.randint(1,3))+".png")
# Set X and Y
self.x = -self.sprite.getWidth() if random.random()<0.5 else self.videoManager.getScreenWidth()+self.sprite.getWidth()
self.y = float(Level.treeUpperY() - self.sprite.getHeight()/2)
self.xVel = 0.1 if self.x<0 else -0.1
self.jumping = random.random()<0.6
self.yVel = self.yVelStart
# Balloontimer
self.balloonTimer = random.randint(-3000,-1000)
def __init__(self):
# Get references
self.videoManager = annchienta.getVideoManager()
self.inputManager = annchienta.getInputManager()
self.cacheManager = annchienta.getCacheManager()
self.audioManager = annchienta.getAudioManager()
# Load sprites...
self.sprite = self.cacheManager.getSurface("data/player.png")
self.gun = self.cacheManager.getSurface("data/player_gun.png")
# Set X and Y
self.x = float(self.videoManager.getScreenWidth() / 2)
self.y = float(Level.treeUpperY() - self.sprite.getHeight() / 2)
self.xScale = 1
self.angle = 0
self.weaponReloadTimer = -1000
self.rage = self.maxRage
def __init__(self, xmlElement):
# Stuff for sounds
self.cacheManager = annchienta.getCacheManager()
self.audioManager = annchienta.getAudioManager()
self.soundNeg = self.cacheManager.getSound('sounds/click-negative.ogg')
self.soundHeal = self.cacheManager.getSound('sounds/cure.ogg')
self.soundHealHi = self.cacheManager.getSound('sounds/cura.ogg')
self.soundExplode = self.cacheManager.getSound('sounds/grenade.ogg')
# Get some references
self.logManager = annchienta.getLogManager()
text = str(xmlElement.firstChild.data)
words = text.split()
self.dictionary = {}
# Get all the items
for i in range(int(len(words) / 2)):
self.dictionary[words[i * 2]] = int(words[i * 2 + 1])
def __init__( self ):
# Get references
self.engine = annchienta.getEngine()
self.videoManager = annchienta.getVideoManager()
self.inputManager = annchienta.getInputManager()
self.cacheManager = annchienta.getCacheManager()
self.mapManager = annchienta.getMapManager()
self.mathManager = annchienta.getMathManager()
self.sceneManager = SceneManager.getSceneManager()
# Load images
self.background = annchienta.Surface("images/backgrounds/water.png")
self.cacheManager.getSurface("sprites/rock1.png")
self.cacheManager.getSurface("sprites/rock2.png")
# Initial positions
self.backgroundY = 0.0
self.speed = 0.1
self.nextSpawn = 500
self.rocks = []
self.raft = RaftObject( annchienta.Surface("sprites/raft.png"), annchienta.Vector( self.videoManager.getScreenWidth()/2, self.videoManager.getScreenHeight()/2 ) )
def __init__(self, combatants, background, canFlee):
# Set variables
self.combatants = combatants
self.running = True
self.background = background
self.canFlee = canFlee
self.won = False
self.actionLock = False
# Get references
self.engine = annchienta.getEngine()
self.videoManager = annchienta.getVideoManager()
self.inputManager = annchienta.getInputManager()
self.cacheManager = annchienta.getCacheManager()
self.mathManager = annchienta.getMathManager()
self.mapManager = annchienta.getMapManager()
self.audioManager = annchienta.getAudioManager()
self.sceneManager = SceneManager.getSceneManager()
self.partyManager = PartyManager.getPartyManager()
# Lines for the 'console' window
self.lines = []
def __init__(self):
# Get some references
self.engine = annchienta.getEngine()
self.inputManager = annchienta.getInputManager()
self.mapManager = annchienta.getMapManager()
self.cacheManager = annchienta.getCacheManager()
self.mathManager = annchienta.getMathManager()
self.sceneManager = SceneManager.getSceneManager()
# Set variables
self.player = 0
self.records = []
self.inventory = 0
self.lastMaps = []
self.currentMap = 0
self.startTime = 0
# Create a map loader
self.mapLoader = MapLoader()
# Battle variables
self.randomBattleDelay = self.mathManager.randInt(300, 400)
def __init__(self):
# Stuff for sounds
self.cacheManager = annchienta.getCacheManager()
self.audioManager = annchienta.getAudioManager()
self.soundClickRev = self.cacheManager.getSound(
'sounds/click-reverse.ogg')
self.soundClickNeg = self.cacheManager.getSound(
'sounds/click-negative.ogg')
self.soundClickPos = self.cacheManager.getSound(
'sounds/click-positive.ogg')
self.soundClickNeu = self.cacheManager.getSound(
'sounds/click-neutral.ogg')
self.soundSave = self.cacheManager.getSound('sounds/save.ogg')
# General references
self.mapManager = annchienta.getMapManager()
self.inputManager = annchienta.getInputManager()
self.partyManager = PartyManager.getPartyManager()
self.menu = Menu.Menu("In-Game Menu", "Select action.")
options = []
# An option that does nothing.
options += [
MenuItem.MenuItem("continue", "Close menu and continue playing.")
]
# A submenu for party management.
options += [MenuItem.MenuItem("party", "Change equipment, heal...")]
# An option to quit.
options += [MenuItem.MenuItem("quit", "Stop playing.")]
self.menu.setOptions(options)
self.menu.top()
class SceneManager:
margin = 6
defaultFont, italicsFont = None, None
boxTextures = []
engine = annchienta.getEngine()
videoManager = annchienta.getVideoManager()
inputManager = annchienta.getInputManager()
audioManager = annchienta.getAudioManager()
cacheManager = annchienta.getCacheManager()
mathManager = annchienta.getMathManager()
mapManager = annchienta.getMapManager()
def waitForClick(self):
self.videoManager.storeBuffer(7)
self.inputManager.update()
while self.inputManager.running(
) and not self.inputManager.buttonTicked(0):
self.inputManager.update()
self.videoManager.clear()
self.videoManager.restoreBuffer(7)
self.videoManager.flip()
self.mapManager.resync()
def defaultColor(self):
self.videoManager.setColor(255, 255, 255)
def activeColor(self):
self.videoManager.setColor(255, 255, 0)
def inactiveColor(self):
self.videoManager.setColor(170, 170, 170)
## \brief Draw a box.
#
# A box is the main GUI element. You can customize the box layout
# by changing bitmaps.
def drawBox(self, x1, y1, x2, y2):
#self.videoManager.push()
#self.videoManager.identity()
self.videoManager.boxBlur(x1, y1, x2, y2)
#self.videoManager.pop()
# If there are not enough textures, just draw a stupid simple box.
if (len(self.boxTextures) <= 8):
self.videoManager.setColor(100, 100, 150, 200)
self.videoManager.drawRectangle(x1, y1, x2, y2)
self.videoManager.setColor()
else:
# Draw the corner textures
self.videoManager.drawSurface(self.boxTextures[0], x1, y1)
self.videoManager.drawSurface(self.boxTextures[2],
x2 - self.boxTextures[2].getWidth(),
y1)
self.videoManager.drawSurface(self.boxTextures[6], x1,
y2 - self.boxTextures[6].getHeight())
self.videoManager.drawSurface(self.boxTextures[8],
x2 - self.boxTextures[2].getWidth(),
y2 - self.boxTextures[6].getHeight())
# Draw the side textures as patterns.
self.videoManager.drawPattern(self.boxTextures[1],
x1 + self.boxTextures[0].getWidth(),
y1,
x2 - self.boxTextures[2].getWidth(),
y1 + self.boxTextures[1].getHeight())
self.videoManager.drawPattern(self.boxTextures[7],
x1 + self.boxTextures[7].getWidth(),
y2 - self.boxTextures[7].getHeight(),
x2 - self.boxTextures[8].getWidth(),
y2)
self.videoManager.drawPattern(self.boxTextures[3], x1,
y1 + self.boxTextures[0].getHeight(),
x1 + self.boxTextures[3].getWidth(),
y2 - self.boxTextures[6].getHeight())
self.videoManager.drawPattern(self.boxTextures[5],
x2 - self.boxTextures[5].getWidth(),
y1 + self.boxTextures[2].getHeight(),
x2,
y2 - self.boxTextures[8].getHeight())
# Draw the main texture as pattern.
self.videoManager.drawPattern(self.boxTextures[4],
x1 + self.boxTextures[0].getWidth(),
y1 + self.boxTextures[0].getHeight(),
x2 - self.boxTextures[8].getWidth(),
y2 - self.boxTextures[8].getHeight())
## \brief Renders justified text.
#
# \return The height of the rendered text.
def renderTextInArea(self, text, x1, y1, x2, font):
paragraphs = text.split('\n')
spaceWidth = font.getStringWidth(' ')
maxWidth = x2 - x1
oy1 = y1
for paragraph in paragraphs:
words = paragraph.split()
lineWords = []
totalWidth = 0
for word in words:
if totalWidth + font.getStringWidth(
word) + spaceWidth < maxWidth:
totalWidth += font.getStringWidth(word) + spaceWidth
lineWords.append(word)
else:
if len(lineWords) <= 0:
break
totalWidth = -spaceWidth
for w in lineWords:
totalWidth += font.getStringWidth(w)
actualSpaceWidth = (maxWidth -
totalWidth) / (len(lineWords))
x = x1
for w in lineWords:
self.videoManager.drawString(font, w, x, y1)
x += font.getStringWidth(w) + actualSpaceWidth
y1 += font.getLineHeight()
totalWidth = font.getStringWidth(word)
lineWords = [word]
x = x1
for w in lineWords:
self.videoManager.drawString(font, w, x, y1)
x += font.getStringWidth(w) + spaceWidth
y1 += font.getLineHeight()
# Return the height elapsed.
return y1 - oy1
## \brief Display some text.
#
# \param text The text to be displayed.
def text(self, text, font=None):
font = self.defaultFont if font is None else font
text = str(text)
self.inputManager.update()
self.videoManager.storeBuffer(7)
while self.inputManager.running(
) and not self.inputManager.buttonTicked(0):
self.inputManager.update()
self.videoManager.clear()
self.videoManager.restoreBuffer(7)
self.drawBox(self.margin, self.margin,
self.videoManager.getScreenWidth() - self.margin, 110)
self.videoManager.setClippingRectangle(
2 * self.margin, 2 * self.margin,
self.videoManager.getScreenWidth() - 3 * self.margin,
110 - self.margin)
self.defaultColor()
height = self.renderTextInArea(
text, 2 * self.margin, 2 * self.margin,
self.videoManager.getScreenWidth() - 3 * self.margin, font)
height -= 110 - font.getLineHeight()
self.videoManager.disableClipping()
self.videoManager.flip()
self.videoManager.restoreBuffer(7)
self.mapManager.resync()
def thoughts(self, text):
text = str(text)
scroll = 0
self.inputManager.update()
self.videoManager.storeBuffer(7)
while self.inputManager.running(
) and not self.inputManager.buttonTicked(0):
self.inputManager.update()
self.videoManager.clear()
self.videoManager.setColor(0, 0, 0)
self.videoManager.drawRectangle(
0, 0, self.videoManager.getScreenWidth(),
self.videoManager.getScreenHeight())
self.defaultColor()
self.renderTextInArea(
text, 2 * self.margin, 100,
self.videoManager.getScreenWidth() - 2 * self.margin,
self.italicsFont)
self.videoManager.flip()
self.videoManager.restoreBuffer(7)
self.mapManager.resync()
## \brief Display some info.
#
# \param text The text to be displayed.
def info(self, text, timeOut=800):
text = str(text)
self.inputManager.update()
self.videoManager.storeBuffer(7)
start = self.engine.getTicks()
done = False
while not done:
self.inputManager.update()
self.videoManager.clear()
self.videoManager.restoreBuffer(7)
self.drawBox(
self.margin,
self.videoManager.getScreenHeight() - self.margin * 3 -
self.defaultFont.getLineHeight(),
self.videoManager.getScreenWidth() - self.margin,
self.videoManager.getScreenHeight() - self.margin)
self.defaultColor()
self.videoManager.drawString(
self.defaultFont, text, 2 * self.margin,
self.videoManager.getScreenHeight() - self.margin * 2 -
self.defaultFont.getLineHeight())
self.videoManager.flip()
if not self.inputManager.running(
) or self.inputManager.buttonTicked(0):
done = True
if timeOut is not None:
if self.engine.getTicks() > start + timeOut:
done = True
self.videoManager.restoreBuffer(7)
self.mapManager.resync()
## \brief lets someone say something.
#
def speak(self, object, text):
self.mapManager.cameraPeekAt(object, True)
self.videoManager.clear()
self.mapManager.renderFrame()
self.text(object.getName().capitalize() + ":\n" + text,
self.defaultFont)
def chat(self, speaker, intro, answers):
if speaker is not None:
self.mapManager.cameraPeekAt(speaker, True)
self.videoManager.clear()
self.mapManager.renderFrame()
selected = 0
self.inputManager.update()
self.videoManager.storeBuffer(7)
intro = (speaker.getName().capitalize() + ":\n" +
intro) if speaker is not None else intro
done = False
while self.inputManager.running() and not done:
self.inputManager.update()
y = 0
self.videoManager.clear()
self.videoManager.restoreBuffer(7)
self.drawBox(self.margin, self.margin,
self.videoManager.getScreenWidth() - self.margin, 110)
# Make sure everything goes in the box.
self.videoManager.setClippingRectangle(
2 * self.margin, 2 * self.margin,
self.videoManager.getScreenWidth() - 2 * self.margin,
110 - self.margin)
self.defaultColor()
height = self.renderTextInArea(
intro, 2 * self.margin, 2 * self.margin + y,
self.videoManager.getScreenWidth() - 2 * self.margin,
self.defaultFont)
y += height + self.margin
for i in range(len(answers)):
if self.inputManager.hover(
2 * self.margin, 2 * self.margin + y,
self.videoManager.getScreenWidth() - 2 * self.margin,
2 * self.margin + y +
self.defaultFont.getLineHeight()):
self.activeColor()
if self.inputManager.buttonTicked(0):
selected = i
done = True
else:
self.inactiveColor()
height = self.renderTextInArea(
answers[i], 2 * self.margin, 2 * self.margin + y,
self.videoManager.getScreenWidth() - 2 * self.margin,
self.defaultFont)
y += height
self.videoManager.disableClipping()
self.videoManager.flip()
self.videoManager.setColor()
self.videoManager.restoreBuffer(7)
self.mapManager.resync()
return selected
def choose(self, title, answers):
selected = 0
done = False
self.inputManager.update()
self.videoManager.storeBuffer(7)
while self.inputManager.running() and not done:
self.inputManager.update()
self.videoManager.clear()
self.videoManager.restoreBuffer(7)
self.drawBox(self.margin, self.margin,
self.videoManager.getScreenWidth() - self.margin, 110)
self.defaultColor()
y = self.margin * 2
self.videoManager.drawString(self.defaultFont, title,
self.margin * 2, y)
y += self.defaultFont.getLineHeight()
for i in range(len(answers)):
if self.inputManager.hover(
self.margin * 2, y,
self.videoManager.getScreenWidth() - self.margin * 2,
y + self.defaultFont.getLineHeight()):
self.activeColor()
if self.inputManager.buttonTicked(0):
selected = i
done = True
else:
self.inactiveColor()
self.videoManager.drawString(self.defaultFont, answers[i],
self.margin * 2, y)
y += self.defaultFont.getLineHeight()
self.videoManager.flip()
self.videoManager.setColor()
self.videoManager.restoreBuffer(7)
self.mapManager.resync()
return answers[selected]
## \moves someone.
#
def move(self, objects, points):
# Convert objects and points to lists if they aren't.
if type(objects) is not type([]):
objects = [objects]
points = [points]
self.inputManager.update()
self.inputManager.setInputMode(annchienta.CinematicMode)
going = 1
while self.inputManager.running() and going:
going = sum(
map(lambda i: int(objects[i].stepTo(points[i])),
range(len(objects))))
self.mapManager.update(False)
self.inputManager.update()
self.mapManager.cameraPeekAt(objects[0], True)
self.videoManager.clear()
self.mapManager.renderFrame()
self.videoManager.flip()
self.inputManager.setInputMode(annchienta.InteractiveMode)
self.mapManager.resync()
## \brief Inits a dialog.
#
def initDialog(self, objects):
for o in objects:
o.freeze(True)
o.setStandAnimation()
for i in range(len(objects)):
objects[i].lookAt(objects[(i + 1) % len(objects)])
self.objectsInDialog = objects
## \brief Ends a dialog.
#
def quitDialog(self):
for object in self.objectsInDialog:
object.freeze(False)
## \fades
#
def fadeOut(self, r=0, g=0, b=0, ms=500):
start = self.engine.getTicks()
self.videoManager.storeBuffer(7)
while self.engine.getTicks(
) < start + ms and self.inputManager.running():
self.inputManager.update()
alpha = float(self.engine.getTicks() - start) / float(ms) * 255.0
self.videoManager.clear()
self.videoManager.restoreBuffer(7)
self.videoManager.setColor(r, g, b, int(alpha))
self.videoManager.drawRectangle(
0, 0, self.videoManager.getScreenWidth(),
self.videoManager.getScreenHeight())
self.videoManager.flip()
self.mapManager.resync()
def rotateEffect(self, duration=1500):
start = self.engine.getTicks()
self.videoManager.storeBuffer(7)
while self.engine.getTicks(
) < start + duration and self.inputManager.running():
factor = float(self.engine.getTicks() - start) / float(duration)
self.videoManager.clear()
self.videoManager.translate(
self.videoManager.getScreenWidth() / 2,
self.videoManager.getScreenHeight() / 2)
self.videoManager.rotate((factor + 1.) * (factor + 1.) * 360.)
self.videoManager.scale(factor * 50., factor * 50.)
self.videoManager.translate(
-self.videoManager.getScreenWidth() / 2,
-self.videoManager.getScreenHeight() / 2)
self.videoManager.restoreBuffer(7)
self.videoManager.flip()
self.mapManager.resync()
def noise(self, duration=1000):
start = self.engine.getTicks()
self.videoManager.storeBuffer(7)
s = self.cacheManager.getSound("sounds/noise.ogg")
self.audioManager.playSound(s)
while self.engine.getTicks(
) < start + duration and self.inputManager.running():
self.inputManager.update()
self.videoManager.clear()
r = self.mathManager.randInt(0, 256)
self.videoManager.setColor(r, r, r)
self.videoManager.drawRectangle(
0, 0, self.videoManager.getScreenWidth(),
self.videoManager.getScreenHeight())
self.videoManager.flip()
self.videoManager.setColor()
self.videoManager.restoreBuffer(7)
self.mapManager.resync()
import annchienta
import MenuItem, Menu
import PartyManager
import SceneManager
cacheManager = annchienta.getCacheManager()
sound = cacheManager.getSound('sounds/crystal.ogg')
audioManager = annchienta.getAudioManager()
audioManager.playSound( sound )
partyManager = PartyManager.getPartyManager()
partyManager.heal()
sceneManager = SceneManager.getSceneManager()
sceneManager.initDialog( [annchienta.getActiveObject(), annchienta.getPassiveObject()] )
sceneManager.text("Your health was restored!")
menu = Menu.Menu("Save menu.", "Save your game.")
options = [ MenuItem.MenuItem("save", "Save your progress."), MenuItem.MenuItem("cancel", "Return to the game.") ]
menu.setOptions( options )
menu.top()
ans = menu.pop()
if ans is not None:
if ans.name == "save":
path = os.path.join(os.path.expanduser("~"), ".fall-of-imiryn/save.xml")
partyManager.save(path)
sceneManager.text("The progress in your travels has been recorded.")
def __init__(self, xmlElement):
# Call super constructor
BattleEntity.BattleEntity.__init__(self, xmlElement)
# We need to log stuff
self.logManager = annchienta.getLogManager()
# Get references
self.videoManager = annchienta.getVideoManager()
self.cacheManager = annchienta.getCacheManager()
self.mathManager = annchienta.getMathManager()
self.sceneManager = SceneManager.getSceneManager()
# Create a dictionary describing the level stuff
self.level = {}
levelElement = xmlElement.getElementsByTagName("level")[0]
for k in levelElement.attributes.keys():
self.level[k] = int(levelElement.attributes[k].value)
# Create a dictionary describing the health stats
self.healthStats = {}
healthStatsElement = xmlElement.getElementsByTagName("healthstats")[0]
for k in healthStatsElement.attributes.keys():
self.healthStats[k] = int(healthStatsElement.attributes[k].value)
# Get all possible actions. The actual actions are in the first child
# of the element, hence the code. <actions> action1 action2 </actions>
actionsElement = xmlElement.getElementsByTagName("actions")[0]
actionNames = str(actionsElement.firstChild.data).split()
# Prepare to get the from the xml data
self.actions = []
# Get them
for a in actionNames:
self.addAction(a)
# Create a dictionary describing the elemental properties
# Only enemies have them, usually
self.primaryElemental = {}
elementalElements = xmlElement.getElementsByTagName("elemental")
if len(elementalElements):
for k in elementalElements[0].attributes.keys():
self.primaryElemental[k] = float(
elementalElements[0].attributes[k].value)
# Load sprite
spriteElement = xmlElement.getElementsByTagName("sprite")[0]
# Keep the filename so we can save it later on
self.spriteFilename = str(spriteElement.getAttribute("filename"))
self.sprite = annchienta.Surface(self.spriteFilename)
if spriteElement.hasAttribute("x1"):
self.sx1 = int(spriteElement.getAttribute("x1"))
self.sy1 = int(spriteElement.getAttribute("y1"))
self.sx2 = int(spriteElement.getAttribute("x2"))
self.sy2 = int(spriteElement.getAttribute("y2"))
else:
self.sx1, self.sy1 = 0, 0
self.sx2 = self.sprite.getWidth()
self.sy2 = self.sprite.getHeight()
# Get width and height from those facts.
self.width = self.sx2 - self.sx1
self.height = self.sy2 - self.sy1
self.position = annchienta.Vector(0, 0)
# We will draw a mark upon ourselves sometimes
self.active = False
self.selected = False
# Damage done by an attack
self.damage = 0
self.damageTimer = 0.0
self.reset()
def __init__(self, xmlElement=None):
self.cacheManager = annchienta.getCacheManager()
self.elemental = {}
if xmlElement:
# Set our name and category
self.name = str(xmlElement.getAttribute("name"))
self.category = str(xmlElement.getAttribute("category"))
self.target = int(xmlElement.getAttribute("target"))
# Get the description
descriptionElement = xmlElement.getElementsByTagName(
"description")[0]
self.description = str(descriptionElement.firstChild.data)
# Set cost
costElement = xmlElement.getElementsByTagName("cost")[0]
self.cost = int(costElement.getAttribute("mp"))
# Create a dictionary describing the elemental properties
found = xmlElement.getElementsByTagName("elemental")
if len(found):
elementalElement = found[0]
for k in elementalElement.attributes.keys():
self.elemental[k] = int(
elementalElement.attributes[k].value)
# Set factor, hit and type
found = xmlElement.getElementsByTagName("power")
if len(found):
powerElement = found[0]
self.factor = float(powerElement.getAttribute("factor"))
self.hit = float(powerElement.getAttribute("hit"))
self.type = str(powerElement.getAttribute("type"))
# Set statusEffect and statusHit
found = xmlElement.getElementsByTagName("status")
if len(found):
statusElement = found[0]
self.statusEffect = str(statusElement.getAttribute("effect"))
self.statusHit = float(statusElement.getAttribute("hit"))
# Set animation and animationData
found = xmlElement.getElementsByTagName("animation")
if len(found):
animationElement = found[0]
sprite, sound = None, None
if animationElement.hasAttribute("sprite"):
sprite = self.cacheManager.getSurface(
str(animationElement.getAttribute("sprite")))
if animationElement.hasAttribute("sound"):
sound = self.cacheManager.getSound(
str(animationElement.getAttribute("sound")))
type = str(animationElement.getAttribute("type"))
if type == "attack":
self.animation = AttackAnimation.AttackAnimation(
sprite, sound)
elif type == "sprite":
self.animation = SpriteAnimation.SpriteAnimation(
sprite, sound)
else:
self.animation = None
