Video Games

#!/usr/bin/env python

from random import randint, random, choice, randrange, uniform
from math import sin, tan, radians, copysign, degrees, cos, asin
from os import mkdir, remove
from os.path import join, exists
from sys import argv
from glob import glob
from collections import deque
from itertools import chain

from pygame.locals import *
from pygame import Surface, Color, PixelArray
from pygame.font import Font
from pygame.mixer import Sound, Channel, get_num_channels
from pygame.draw import polygon, line, circle, aaline
from pygame.gfxdraw import aapolygon, aacircle, filled_circle
from pygame.image import load, save
from pygame.transform import rotate, smoothscale, rotozoom, scale, flip
from pygame.event import clear
from pygame.display import set_mode

from lib.pgfw.pgfw.Game import Game
from lib.pgfw.pgfw.GameChild import GameChild
from lib.pgfw.pgfw.Sprite import Sprite
from lib.pgfw.pgfw.Animation import Animation
from lib.pgfw.pgfw.Vector import Vector
from lib.pgfw.pgfw.extension import (get_distance, get_delta, place_in_rect,
                                     get_step, collide_line_with_rect)

class SoundEffect(GameChild, Sound):

    def __init__(self, parent, path, volume=1.0):
        GameChild.__init__(self, parent)
        Sound.__init__(self, path)
        self.display_surface = self.get_display_surface()
        self.set_volume(volume)

    def play(self, loops=0, maxtime=0, fade_ms=0, position=None, x=None):
        channel = Sound.play(self, loops, maxtime, fade_ms)
        if x is not None:
            position = float(x) / self.display_surface.get_width()
	if position is not None and channel is not None:
            channel.set_volume(*self.get_panning(position))
        return channel

    def get_panning(self, position):
        return 1 - max(0, ((position - .5) * 2)), \
               1 + min(0, ((position - .5) * 2))

# ===--------------------===
# )))) FISSION / FUSION ((((
# ===--------------------===

class iQue(Game, Sprite):

    GENERATE_FLAG = "-generate"
    FRAME_DIR = "frame/"

    def __init__(self):
        Game.__init__(self)
        Sprite.__init__(self, self, 1000)
        if self.check_command_line(self.GENERATE_FLAG):
            pixels = PixelArray(smoothscale(\
                load(self.get_resource("Untitled.png")).convert(), (500, 400)))
            if not exists(self.FRAME_DIR):
                mkdir(self.FRAME_DIR)
            for path in glob("%s/*.png" % self.FRAME_DIR):
                remove(path)
            for ii in xrange(int(argv[argv.index("-" + \
                                                 self.GENERATE_FLAG) + 1])):
                color = Color(0, 0, 0)
                for x in xrange(len(pixels)):
                    for y in xrange(len(pixels[0])):
                        h, s, l, a = Color(*Surface((0, 0)).\
                                           unmap_rgb(pixels[x][y])).hsla
                        color.hsla = int((h + (ii % 240)) % 360), int(s), 50,\
                                     100
                        pixels[x][y] = color
                        pixels[x - 138][y - (ii % 1024)] = pixels[\
                            x - (ii % 128)][y - (ii % 2)]
                print ii
                save(pixels.make_surface(), "%s/%04i.png" % (self.FRAME_DIR,
                                                             ii))
        for path in sorted(glob("%s/*.png" % self.FRAME_DIR)):
            self.add_frame(load(path).convert())
        self.location.topleft = -10, -10
        self.goal = Goal(self)
        self.calorie = Calorie(self)
        self.carrot = Carrot(self)
        self.subscribe(self.respond)
        self.reset()
        clear()

    def respond(self, event):
        if self.delegate.compare(event, "reset-game"):
            self.reset()

    def reset(self):
        self.calorie.reset()

    def update(self):
        Sprite.update(self)
        self.goal.update()
        self.carrot.update()
        self.calorie.update()


class Carrot(Sprite):

    SIZE = 60, 35
    MARGIN = 30

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.add_frame(smoothscale(load("Emparchment.png").convert_alpha(),
                                   self.SIZE))
        self.spawn()

    def spawn(self):
        place_in_rect(self.get_display_surface().get_rect(), self.location,
                      True, self.parent.goal.skull.location.inflate(\
                          [self.MARGIN] * 2))
        self.parent.calorie.find_carrot()


class Goal(GameChild):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.skull = Skull(self)
        self.shield = Shield(self)

    def update(self):
        self.skull.update()


class Skull(Sprite):

    MARGIN = 10

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.add_frame(load("Pencil.png").convert_alpha())
        self.location.bottomright = self.get_display_surface().get_rect().\
                                    move([-self.MARGIN] * 2).bottomright


class Shield(GameChild):

    def __init__(self, parent):
        GameChild.__init__(self, parent)


