Esempio n. 1
0
        def update(_self, self, dt, t, *args, **kwargs):
            super(StateMachine, self).update(dt, t)
            _self.checkScreenClipping(self)
            if self.pos.x > 10 and self.pos.x < SCREENWIDTH - 10:
                if have_luck(BIRDPOOPCHANCE) and (
                        self.pos.x < FENCELEFT - 40
                        or self.pos.x > FENCERIGHT + 40):
                    self.change_state(self._state_poop)

                elif have_luck(BIRDTURNCHANCE):
                    self.vel.x *= -1
                    if sign(self.vel.x) > 0:
                        self.spr = self.spr_fly_r
                    else:
                        self.spr = self.spr_fly_l
                    self.spr.play()
                if self.vel.y:
                    if have_luck(BIRDSTOPCHANCE) and self.pos.y < 350:
                        self.accel.y = 0
                        self.vel.y = 0
                    if self.pos.y < 0:
                        self.pos.y = 10
                        self.accel.y = 0
                        self.vel.y = 0
            self.spr.update(dt, t)
            self.rect.center = self.pos
Esempio n. 2
0
 def update(_self, self, dt, t, *args, **kwargs):
     if have_luck(0.5):
         if have_luck(0.5):
             self.pos.values = Vec2D(-BIRDSPAWNDIST,
                                     random.randint(20, 300))
             self.vel.x = BIRDSPEED
         else:
             self.pos.values = Vec2D(SCREENWIDTH + BIRDSPAWNDIST,
                                     random.randint(20, 300))
             self.vel.x = -BIRDSPEED
         self.change_state(self._state_fly)
Esempio n. 3
0
 def __init__(self):
     super(LadyBug, self).__init__(Vec2D(0, 0))
     
     self._state_thrown = LadyBug.StateThrown2()
     
     self.spr_walk = animation.TimedAnimation(self.pos, data.load_image('ladybRwalk_anim.png'), 2, 2, 'loop')
     self.spr_eat = animation.TimedAnimation(self.pos, data.load_image('ladybugReat_anim.png'), 2, 2, 'loop')
     self.spr_idle = animation.TimedAnimation(self.pos, data.load_image('ladybugblink_anim.png'), 2, 2)
     self.spr_fly = animation.TimedAnimation(self.pos, data.load_image('ladybRfly_anim.png'), 2, 10, 'loop')
     self.spr_fly.play()
     if have_luck(0.5):
         self.pos.x = -5
         self.vel.x = 0.08
     else:
         self.pos.x = 800 + 5
         self.vel.x = -0.1
     self.vel.y = 0.008
     self.pos.y = randint(150, 350)
     self._count += 1
     
     self.spr = self.spr_fly
     
     self.rect = self.spr.rect
     self.size = self.rect.h / 2
     self.eat_next_time = 0
     self.spr.face = self.facing
     self._walk_target = 0
     self.lawnsegments = []
     self.steam = randint(400, 800)
     self.change_state(self._state_fly)
Esempio n. 4
0
    def __init__(self):
        super(LadyBug, self).__init__(Vec2D(0, 0))

        self._state_thrown = LadyBug.StateThrown2()

        self.spr_walk = animation.TimedAnimation(
            self.pos, data.load_image('ladybRwalk_anim.png'), 2, 2, 'loop')
        self.spr_eat = animation.TimedAnimation(
            self.pos, data.load_image('ladybugReat_anim.png'), 2, 2, 'loop')
        self.spr_idle = animation.TimedAnimation(
            self.pos, data.load_image('ladybugblink_anim.png'), 2, 2)
        self.spr_fly = animation.TimedAnimation(
            self.pos, data.load_image('ladybRfly_anim.png'), 2, 10, 'loop')
        self.spr_fly.play()
        if have_luck(0.5):
            self.pos.x = -5
            self.vel.x = 0.08
        else:
            self.pos.x = 800 + 5
            self.vel.x = -0.1
        self.vel.y = 0.008
        self.pos.y = randint(150, 350)
        self._count += 1

        self.spr = self.spr_fly

        self.rect = self.spr.rect
        self.size = self.rect.h / 2
        self.eat_next_time = 0
        self.spr.face = self.facing
        self._walk_target = 0
        self.lawnsegments = []
        self.steam = randint(400, 800)
        self.change_state(self._state_fly)
