Programmieren auf der GP2X


wenn man das python 2.2.4 auf dem gp2x benutzt, sollte man dann auf dem windowspython 2.2.4 lernen oder auch schon auf python 2.5 die programme entwerfen?
Also ich benutzte 2.5, aber mache bissher fast ausschließlich nur Sachen am PC.

Kannst ja mal in deinem Python Ordner die NEWS.txt öffnen, da findest du alle Änderungen seit Version 1.5.1 und dann selbst entscheiden..

Gruss

Edit:
http://www.python-forum.de/forum-4.html
 
ich habe hier mal eine ping-pong-demo aus dem pygameordner lauffähig gemacht für den gp2x. habe die paddle mit den tasten noch nicht eingbunden und die 5 bälle auf 1 ball reduziert.
wollte nur einmal testen wie das programm auf dem gp2x läuft.

es funktioniert soweit alles.
nur der 1 ball fliegt sehr, sehr langsam über die bildfläche, wo liegt da die bremse. kann einer mal den code testen oder durchforsten.

auf dem pc läuft dieses programm ab wie schmidts katze.

es sind doch nur einpaar einfache matherechnungen drin.

ist mir schleierhaft.

Code:
<i>
</i>import pygame
from pygame.locals import *
import sys, os
import random
from math import *

pygame.init()

Screen = (320,240)
pygame.display.set_caption("Ping")
icon = pygame.Surface((1,1)); icon.set_alpha(0); pygame.display.set_icon(icon)
Surface = pygame.display.set_mode(Screen)

pygame.mouse.set_visible(False)

Ping = pygame.mixer.Sound('Ping.wav')
Click = pygame.mixer.Sound('Click.wav')
Ping.set_volume(0.1)
Click.set_volume(0.1)

Font = pygame.font.Font(None,22)
Font2 = pygame.font.Font(None,18)

CirclesInTheAir = 1

class Circle:
    def __init__(self,x,y):
        self.x = x
        self.y = y
        angle = random.randint(0,360)
        self.speedx = 0.7*cos(radians(angle))
        self.speedy = 0.7*sin(radians(angle))
        self.placesbeen = []
        self.radius = 2
        self.add = 0
        self.stopped = False
        self.stoppedtime = 0
Circles = []
#for x in xrange(CirclesInTheAir):
#    Circles.append(Circle(Screen[0]/2,Screen[1]/2))
class Paddle:
    def __init__(self,x,y,size,player):
        self.rect = [x,y,10,size]
        self.player = player
Paddles = []
Paddles.append(Paddle(10,Screen[1]/2,50,1))
Paddles.append(Paddle(310,Screen[1]/2,50,2))
P1Score = 0
P2Score = 0
def GetInput():
    key = pygame.key.get_pressed()
    for event in pygame.event.get():
        if event.type == QUIT or key[K_a]:
            pygame.mouse.set_visible(True)
            pygame.quit(); sys.exit()
    if key[K_UP]:
        for p in Paddles:
            if p.player == 2: p.rect[1] += 3
    if key[K_DOWN]:
        for p in Paddles:
            if p.player == 2: p.rect[1] -= 3
    if key[K_w]:
        for p in Paddles:
            if p.player == 1: p.rect[1] += 3
    if key[K_s]:
        for p in Paddles:
            if p.player == 1: p.rect[1] -= 3
def Update():
    for c in Circles:
        if c.add == 0:
            c.placesbeen.append([c.x,c.y])
            c.placesbeen.reverse()
            c.placesbeen = c.placesbeen[:25]
            c.placesbeen.reverse()
            c.add = 15
        else:
            c.add -= 1
        if c.stoppedtime == 37:
            Circles.remove(c)
            continue
    if len(Circles) < CirclesInTheAir:
        Circles.append(Circle(Screen[0]/2,Screen[1]/2))
def Move():
    for c in Circles:
        c.x += c.speedx
        c.y += c.speedy
    Update()
