def main():
screen = psp2d.Screen()
font = psp2d.Font('font.png')
bgimg = psp2d.Image('background.png')
screen.blit(bgimg)
font.drawText(screen, 0, 0, 'Connecting...')
screen.swap()
def cb(s):
screen.blit(bgimg)
if s >= 0:
font.drawText(screen, 0, 0, 'State: %d/4' % s)
else:
font.drawText(screen, 0, 0, 'Connected. IP: %s' % pspnet.getIP())
screen.swap()
pspnet.connectToAPCTL(1, cb)
srv = MSServer(('', 80), MSHandler)
thr = threading.Thread(target=srv.serve_forever)
thr.setDaemon(True)
thr.start()
while True:
pad = psp2d.Controller()
if pad.circle:
break
pspnet.disconnectAPCTL()
def main():
scr = psp2d.Screen()
fnt = psp2d.Font('font_small.png')
dy = fnt.textHeight('') + 5
while True:
pad = psp2d.Controller()
img = psp2d.Image(480, 272)
img.clear(psp2d.Color(0, 0, 0))
fnt.drawText(img, 0, 0, 'Analog X: %d' % pad.analogX)
fnt.drawText(img, 0, dy, 'Analog Y: %d' % pad.analogY)
fnt.drawText(img, 0, 2 * dy, 'Square: %d' % int(pad.square))
fnt.drawText(img, 0, 3 * dy, 'Circle: %d' % int(pad.circle))
fnt.drawText(img, 0, 4 * dy, 'Cross: %d' % int(pad.cross))
fnt.drawText(img, 0, 5 * dy, 'Triangle: %d' % int(pad.triangle))
fnt.drawText(img, 0, 6 * dy, 'Left: %d' % int(pad.left))
fnt.drawText(img, 0, 7 * dy, 'Right: %d' % int(pad.right))
fnt.drawText(img, 0, 8 * dy, 'Up: %d' % int(pad.up))
fnt.drawText(img, 0, 9 * dy, 'Down: %d' % int(pad.down))
fnt.drawText(img, 0, 10 * dy, 'Left trigger: %d' % int(pad.l))
fnt.drawText(img, 0, 11 * dy, 'Right trigger: %d' % int(pad.r))
scr.blit(img)
scr.swap()
def main():
screen = psp2d.Screen()
font = psp2d.Font('font.png')
bgimg = psp2d.Image('background.png')
screen.blit(bgimg)
font.drawText(screen, 0, 0, 'Connecting...')
screen.swap()
def cb(s):
screen.blit(bgimg)
if s >= 0:
font.drawText(screen, 0, 0, 'State: %d/4' % s)
else:
font.drawText(screen, 0, 0, 'Connected. IP: %s' % pspnet.getIP())
screen.swap()
pspnet.connectToAPCTL(1, cb)
a = Acceptor()
a.create_socket(socket.AF_INET, socket.SOCK_STREAM)
a.bind(('', 23))
a.listen(5)
thr = threading.Thread(target=runloop)
thr.setDaemon(True)
thr.start()
while True:
pad = psp2d.Controller()
if pad.circle:
break
def cb(s):
screen = psp2d.Screen()
font = psp2d.Font('font.png')
if s >= 0:
font.drawText(screen, 0, 0, 'State: %d/4' % s)
else:
font.drawText(screen, 0, 20, 'Connected. IP: %s' % pspnet.getIP())
screen.swap()
def __init__(self, clearer=None, label='', bitmap=None, font=None):
Widget.__init__(self, clearer)
self.label = label
self.bitmap = bitmap
if font is None:
self.font = psp2d.Font('font_small.png')
else:
self.font = font
def __init__(self, clearer=None, text='', font=None, margin=3):
Widget.__init__(self, clearer)
self.margin = margin
if font is None:
self.font = psp2d.Font('font_small.png')
else:
self.font = font
self.text = text
def sluchacz(sock): # thread
font = psp2d.Font('font.png')
parser = PSPParser()
global dzialaj
while dzialaj:
waga_wiadomosci = sock.otrzymaj_dane(ile=6)
# zmien nazwe usun_uzupelnienie, by rzutow. int zawrzec w metodzie
waga_wiadomosci = int(parser.usun_uzupelnienie(waga_wiadomosci))
bufor = sock.otrzymaj_dane(ile=waga_wiadomosci)
with open('prtscr.jpeg', 'wb') as plik:
plik.write(bufor)
odrysuj_na_ekranie(obrazek='prtscr.jpeg')
def main(msg='Hello, world!'):
screen = psp2d.Screen()
bgimg = psp2d.Image('background.png')
font = psp2d.Font('font.png')
## pspsnd.setMusicVolume(128)
## music = pspsnd.Music('stranglehold.xm', loop = True)
## music.start()
widths = []
totalw = 0
for c in msg:
widths.append(font.textWidth(c))
totalw += font.textWidth(c)
y = (272 - font.textHeight(msg)) / 2
x = (480 - totalw) / 2
angle = 0.0
menu = Menu(10, 10)
amplitude = FloatMenuItem(20, 0.5, 'Amplitude')
step = FloatMenuItem(0.2, 0.02, 'Step')
slope = FloatMenuItem(0.2, 0.02, 'Slope')
menu.addItem(amplitude)
menu.addItem(step)
menu.addItem(slope)
menu.realize(font)
while True:
screen.blit(bgimg)
menu.draw(font, screen)
dx = 0
for idx, c in enumerate(msg):
font.drawText(
screen, x + dx,
y + amplitude.value * math.sin(angle + slope.value * idx), c)
dx += widths[idx]
screen.swap()
angle += step.value
pad = psp2d.Controller()
if pad.circle:
break
menu.update(pad)
def main():
scr = psp2d.Screen()
img = psp2d.Image('background.png')
scr.blit(img)
font = psp2d.Font('font.png')
msg = 'Hello, world!'
font.drawText(scr, (480 - font.textWidth(msg)) / 2, 20, msg)
scr.swap()
while True:
pad = psp2d.Controller()
if pad.circle:
break
def __init__(self, clearer=None, height=10, font=None):
Widget.__init__(self, clearer)
self.height = height
self.choices = []
self.up = psp2d.Image('up.png')
self.down = psp2d.Image('down.png')
self.selection = None
self.first = None
if font is None:
self.font = psp2d.Font('font_small.png')
else:
self.font = font
self.minW = 16
self.minH = 32 + self.font.textHeight(' ') * height
def main(msgs):
screen = psp2d.Screen()
bgimg = psp2d.Image('background.png')
font = psp2d.Font('font.png')
widths = []
totalw = []
for msg in msgs:
widths.append([])
totalw.append(0)
for c in msg:
widths[-1].append(font.textWidth(c))
totalw[-1] += font.textWidth(c)
y = (272 - font.textHeight('')) / 2
xs = []
for tw in totalw:
xs.append((480 - tw) / 2)
angle = 0.0
while True:
screen.blit(bgimg)
dy = 0
for i, msg in enumerate(msgs):
dx = 0
for idx, c in enumerate(msg):
font.drawText(screen, xs[i] + dx,
y + dy + 20 * math.sin(angle + 0.2 * idx), c)
dx += widths[i][idx]
dy += font.textHeight('') + 20
screen.swap()
angle += 0.2
pad = psp2d.Controller()
if pad.circle:
break
def __init__(self):
self.logic = Logic()
self.marked_option = 0
self.menu_opt = [{
'opt_name': 'Start',
'yposition': 170,
'reaction': self.start_game
}, {
'opt_name': 'High Score',
'yposition': 200,
'reaction': self.high_score
}, {
'opt_name': 'Exit',
'yposition': 230,
'reaction': self.exit
}]
self.OPTIONS_NUMBER = len(self.menu_opt)
self.quit = False
self.font = psp2d.Font('buttons/res/font.png')
self.BLACK = psp2d.Color(0, 0, 0, 255)
self.GREEN = psp2d.Color(0, 50, 0, 255)
self.RED = psp2d.Color(50, 0, 0, 255)
self._initialize_screen()
self.database = anydbm.open('scores.db', 'c')
def load_font(self, url):
return psp2d.Font(url)
import pspogg
from time import time, localtime, sleep
import datetime
import stackless
import sys
from beast.btypes import *
from beast.tools import *
import random
import threading
from beast.tools import get_random_string
import types
import glob
import os
import importlib
font = psp2d.Font('assets/font.png')
screen = psp2d.Screen()
screen.clear(psp2d.Color(0, 0, 0, 255))
def LOG(self, data="...", to_console=True, to_screen=False):
t = "%s: %s" % ("Anonumous", str(data))
if to_console: print(t)
class GLOBAL(object):
SCREEN = screen
REGISTER = {}
TYPED_REGISTER_COUNT = {}
TYPED_REGISTER = {}
STATE = {}
import datetime
import sys
import stackless
import os
import threading
import urlparse
pspos.setclocks(333, 166)
print "Localtime: ", localtime()
print "Datetime: ", datetime.datetime.now()
screen = psp2d.Screen()
screen.clear(psp2d.Color(0, 0, 0, 255))
font = psp2d.Font('font.png')
apctl_states = [
"PSP_NET_APCTL_STATE_DISCONNECTED", "PSP_NET_APCTL_STATE_SCANNING",
"PSP_NET_APCTL_STATE_JOINING", "PSP_NET_APCTL_STATE_GETTING_IP",
"PSP_NET_APCTL_STATE_GOT_IP", "PSP_NET_APCTL_STATE_EAP_AUTH",
"PSP_NET_APCTL_STATE_KEY_EXCHANGE", "PSP_NET_APCTL_EVENT_CONNECT_REQUEST",
"PSP_NET_APCTL_EVENT_SCAN_REQUEST", "PSP_NET_APCTL_EVENT_SCAN_COMPLETE",
"PSP_NET_APCTL_EVENT_ESTABLISHED", "PSP_NET_APCTL_EVENT_GET_IP",
"PSP_NET_APCTL_EVENT_DISCONNECT_REQUEST", "PSP_NET_APCTL_EVENT_ERROR",
"PSP_NET_APCTL_EVENT_INFO", "PSP_NET_APCTL_EVENT_EAP_AUTH",
"PSP_NET_APCTL_EVENT_KEY_EXCHANGE", "PSP_NET_APCTL_EVENT_RECONNECT",
"PSP_NET_APCTL_INFO_PROFILE_NAME", "PSP_NET_APCTL_INFO_BSSID",
"PSP_NET_APCTL_INFO_SSID", "PSP_NET_APCTL_INFO_SSID_LENGTH",
"PSP_NET_APCTL_INFO_SECURITY_TYPE", "PSP_NET_APCTL_INFO_STRENGTH",
"PSP_NET_APCTL_INFO_CHANNEL", "PSP_NET_APCTL_INFO_POWER_SAVE",
import psp2d, pspos
import anydbm
from time import time
from time import sleep
from random import randint
from buttons.Left import Left
from buttons.Right import Right
from buttons.Up import Up
from buttons.Down import Down
from buttons.Circle import Circle
from buttons.Triangle import Triangle
from buttons.Square import Square
from buttons.Cross import Cross
screen = psp2d.Screen()
fnt = psp2d.Font('buttons/res/font.png')
pspos.setclocks(20, 10)
execfile(".\\danzeff\\danzeff.py")
# unused
class Rectangle(object):
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def isIn(self, x, y):
def setUp(self):
self.screen = psp2d.Screen()
self.font = psp2d.Font('font.png')
if pad.l:
font.drawText(image, 0, 60, "LEFT TRIG")
if pad.r:
font.drawText(image, 160, 60, "RIGHT TRIG")
if pad.start:
font.drawText(image, 120, 130, "START")
if pad.select:
font.drawText(image, 60, 130, "SELECT")
if pad.analogX:
font.drawText(image, 0, 150, "ANALOG_X= " + str(pad.analogX))
if pad.analogY:
font.drawText(image, 0, 170, "ANALOG_Y= " + str(pad.analogY))
return image
font = psp2d.Font("font.png")
image = psp2d.Image(480, 272)
screen = psp2d.Screen()
CLEAR_COLOR = psp2d.Color(0, 0, 0)
image.clear(CLEAR_COLOR)
x = True
while x == True:
image.clear(CLEAR_COLOR)
font.drawText(image, 70, 0, "--PSP CONTROLLER TEST--")
font.drawText(image, 50, 30, "------------------------------------")
font.drawText(image, 70, 210, "WRITTEN BY: SUPROTIK DEY")
pad = psp2d.Controller()
image = drawGamePadTest(pad, image)
screen.blit(image)
screen.swap()