Esempio n. 5
0
 def update(_self, self, dt, t, *arg, **kwargs):
     super(StateMachine, self).update(dt, t)
     
     if self.pos.y > MOLEDESCENDDEPTH and have_luck(MOLEDESCENDDEPTH):
         self.change_state(self._state_walk_h)
     
     self.spr.update(dt, t)
     self.rect.center = self.pos
Esempio n. 6
0
        def update(_self, self, dt, t, *arg, **kwargs):
            super(StateMachine, self).update(dt, t)

            if self.pos.y > MOLEDESCENDDEPTH and have_luck(MOLEDESCENDDEPTH):
                self.change_state(self._state_walk_h)

            self.spr.update(dt, t)
            self.rect.center = self.pos
Esempio n. 7
0
        def update(_self, self, dt, t, *args, **kwargs):
            super(StateMachine, self).update(dt, t)

            _self.checkScreenClipping(self)
            if self.pos.x > 10 and self.pos.x < SCREENWIDTH - 10:
                if have_luck(MOLECLIMBCHANCE):
                    self.change_state(self._state_walk_u)
                    return
                elif have_luck(MOLEDIRCHGCHANCE):
                    self.vel.x *= -1.0
                    if sign(self.vel.x) > 0:
                        self.spr = self.spr_walk_r
                    else:
                        self.spr = self.spr_walk_l
                    self.spr.play()

            self.spr.update(dt, t)
            self.rect.center = self.pos
Esempio n. 8
0
 def update(_self, self, dt, t, *args, **kwargs):
     super(StateMachine, self).update(dt, t)
     
     _self.checkScreenClipping(self)
     if self.pos.x > 10 and self.pos.x < SCREENWIDTH - 10:
         if have_luck(MOLECLIMBCHANCE):
             self.change_state(self._state_walk_u)
             return
         elif have_luck(MOLEDIRCHGCHANCE):
             self.vel.x *= -1.0
             if sign(self.vel.x)>0:
                 self.spr = self.spr_walk_r
             else:
                 self.spr = self.spr_walk_l
             self.spr.play()
     
 
     self.spr.update(dt, t)
     self.rect.center = self.pos
Esempio n. 9
0
 def update(self_, self, dt, t):
     if self.pos.y > GROUNDLIMIT - self.rect.h / 2:
         self.pos.y = GROUNDLIMIT - self.rect.h / 2
         self.vel.y = 0
     super(LadyBug.StateIdle, self_).update(self, dt, t)
     if have_luck(0.05):
         self.spr.play()
     x = randint(0, 100)
     if x < 30:
         self._state_fly.enter_takeoff(self)
         self.change_state(self._state_fly)
     elif x < 50:
         self.change_state(self._state_eat)
     elif x < 70:
         self.change_state(self._state_walk)
Esempio n. 10
0
 def update(self_, self, dt, t):
     if self.pos.y > GROUNDLIMIT - self.rect.h / 2:
         self.pos.y = GROUNDLIMIT - self.rect.h / 2
         self.vel.y = 0
     super(LadyBug.StateIdle, self_).update(self, dt, t)
     if have_luck(0.05):
         self.spr.play()
     x = randint(0, 100)
     if x < 30:
         self._state_fly.enter_takeoff(self)
         self.change_state(self._state_fly)
     elif x < 50:
         self.change_state(self._state_eat)
     elif x < 70:
         self.change_state(self._state_walk)
Esempio n. 11
0
 def update(_self, self, dt, t, *args, **kwargs):
     super(StateMachine, self).update(dt, t)
     ground_limit = GROUNDLIMIT - (self.size / 2.0)
     if self.pos.y >= ground_limit:
         self.pos.y = ground_limit
         self.accel.y = 0
         self.vel.y = 0
         if have_luck(BIRDREVIVECHANCE):
             self.change_state(self._state_revive)
         else:
             # changed from _state_still.
             # makes birds unthrowable again
             self.change_state(self._state_idle)
     self.spr.update(dt, t)
     self.rect.center = self.pos