def CollisionDetect():
    global P1Score, P2Score
    for c in Circles:
        if c.x <= 0-c.radius:
            if not c.stopped:
                c.stopped = True
                c.speedx = 0
                c.speedy = 0
                P2Score += 1
            else:
                c.stoppedtime += 1
        if c.y <0>= Screen[0]+c.radius:
            if not c.stopped:
                c.stopped = True
                c.speedx = 0
                c.speedy = 0
                P1Score += 1
            else:
                c.stoppedtime += 1
        if c.y >= Screen[1]:
            c.y = Screen[1]
            c.speedy *= -1
            Click.play(0)
    for p in Paddles:
        if p.rect[1]-(p.rect[3]/2) <0> Screen[1]:
            p.rect[1] = Screen[1] - (p.rect[3]/2)
    for p in Paddles:
        r = PygameRectFromRect(p.rect)
        for c in Circles:
            xdiff = c.x - p.rect[0]
            ydiff = c.y - p.rect[1]
            if abs(xdiff) <= (p.rect[2]/2) + c.radius and abs(ydiff) <p> 0:#right side
                    c.x = r[0] + r[2] + c.radius
                if xdiff < 0:#left side
                    c.x = r[0] - c.radius
                c.speedx *= 1.1
                c.speedy *= 1.1
def PygameRectFromRect(r):
    tl = (  r[0]-(r[2]/2),  (r[1]+(r[3]/2))  )
    dim = (  r[2],  r[3]  )
    r2 = (tl[0],tl[1],dim[0],dim[1])
    return r2
def IntegerisePoint(point):
    returnpoint = [int(round(point[0])),int(round(point[1]))]
    return returnpoint
info_text = Font.render("Ping",True,(255,255,255))
info_text_draw_pos = ((Screen[0]/2)-(info_text.get_width()/2),10)
def Draw():
    Surface.fill((0,0,0))
    for c in Circles:
        light = 0
        for p in c.placesbeen:
            point = IntegerisePoint((p[0],Screen[1]-p[1]))
            pygame.draw.circle(Surface,(light,0,0),point,c.radius)
            light += 2
        point = IntegerisePoint((c.x,Screen[1]-c.y))
        pygame.draw.circle(Surface,(255,255,255),point,c.radius)
    for p in Paddles:
        r = PygameRectFromRect(p.rect)
        pygame.draw.rect(Surface,(255,255,255),(r[0],Screen[1]-r[1],r[2],r[3]),0)
    Surface.blit(info_text,info_text_draw_pos)
    p1_score_text = Font2.render("Player 1, Score "+str(P1Score),True,(255,255,255))
    p2_score_text = Font2.render("Player 2, Score "+str(P2Score),True,(255,255,255))
    Surface.blit(p1_score_text,(0+20,20))
    Surface.blit(p2_score_text,(Screen[0]-p2_score_text.get_width()-20,20))
    pygame.display.flip()
def main():
    while True:
        GetInput()
        Move()
        CollisionDetect()
        Draw()
if __name__ == '__main__': main()
 
Pygame macht den Zugriff auf die Grafikleistungen der SDL besonders einfach. Allerdings ist Python als Interpretersprache nicht optimal, wenn es um rechenintensive 3D-Darstellungen geht. Ideal ist in diesen Fällen die Kombination von Python mit C oder C++.

ich programmier zwar nur in 2d, aber intensive rechnungen müssen ja auf grund des abprallwinkel hier in 2d auch durchgeführt werden.

kann das schon der bremsklotz sein? hoffentlich nicht.
es kann doch nicht schon an einer ballbewegung von einem ball und einer einfach gestrickten collison scheitern???

hoffentlich liegt es wo anders dran!
 
sechsrad said:
Pygame macht den Zugriff auf die Grafikleistungen der SDL besonders einfach. Allerdings ist Python als Interpretersprache nicht optimal, wenn es um rechenintensive 3D-Darstellungen geht. Ideal ist in diesen Fällen die Kombination von Python mit C oder C++.

ich programmier zwar nur in 2d, aber intensive rechnungen müssen ja auf grund des abprallwinkel hier in 2d auch durchgeführt werden.

kann das schon der bremsklotz sein? hoffentlich nicht.
es kann doch nicht schon an einer ballbewegung von einem ball und einer einfach gestrickten collison scheitern???

hoffentlich liegt es wo anders dran!
genau da könnte das problem liegen, es dauert zu lange alles nötige zu berechnen.
dazu kommt noch das python eine interpretierte und nicht compilierte sprache ist, somit fehlt dort also auch eine gewisse performance.
korrigiert mich einfach wenn was an meinen aussagen falsch ist^^

edit: ich hab grad in der entwickler-ecke gelesen, das es auch compiled python gibt, schau doch einfach mal nach: http://forum.gp2x.de/viewtopic.php?p=62317#62317
 
