#!/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.220
216.73.216.220
216.73.216.220
 
March 22, 2020

The chicken nugget business starter kit is now available online! Send me any amount of money through Venmo or PayPal, and I will mail you a package which will enable you to start a chicken nugget business of your own, play a video game any time you want, introduce a new character into your Animal Crossing village, and start collecting the chicken nugget trading cards.

The kit includes:

  • jellybean
  • instruction manual
  • limited edition trading card

By following the instructions you'll learn how to cook your own chicken or tofu nugget and be well on your way to financial success. I'm also throwing in one randomly selected card from the limited edition trading card set. Collect them, trade them, and if you get all eighteen and show me your set, I will give you an exclusive video game product.

All orders are processed within a day, so you can have your kit on your doorstep as quickly as possible. Don't sleep on this offer! Click the PayPal button or send a Venmo payment of any amount to @ohsqueezy, and in a matter of days you'll be counting money and playing video games.

PayPal me