Esempio n. 12
0
 def update(self_, self, dt, t):
     super(LadyBug.StateEat, self_).update(self, dt, t)
     self.rect.center = self.pos
     if have_luck(0.01):
         self.change_state(self._state_idle)
     if t > self.eat_next_time:
         self.eat_next_time = t + randint(100, 1000)
         if self.lawnsegments:
             seg = choice(self.lawnsegments)
             seg.hurt(6)
             soundsystem.eat()
             if seg.pos.x - self.pos.x < 0:
                 self.facing = -1
             else:
                 self.facing = 1
         self.spr.face = self.facing
Esempio n. 13
0
 def update(self_, self, dt, t):
     super(LadyBug.StateEat, self_).update(self, dt, t)
     self.rect.center = self.pos
     if have_luck(0.01):
         self.change_state(self._state_idle)
     if t > self.eat_next_time:
         self.eat_next_time = t + randint(100, 1000)
         if self.lawnsegments:
             seg = choice(self.lawnsegments)
             seg.hurt(6)
             soundsystem.eat()
             if seg.pos.x - self.pos.x < 0:
                 self.facing = -1
             else:
                 self.facing = 1
         self.spr.face = self.facing
Esempio n. 14
0
 def update(self_, self, dt, t):
     if self.facing == 1:
         if self.pos.x > FENCELEFT - self.rect.w and self.pos.x <= FENCEMIDDLE:
             self.vel.x = -1 * abs(self.vel.x)
     else:
         if self.pos.x < FENCERIGHT + self.rect.w and self.pos.x >= FENCEMIDDLE:
             self.vel.x = -1 * abs(self.vel.x)
     self.pos += dt * self.vel
     super(LadyBug.StateWalk, self_).update(self, dt, t)
     self.spr.face = self.facing
     self.rect.center = self.pos
     if have_luck(0.01):
         self.change_state(self._state_idle)
     # stop walking if reaching target location
     if self.pos.x > SCREENWIDTH + 10:
         states.TheStateManager.cur_state.remove_entity(self)
         self._count -= 1
     if self.pos.x < 0 - 10:
         states.TheStateManager.cur_state.remove_entity(self)
         self._count -= 1
Esempio n. 15
0
 def update(self_, self, dt, t):
     if self.facing == 1:
         if self.pos.x > FENCELEFT - self.rect.w and self.pos.x <= FENCEMIDDLE:
             self.vel.x = -1 * abs(self.vel.x)
     else:
         if self.pos.x < FENCERIGHT + self.rect.w and self.pos.x >= FENCEMIDDLE:
             self.vel.x = -1 * abs(self.vel.x)
     self.pos += dt * self.vel
     super(LadyBug.StateWalk, self_).update(self, dt, t)
     self.spr.face = self.facing
     self.rect.center = self.pos
     if have_luck(0.01):
         self.change_state(self._state_idle)
     # stop walking if reaching target location
     if self.pos.x > SCREENWIDTH + 10:
         states.TheStateManager.cur_state.remove_entity(self)
         self._count -= 1
     if self.pos.x < 0 - 10:
         states.TheStateManager.cur_state.remove_entity(self)
         self._count -= 1
Esempio n. 16
0
 def update(_self, self, dt, t, *arg, **kwargs):
     super(StateMachine, self).update(dt, t)
     self.spr.update(dt, t)
     self.rect.center = self.pos
     if have_luck(MOLEDESCENDCHANCE) or self.touched:
         self.change_state(self._state_walk_d)
Esempio n. 17
0
 def update(_self, self, dt, t, *arg, **kwargs):
     super(StateMachine, self).update(dt, t)
     self.spr.update(dt, t)
     self.rect.center = self.pos
     if have_luck(MOLEDESCENDCHANCE) or self.touched:
         self.change_state(self._state_walk_d)