Beispiel #1
0
class Menu(directicus.engine.Menu):

    color = (0,0,0)
    hover = (100,100,100)
    headerFont = pygame.font.Font('data/font.ttf',50)
    headerFont.set_underline(True)
    regularFont = pygame.font.Font('data/font.ttf',30)

    #def __init__(self):
    #    self.cursor = pygame.image.load('data/cursors/arrow.bmp')
    #    self.cursor.set_colorkey((14,56,102))

    #def EVT_tick(self,event):
    #    directicus.engine.Menu.EVT_tick(self,event)
    #    icon = pygame.image.load('data/cursors/sword.bmp')
    #    icon.set_colorkey((14,56,102))
    #    pygame.display.set_caption('Forest Patrol')
    #    pygame.display.set_icon(icon)
    #    rect = self.cursor.get_rect()
    #    rect.topleft = pygame.mouse.get_pos()
    #    pygame.display.get_surface().blit(self.cursor,rect)
    #    pygame.display.update(rect)

    def start(self):
        self.background = pygame.image.load('data/menu.png')
        self.audio = Audio()
        self.music = Music()
        self.audio.volume = 0.3
        self.music.volume = 0.5
        pygame.display.get_surface().blit(self.background,(0,0))
        icon = resources.Cursor.sword #pygame.image.load('data/cursors/sword.png')
        icon.set_colorkey((14,56,102))
        pygame.display.set_caption('Forest Patrol')
        pygame.display.set_icon(icon)

        directicus.engine.Menu.__init__(self)
        directicus.engine.Menu.start(self)
        #pygame.mouse.set_visible(False)

    def EVT_MouseButtonDown(self,event):
        if self.selected:
            self.audio.play('data/sounds/sword-draw.wav')
        directicus.engine.Menu.EVT_MouseButtonDown(self,event)

    def EVT_KeyDown(self,event):
        if pygame.key.name(event.key) == 'escape':
            self.quit()

    def quit(self,next=None):
        #pygame.mouse.set_visible(True)
        directicus.engine.Menu.quit(self,next)
Beispiel #2
0
 def __init__(self):
     State.__init__(self)
     self.audio = Audio()
     self.audio.volume = 0.5
     self.music = Music()
     self.music.volume = 0.7
     self.music.stop(500)
     self.delay = 10*40
     self.playing = False
     self.image = data.candy
     self.image.set_alpha(0)
Beispiel #3
0
    def start(self):
        self.background = pygame.image.load('data/menu.png')
        self.audio = Audio()
        self.music = Music()
        self.audio.volume = 0.3
        self.music.volume = 0.5
        pygame.display.get_surface().blit(self.background,(0,0))
        icon = resources.Cursor.sword #pygame.image.load('data/cursors/sword.png')
        icon.set_colorkey((14,56,102))
        pygame.display.set_caption('Forest Patrol')
        pygame.display.set_icon(icon)

        directicus.engine.Menu.__init__(self)
        directicus.engine.Menu.start(self)
Beispiel #4
0
 def __init__(self,lvl=None):
     State.__init__(self)
     if lvl == None:
         self.level = level.load(Campaign.next())
     else:
         self.level = lvl
     self.bg = pygame.sprite.Group(self.level.s)
     self.selected = None
     self.audio = Audio()
     self.music = Music()
     self.music.volume = 1
     self.audio.volume = 0.5
     self.alarm = 0
     self.music.stop(500)
     self.music.play('data/music/play.ogg',-1)
     self.playing = True
Beispiel #5
0
 def __init__(self,enemies=1,size=(3000,3000)):
     directicus.engine.State.__init__(self)
     reload(level)
     self.level = level.create(size,enemies=enemies)
     self.audio = Audio()
     self.music = Music()
     self.audio.volume = 0.7
     self.music.volume = 0.5
     self.level.render()
     self.selected = []
     self.sprite = pygame.sprite.Sprite()
     self.sprite.image = self.level.surface
     self.sprite.rect = self.sprite.image.get_rect()
     self.sprite.rect.topleft = (0,0)
     self.keys = [0,0,0,0]
     self.interface = pygame.sprite.Group()
     self.paused = False
     self.mouse = 0