so, ich habe jetzt auch dieses spiel "Asteroids" vom pygame-center auf dem gp2x mit python zum laufen gebracht (screen geändert und eine dateiendung von .pyw auf .py geändert) die grafiken,musik usw laufen wie auf dem pc. also eigentlich wunderbar.

aber auch hier der starke einbruch in der geschwindigkeit zur darstellung und berechnung der daten.
für 1 frame braucht der gp2x 0,5 sekunden.

ich weiss auch nicht mehr wo ich kürzen soll, weil das spiel startet und läuft auf dem gp2x sonst einwandfrei , schmiert nicht ab. das ist ja eigentlich für python eine klasse angelegenheit.

schade eigentlich!!!

fazit ist, das python nicht geeignet ist um spiele zu proggen die bewegung mit collision darstellen auf dem gp2x.
spiele wie tetris usw sind machbar aber bei mehreren bewegungen mit collisionsabfrage geht es nicht mehr so, das es angenehm anzuschauen ist.

zur zeit sind die favoriten für das proggen auf dem gp2x : c++,glbasic und fenix.
 
ein artikel aus einem forum:
Ein Programm arbeitet nicht schneller oder langsamer, wenn es von einer .pyc- oder .pyo-Datei gelesen wird, als wenn es von einer .py-Datei gelesen wird. Das Einzige, was bei .pyc- oder .pyo-Dateien schneller geschieht, ist die Geschwindigkeit, mit der sie geladen werden.


in der ablaufgeschwindigkeit tut sich nichts.
 
noch eine schlechte botschaft : sdl_doublebuf geht nicht in c++ für den gp2x. es läuft nur unter windows mit directx , wenn man dahinter einen text=directx schreibt.

mfg
 
also es gibt zur zeit nur 2 programmiersprachen die die grafik einwandfrei , schnell und flimmerfrei auf dem gp2xanzeigen :( :

glbasic und fenix:D


damit hätten wir es eigentlich.

mfg
 
also es gibt zur zeit nur 2 programmiersprachen die die grafik einwandfrei , schnell und flimmerfrei auf dem gp2xanzeigen :

glbasic und fenix
Es wurde dir schon mehrfach gesagt, dass das nichts mit der Programmiersprache zu tun hat! Du kannst statt der SDL genausogut Allegro oder eine andere Bibliothek verwenden. Ansonsten unterstützt diese SDL-Version Double-Buffering und sogar HW-Blitting. Übrigens wird diese Version höchstwahrscheinlich sowohl von glBasic als auch von Fenix verwendet.

mfg Isoc
 
. Ansonsten unterstützt diese SDL-Version Double-Buffering und sogar HW-Blitting.

da das devkit für den gp2x mit sdl abgestimmt ist und etwas älter ist, wird die nicht eingebaut sein. auf jedenfall läuft der befehl nicht, wird ingnoriert. schade.
Übrigens wird diese Version höchstwahrscheinlich sowohl von glBasic als auch von Fenix verwendet.

das weiss ich nicht. da musst du mal die entwicker von fenix und glbasic fragen. kann ich dir nicht beantworten.
 
Es wurde dir schon mehrfach gesagt, dass das nichts mit der Programmiersprache zu tun hat!

das ist mir wurscht, hauptsache es wird vom dem grafikbefehl den ich in fenix oder glbasic eingebe benutzt.
 
Hallo sechsrad,

also erstmal.. 4-fach-posts sind nicht witzig :lol: Kannst ja die Edit-Funktion verwenden. Ist einfach übersichtlicher..


Kannst ja mal hier vorbeischauen, sind ein paar Spiele und Programme, die mit pygame auf dem gp2x realisiert wurden.
Ich weiß aber echt nicht, was du für Performanceprobleme hast, bei mir läuft bissher alles was ich getestet habe super.

gruss
 
denk dran ich benutze den gp2x und nicht den pc zum testen.
auf dem pc ist das kein problem. nicht das wir hier von 2 verschiedenen schuhen reden. weil du glaube ich nur auf dem pc proggen tust.
sonst ist pygame kein problem. als editor nehme ich den idle von python. der ist erste sahne im handling.

also dieses "Asteroids" läuft mit 1 frame bei 0.5 sekunden.
dieses ping-pong-spiel läuft mit 3 frame pro sekunde, wobei dieses wirklich einfach gestrickt ist.
 
Back
Top