class Calorie(Sprite):

    SIZE = 71, 88
    SPAWN_MARGIN = 30
    FETCH_DELAY = 1000
    SPEED = 7
    CARROT_BOX_SHRINK = -20, -10
    PROJECTION_LENGTH = 2000
    SPIN_RANGE = -1.2, 1.2
    NORTH, EAST, SOUTH, WEST = range(4)

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.step = (0, 0)
        self.shot_speed_nodeset = self.get_game().interpolator.\
                                  get_nodeset("shot-speed")
        self.add_frames()
        self.shadow = load("Gallery.png").convert_alpha()
        self.register(self.fetch_carrot, self.barf)

    def add_frames(self):
        morph_paths = glob(join(self.get_resource("morph"), "*.png"))
        base = load("Calorie.png").convert_alpha()
        self.add_frame(base)
        self.add_frameset(0, name="facing-right")
        self.add_frame(flip(base, True, False))
        self.add_frameset(1, name="facing-left")
        self.set_frameset(randint(1, 2))
        for path in sorted():
            self.add_frame(load(path).convert_alpha())
            self.add_frameset(xrange(2, len(self.frames)), name="shooting")

    def reset(self):
        self.shot_count = 0
        self.clear_aim()
        place_in_rect(self.get_display_surface().get_rect(), self.location,
                      True, self.parent.goal.skull.location.inflate(\
                          [self.SPAWN_MARGIN] * 2))

    def clear_aim(self):
        self.collisions = []
        self.steps = []

    def find_carrot(self):
        self.play(self.fetch_carrot, delay=self.FETCH_DELAY, play_once=True)

    def fetch_carrot(self):
        step = self.step = get_step(self.location.midbottom,
                                    self.parent.carrot.location.center,
                                    self.SPEED)
        if step[0] < 0:
            self.set_frameset("facing-left")
        else:
            self.set_frameset("facing-right")

    def aim(self):
        angles = deque(xrange(360))
        angles.rotate(randrange(0, len(angles)))
        magnitude = self.shot_speed_nodeset.get_y(self.shot_count)
        bounds = self.get_display_surface().get_rect()
        spin = uniform(*self.SPIN_RANGE)
        best_wc, best_c, best_s = None, [], []
        for angle in angles:
            collides, wall_count, collisions, steps = self.project(angle, spin,
                                                                   magnitude,
                                                                   bounds)
            if collides and wall_count >= best_wc and \
                   len(steps) >= len(best_s) and len(collisions) <= \
                   len(best_c) + 1:
                best_wc = wall_count
                best_c = collisions
                best_s = steps
        self.steps = best_s
        self.collisions = best_c
        self.shot_count += 1
        self.set_frameset("shooting")
        self.play(self.barf, delay=3000, play_once=True)

    def project(self, angle, spin, magnitude, bounds):
        traveled = 0
        projection = Vector(*self.get_game().carrot.location.center)
        collides = False
        steps = []
        collisions = []
        walls = [False] * 4
        while traveled < self.PROJECTION_LENGTH:
            delta = get_delta(angle, magnitude)
            projection += delta
            angle += spin
            if steps and collide_line_with_rect(self.get_game().goal.skull.\
                                                location, steps[-1],
                                                projection):
                collides = True
                break
            if projection[0] < bounds.left or projection[0] > bounds.right or \
                   projection[1] < bounds.top or projection[1] > bounds.bottom:
                if projection[0] < bounds.left:
                    projection[0] += 2 * (bounds.left - projection[0])
                    wall_angle = 0
                    walls[self.WEST] = True
                elif projection[0] > bounds.right:
                    projection[0] += 2 * (bounds.right - projection[0])
                    wall_angle = 0
                    walls[self.EAST] = True
                if projection[1] < bounds.top:
                    projection[1] += 2 * (bounds.top - projection[1])
                    wall_angle = 180
                    walls[self.NORTH] = True
                elif projection[1] > bounds.bottom:
                    projection[1] += 2 * (bounds.bottom - projection[1])
                    wall_angle = 180
                    walls[self.SOUTH] = True
                collisions.append(map(int, projection))
                angle = wall_angle - angle
            steps.append(tuple(projection))
            traveled += magnitude
        wall_count = 0
        for wall in walls:
            if wall:
                wall_count += 1
        return collides, wall_count, collisions, steps

    def barf(self):
        self.get_game().carrot.spawn()
        self.clear_aim()

    def update(self):
        self.get_game().time_filter.open()
        ds = self.get_display_surface()
        for ii in xrange(1, len(self.steps)):
            line(ds, (0, 0, 0), self.steps[ii - 1], self.steps[ii], 5)
            line(ds, (128, 128, 128), self.steps[ii - 1], self.steps[ii], 3)
            line(ds, (0, 255, 255), self.steps[ii - 1], self.steps[ii])
        for ii, collision in enumerate(self.collisions):
            font = Font(None, 20)
            surface = font.render(str(ii), False, (0, 0, 255))
            circle(ds, (255, 255, 255), collision, 20)
            ds.blit(surface, collision)
        if self.step != (0, 0):
            if self.parent.carrot.location.inflate(self.CARROT_BOX_SHRINK).\
                   collidepoint(self.location.midbottom - ):
                self.step = (0, 0)
                self.get_game().time_filter.close()
                self.aim()
            else:
                self.move(*self.step)
        Sprite.update(self)


if __name__ == "__main__":
    iQue().run()
216.73.216.142
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.
↠ RSS Feed ↞