Beispiel #6
0
 def __init__(self,level):
     #for name in ['walk_left',
     #             'walk_right',
     #             'die_back_left',
     #             'die_back_right',
     #             'die_forward_left',
     #             'die_forward_right']:
     #    anim = getattr(self.animation_set,name)
     #    setattr(self.animation_set,name,Animation(anim,True))
     self.audio = Audio()
     self.audio.volume = 0.5
     self.anim = self.animation_set.walk_right
     AnimatedSprite.__init__(self)
     self.level = level
     self.vy = 3
     self.vx = 0
     self.capture()
     self.image.set_colorkey(self.image.get_at((0,0)))
     self.punching = False
     self.kicking = False
     self.dying = False
     self.direction = 'right'
     self.enemies = []
Beispiel #7
0
class Ending(State):

    def __init__(self):
        State.__init__(self)
        self.audio = Audio()
        self.audio.volume = 0.5
        self.music = Music()
        self.music.volume = 0.7
        self.music.stop(500)
        self.delay = 10*40
        self.playing = False
        self.image = data.candy
        self.image.set_alpha(0)

    def start(self):
        State.start(self)
        self.music.play('data/sounds/winner.wav')
        pygame.display.get_surface().fill((0,0,0))
        pygame.display.get_surface().blit(self.intro(),(0,0))
        pygame.display.flip()

    def EVT_KeyDown(self,event):
        self.playing = True
        self.music.stop(500)
        self.audio.play('data/sounds/fanfare.wav')

    def intro(self):
        '''
        Copied almost straight from level.py
        '''

        surf = pygame.Surface((800,600))
        surf.fill((0,0,0))
        surf.set_colorkey((0,0,0))
        try:
            intro = '''You: At... last... after such pain and toil,
I have reclaimed my own.

Boss: All right already, you can have it, it's
stale anyway.'''
            intro = [line.strip() for line in intro.split('\n')]
            fnt = pygame.font.SysFont('Verdana',20,italic=True)
            y = 5
            for line in intro:
                line = fnt.render(line,True,(0,255,0))
                surf.blit(line,(400-(line.get_width()/2),y))
                y += line.get_height()+5
        except:
            pass
        return surf

    def EVT_tick(self,event):
        if not self.playing:
            return
        disp = pygame.display.get_surface()
        if self.image.get_alpha() != 255:
            self.image.set_alpha(self.image.get_alpha()+1)
        disp.fill((0,0,0))
        disp.blit(self.image,(400-self.image.get_width()/2,
                              300-self.image.get_height()/2))
        pygame.display.flip()
        if self.delay:
            self.delay -= 1
        else:
            self.quit()
Beispiel #8
0
class GameState(State):

    def __init__(self,lvl=None):
        State.__init__(self)
        if lvl == None:
            self.level = level.load(Campaign.next())
        else:
            self.level = lvl
        self.bg = pygame.sprite.Group(self.level.s)
        self.selected = None
        self.audio = Audio()
        self.music = Music()
        self.music.volume = 1
        self.audio.volume = 0.5
        self.alarm = 0
        self.music.stop(500)
        self.music.play('data/music/play.ogg',-1)
        self.playing = True

    def start(self):
        State.start(self)
        self.EVT_tick(None)
        self.playing = False
        pygame.display.get_surface().blit(self.level.intro(),(0,0))
        pygame.display.flip()

    def EVT_win(self,event):
        self.quit(Win(self.level.filename))

    def EVT_lose(self,event):
        self.quit(Lose(self.level.filename))

    def EVT_tick(self,event):
        if not self.playing:
            return
        disp = pygame.display.get_surface()
        disp.fill((0,0,0))
        self.level.clear()
        self.level.update()
        self.level.draw()
        self.level.s.rect.left = -self.level.player.rect.left + pygame.display.get_surface().get_width()/2
        self.level.s.rect.top = -self.level.player.rect.top + pygame.display.get_surface().get_height()/2
        self.bg.clear(disp,self.level.background)
        self.bg.draw(disp)
        pygame.display.flip()
        if self.alarm:
            self.alarm -= 1

    def EVT_KeyDown(self,event):
        if not self.playing:
            self.playing = True
        elif event.key == pygame.K_ESCAPE:
            self.quit(PauseMenu(self))

    def EVT_alarm(self,event):
        if not self.alarm:
            self.audio.play('data/sounds/alarm.wav')
            self.alarm = 520

    def quit(self,next=None):
        self.audio.stop(500)
        self.music.stop(500)
        self.music.play('data/music/menu.ogg',-1)
        State.quit(self,next)
