from lib.pgfw.pgfw.Sprite import Sprite

class StaticEnvironment(Sprite):

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.load_from_path(self.get_resource("home",
                                              "static-environment-path"),
                            True)
from pygame import mixer
from pygame.image import load

from lib.pgfw.pgfw.GameChild import GameChild
from food_spring.home.View import View
from food_spring.home.StaticEnvironment import StaticEnvironment
from food_spring.home.Foods import Foods
from food_spring.home.collection.Collection import Collection

class Home(GameChild):

    any_press_ignored = ["left", "right"]

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.display_surface = self.get_display_surface()
        self.input = self.get_input()
        self.compare = self.get_delegate().compare
        self.audio = self.get_audio()
        self.audio_path = self.get_resource("home", "audio")
        self.static_environment = StaticEnvironment(self)
        self.view = View(self)
        self.foods = Foods(self)
        self.collection = Collection(self)
        self.reset()
        self.deactivate()

    def deactivate(self):
        self.active = False
        self.input.unregister_any_press_ignore(*self.any_press_ignored)
        self.audio.stop_current_channel()
        mixer.quit()
        mixer.init(self.stored_frequency)

    def reset(self):
        self.foods.reset()
        self.store_frequency()

    def store_frequency(self):
        self.stored_frequency = mixer.get_init()[0]

    def activate(self):
        self.active = True
        self.input.register_any_press_ignore(*self.any_press_ignored)
        self.foods.activate()
        self.start_audio()

    def start_audio(self):
        self.store_frequency()
        mixer.quit()
        mixer.init(int(self.parent.timer.get_ratio_remaining() * \
                       self.stored_frequency))
        self.audio.play_bgm(self.audio_path)

    def update(self):
        if self.active:
            self.view.update()
            self.static_environment.update()
            self.foods.update()
from pygame import Rect

from lib.pgfw.pgfw.GameChild import GameChild

class Foods(GameChild, list):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.active_index = 0
        self.display_surface = self.get_display_surface()
        self.compare = self.get_delegate().compare
        self.bounds = self.get_display_surface().get_rect()
        self.load_configuration()
        self.set_foods()
        self.set_tv_rect()
        self.reset()
        self.subscribe(self.respond)

    def load_configuration(self):
        config = self.get_configuration("home")
        self.inactive_x = config["food-inactive-x"]
        self.inactive_y = config["food-inactive-y"]
        self.active_y = config["food-active-y"]
        self.margin = config["food-margin"]
        self.step = config["food-step"]
        self.tv_edge = config["tv-edge"]

    def set_foods(self):
        levels = self.get_game().levels
        for ii in range(len(levels)):
            self.append(levels[ii].food)

    def set_tv_rect(self):
        self.tv_rect = Rect(0, 0, self.tv_edge,
                            self.display_surface.get_height())

    def swap_in(self, index):
        self.store(self.get_active())
        self.active_index = index
        self.step_forward()

    def step_forward(self):
        self.get_active().location.bottomleft = self.get_x(self.active_index), \
                                                self.active_y

    def get_x(self, index):
        x = self.inactive_x
        for ii in range(index):
            x += self[ii].location.w + self.margin
        return x

    def respond(self, event):
        if self.parent.active:
            if self.compare(event, "left"):
                self.moving[0] = True
            elif self.compare(event, "left", True):
                self.moving[0] = False
            elif self.compare(event, "right"):
                self.moving[1] = True
            elif self.compare(event, "right", True):
                self.moving[1] = False
            elif self.compare(event, "any"):
                self.do()

    def do(self):
        rect = self.get_active().location
        if not self.collide_other():
            if rect.colliderect(self.tv_rect):
                self.stop_moving()
                self.store_location()
                self.parent.deactivate()
                self.get_game().levels.activate(self.active_index)
            elif rect.colliderect(self.parent.collection):
                pass

    def stop_moving(self):
        self.moving = [False, False]

    def collide_other(self):
        active = self.get_active()
        rect = active.location
        clip = None
        closest = None
        for food in self:
            if active != food and rect.colliderect(food):
                if not clip or rect.clip(food).w > clip.w:
                    clip = rect.clip(food)
                    closest = food
        if closest:
            self.swap_in(self.index(closest))
            return True

    def store_location(self):
        self.stored_location = self.get_active().location.topleft

    def reset(self):
        for food in self:
            self.store(food)
        self.swap_in(0)
        self.stop_moving()
        self.store_location()

    def activate(self):
        for food in self:
            if self.index(food) != self.active_index:
                self.store(food)
        self.get_active().location.topleft = self.stored_location

    def store(self, food):
        index = self.index(food)
        self[index].location.bottomleft = self.get_x(index), self.inactive_y

    def update(self):
        active = self.get_active()
        if True in self.moving:
            if self.moving[0]:
                active.move(-self.step)
            if self.moving[1]:
                active.move(self.step)
            self.wrap()
        for food in self:
            if self.index(food) != self.active_index:
                food.update()
        active.update()

    def get_active(self):
        return self[self.active_index]

    def wrap(self):
        rect = self.get_active().location
        bounds = self.bounds
        if rect.left > bounds.right:
            rect.right = bounds.left
        elif rect.right < bounds.left:
            rect.left = bounds.right
44.210.151.5
44.210.151.5
44.210.151.5
 
July 19, 2017


f1. BOSS

Games are corrupt dissolutions of nature modeled on prison, ordering a census from the shadows of a vile casino, splintered into shattered glass, pushing symbols, rusted, stale, charred, ultraviolet harbingers of consumption and violence, badges without merit that host a disease of destruction and decay.

You are trapped. You are so trapped your only recourse of action is to imagine an escape route and deny your existence so fully that your dream world becomes the only reality you know. You are fleeing deeper and deeper into a chasm of self-delusion.

While you're dragging your listless, distending corpus from one cell to another, amassing rewards, upgrades, bonuses, achievements, prizes, add-ons and status boosts in rapid succession, stop to think about what's inside the boxes because each one contains a vacuous, soul-sucking nightmare.

Playing can be an awful experience that spirals one into a void of harm and chaos, one so bad it creates a cycle between the greater and lesser systems, each breaking the other's rules. One may succeed by acting in a way that ruins the world.