Beispiel #9
0
class Game(directicus.engine.State):

    def __init__(self,enemies=1,size=(3000,3000)):
        directicus.engine.State.__init__(self)
        reload(level)
        self.level = level.create(size,enemies=enemies)
        self.audio = Audio()
        self.music = Music()
        self.audio.volume = 0.7
        self.music.volume = 0.5
        self.level.render()
        self.selected = []
        self.sprite = pygame.sprite.Sprite()
        self.sprite.image = self.level.surface
        self.sprite.rect = self.sprite.image.get_rect()
        self.sprite.rect.topleft = (0,0)
        self.keys = [0,0,0,0]
        self.interface = pygame.sprite.Group()
        self.paused = False
        self.mouse = 0

    def start(self):
        directicus.engine.State.start(self)
        self.music.stop(500)
        self.music.play('data/music/battle.mp3',-1)
        self.level.game()
        self.mini = sprites.MiniMap()
        self.mini.level = self.level

    def quit(self,next=None):
        self.music.stop(500)
        self.music.play('data/music/menu.mp3')
        directicus.engine.State.quit(self,next)

    def EVT_tick(self,event):
        self.level.clear()
        self.level.rangers.update(self.level)
        self.level.arrows.update(self.level)

        allies = list()
        for army in self.level.player.armies:
            allies.extend(army.rangers)
        if not allies:
            self.quit(Lose())
            return
        else:
            enemies = list()
            for enemy in self.level.enemies:
                for army in enemy.armies:
                    enemies.extend(army.rangers)
            if not enemies:
                self.quit(Win())
                return

        for sprite in self.interface:
            sprite.kill()

        for sprite in self.selected:
            if not sprite.groups(): # ranger has died
                self.selected.remove(sprite)
                continue
            base = pygame.sprite.Sprite(self.level.sprites,self.interface)
            base.rect = pygame.rect.Rect(sprite)
            base.rect.height = sprite.rect.height/2
            base.rect.bottom = sprite.rect.bottom-1
            base.image = pygame.Surface(base.rect.size)
            base.image.fill((255,0,0))
            base.image.set_colorkey((255,0,0))
            pygame.draw.ellipse(base.image,(0,255,0),base.image.get_rect(),2)

        pygame.display.get_surface().fill((0,0,0))
        self.level.draw()
        pygame.display.get_surface().blit(self.sprite.image,self.sprite.rect)

        if self.mouse:
            msPos = pygame.mouse.get_pos()
            r = pygame.rect.Rect(0,0,0,0)
            r.width = msPos[0]-self.mouse[0]
            r.height = msPos[1]-self.mouse[1]
            r.normalize()
            if msPos[0] > self.mouse[0] and msPos[1] > self.mouse[1]:
                r.topleft = self.mouse
                r.bottomright = msPos
            elif msPos[0] < self.mouse[0] and msPos[1] < self.mouse[1]:
                r.bottomright = self.mouse
                r.topleft = msPos
            elif msPos[0] > self.mouse[0] and msPos[1] < self.mouse[1]:
                r.topright = msPos
                r.bottomleft = self.mouse
            else:
                r.bottomleft = msPos
                r.topright = self.mouse
            pygame.draw.rect(pygame.display.get_surface(),(0,255,0),r,1)

        if self.keys[2]:
            if -self.sprite.rect.x+pygame.display.get_surface().get_width() < self.level.size[0]:
                self.sprite.rect.x -= 30
        if self.keys[3]:
            if -self.sprite.rect.x > 0:
                self.sprite.rect.x += 30
        if self.keys[0]:
            if -self.sprite.rect.y > 0:
                self.sprite.rect.y += 30
        if self.keys[1]:
            if -self.sprite.rect.y+pygame.display.get_surface().get_height() < self.level.size[1]:
                self.sprite.rect.y -= 30

        self.mini.pos = (-self.sprite.rect.left,
                         -self.sprite.rect.top)
        self.mini.tick()
        self.mini.draw()
        pygame.display.flip()

    def EVT_KeyUp(self,event):
        key = pygame.key.name(event.key)
        if key == 'right':
            self.keys[2] = 0
        elif key == 'left':
            self.keys[3] = 0
        elif key == 'up':
            self.keys[0] = 0
        elif key == 'down':
            self.keys[1] = 0

    def EVT_MouseButtonDown(self,event):
        if self.mini.rect.collidepoint(event.pos):
            relPos = self.mini.grow(
                (event.pos[0]-self.mini.rect.centerx,
                 event.pos[1]-self.mini.rect.centery))
            s = pygame.display.get_surface().get_size()
            self.sprite.rect.center = (-relPos[0]+s[0]/2,
                                       -relPos[1]+s[1]/2)
        else:
            pos = (event.pos[0]-self.sprite.rect.left,
                   event.pos[1]-self.sprite.rect.top)
            if event.button == 1:
                self.mouse = event.pos
                self.selected = []
                rangers = list()
                for army in self.level.player.armies:
                    rangers.extend(army.rangers)
                for ranger in rangers:
                    if ranger.rect.collidepoint(pos) and ranger.collidePoint(pos):
                        self.selected.append(ranger)
            elif self.selected:
                target = None
                for enemy in self.level.enemies:
                    for army in enemy.armies:
                        for ranger in army.rangers.sprites():
                            if ranger.rect.collidepoint(pos):
                                target = ranger
                                self.audio.play('data/sounds/sword-draw.wav')
                                break
                if not target:
                    target = (event.pos[0]-self.sprite.rect.left,
                              event.pos[1]-self.sprite.rect.top)
                for r in self.selected:
                    r.target(target)

    def EVT_MouseButtonUp(self,event):
        if event.button == 1 and self.mouse:
            msPos = event.pos
            r = pygame.rect.Rect(0,0,0,0)
            r.width = msPos[0]-self.mouse[0]
            r.height = msPos[1]-self.mouse[1]
            r.normalize()
            if msPos[0] > self.mouse[0] and msPos[1] > self.mouse[1]:
                r.topleft = self.mouse
                r.bottomright = msPos
            elif msPos[0] < self.mouse[0] and msPos[1] < self.mouse[1]:
                r.bottomright = self.mouse
                r.topleft = msPos
            elif msPos[0] > self.mouse[0] and msPos[1] < self.mouse[1]:
                r.topright = msPos
                r.bottomleft = self.mouse
            else:
                r.bottomleft = msPos
                r.topright = self.mouse
            r.left -= self.sprite.rect.left
            r.top -= self.sprite.rect.top

            rangers = list()
            for army in self.level.player.armies:
                rangers.extend(army.rangers)
            for ranger in rangers:
                if ranger.rect.colliderect(r):
                    self.selected.append(ranger)
            self.mouse = None

    def EVT_KeyDown(self,event):
        key = pygame.key.name(event.key)
        if key == 'right':
            self.keys[2] = 1
        elif key == 'left':
            self.keys[3] = 1
        elif key == 'up':
            self.keys[0] = 1
        elif key == 'down':
            self.keys[1] = 1
        elif key == 'escape':
            self.quit()
Beispiel #10
0
class Person(AnimatedSprite,Handler):
    speed = 3
    animation_set = None

    def __init__(self,level):
        #for name in ['walk_left',
        #             'walk_right',
        #             'die_back_left',
        #             'die_back_right',
        #             'die_forward_left',
        #             'die_forward_right']:
        #    anim = getattr(self.animation_set,name)
        #    setattr(self.animation_set,name,Animation(anim,True))
        self.audio = Audio()
        self.audio.volume = 0.5
        self.anim = self.animation_set.walk_right
        AnimatedSprite.__init__(self)
        self.level = level
        self.vy = 3
        self.vx = 0
        self.capture()
        self.image.set_colorkey(self.image.get_at((0,0)))
        self.punching = False
        self.kicking = False
        self.dying = False
        self.direction = 'right'
        self.enemies = []

    def die(self,direction):
        if not self.dying:
            self.audio.play(random.choice(data.punch))
        self.dying = True
        if direction == 1:
            # We're attacked from the right
            if self.direction == 'left':
                self.anim = self.animation_set.die_forward_left
            else:
                self.anim = self.animation_set.die_back_right
        else:
            # We're attacked from the left
            if self.direction == 'left':
                self.anim = self.animation_set.die_back_left
            else:
                self.anim = self.animation_set.die_forward_right

    def kill(self):
        self.release()
        AnimatedSprite.kill(self)

    def update(self,level):
        self.level = level
        self.level.enemies.sprites()
        if self.anim in [self.animation_set.walk_left,
                         self.animation_set.punch_left,
                         self.animation_set.die_forward_left,
                         self.animation_set.die_back_left]:
            self.direction = 'left'
        else:
            self.direction = 'right'
        self.level = level
        self.image = self.anim.seq[0]
        old = self.rect.center
        self.rect.centery += self.vy
        if self.vy:
            self.vy += 0.1

        if pygame.sprite.spritecollideany(self,self.level.floors) or \
           pygame.sprite.spritecollideany(self,self.level.walls):
            self.rect.center = old
            self.vy = 0.1

        old = self.rect.center
        self.rect.centerx += self.vx
        if pygame.sprite.spritecollideany(self,self.level.floors) or \
           pygame.sprite.spritecollideany(self,self.level.walls):
            self.rect.center = old
            if self.flying:
                self.audio.play(random.choice(data.punch))

        if self.punching or self.kicking:
            if self.anim.index == len(self.anim.seq)-1:
                self.recover()
            else:
                AnimatedSprite.update(self)
        elif self.dying:
            if self.anim.index < len(self.anim.seq)-1:
                AnimatedSprite.update(self)
                self.rect.centery += 0.5
                if self.anim in [self.animation_set.die_back_left,
                                 self.animation_set.die_back_right]:
                    if self.direction == 'right':
                        self.rect.centerx -= 2
                    else:
                        self.rect.centerx += 2
                else:
                    if self.direction == 'right':
                        self.rect.centerx += 2
                    else:
                        self.rect.centerx -= 2
        elif self.vx > 0:
            i = self.anim.index
            self.anim = self.animation_set.walk_right
            self.anim.index = i
            AnimatedSprite.update(self)
        elif self.vx < 0:
            i = self.anim.index
            self.anim = self.animation_set.walk_left
            self.anim.index = i
            AnimatedSprite.update(self)
        self.image.set_colorkey(self.image.get_at((0,0)))

    def kick(self):
        self.kicking = True
        if self.anim == self.animation_set.walk_left:
            self.anim = Animation(self.animation_set.kick_left,False)
        elif self.anim == self.animation_set.walk_right:
            self.anim = Animation(self.animation_set.kick_right,False)

    def punch(self):
        self.punching = True
        if self.anim == self.animation_set.walk_left:
            self.anim = Animation(self.animation_set.punch_left,False)
        elif self.anim == self.animation_set.walk_right:
            self.anim = Animation(self.animation_set.punch_right,False)

    def recover(self):
        self.kicking = False
        self.punching = False
        if self.anim.seq in [self.animation_set.kick_left,self.animation_set.punch_left]:
            self.anim = self.animation_set.walk_left
        elif self.anim.seq in [self.animation_set.kick_right,self.animation_set.punch_right]:
            self.anim = self.animation_set.walk_right

    def _dist(self,a,b=None):
        if b == None:
            b = self.rect.center
        if type(a) == type(1):
            return max(a,b)-min(a,b)
        else:
            return (max(a[0],b[0])-min(a[0],b[0]))+(max(a[1],b[1])-min(a[1],b[1]))