Pygame

Keroro · October 21, 2008

Mesi fa marigno ha proposto un corso su python per creare giochi, abbandonato completamente.

Considerato che al tempo c'erano diversi interessati ed alla luce del format che mi ha fatto perdere il mio engine 2d (avendo inoltre rovinato i backup) ho deciso di riscrivere tutto in Python perché lo sto usando per un corso in università (Data Structures and Algorithms).

La mia intenzione è postare qui i risultati ottenuti giornalmente sia per premunirmi dai crash, sia per dare qualcosa alla comunità :)

Non mi dilungherò sulla teoria, quella se volete la potete trovare ovunque, darò solo qualche scratch.

Risorse:

Se comunque non capite qualcosa, non esitate a chiedere :)

Versione 0001: Visualizzare una finestra

finestra.py

#!/usr/bin/python
import pygame, sys
from pygame.locals import *

class GameWindow(object):
game_running = True
def __init__(self,title,width=640,height=480):
	self.width = width
	self.height = height
	pygame.init()
	self.schermo = pygame.display.set_mode((width,height),DOUBLEBUF)
	pygame.display.set_caption(title)
def game_end(self):
	sys.exit(0)
def run(self):
	clock = pygame.time.Clock()
	while (self.__class__.game_running):
		clock.tick(60)
		for evento in pygame.event.get():
			self.input(evento)
		self.draw()
		pygame.display.flip()
	self.game_end()
def input(self,evento):
	if evento.type == QUIT:
		self.__class__.game_running = False;
	else:
		print evento
def draw(self):
	self.schermo.fill(0x39d2c2)	
	

finestra = GameWindow("Finestra Colorata")
finestra.run()

(nota per i mod: modifichereste il css per aumentare la leggibilità?)

Spiegazioni:

Tutti i commenti iniziano per # (cancellletto)
La prima riga serve soltanto per gli utilizzatori di sistemi linux/unix per poter eseguire lo script direttamente da shell:
invece di scrivere
```
python finestra.py
```
è possibile eseguire lo script con
```
./finestra.py
```
avendo settato in precedenza i permessi
```
chmod +x finestra.py
```
l'import è la parola chiave per importare delle librerie, in questo caso pygame che si occupa di tutto quello che ci serve per il gioco e sys che contiene alcune funzioni basilari di sistema
La classe
Tutte le classi in python devono avere un padre da cui ereditano, object è la classe base.
Lo schema è class Nomeclasse(classepadre)
Le variabili dentro una classe ma non dentro il metodo sono variabili di classe
per accedervi dalla stessa classe ho usato il costrutto self.__class__.nomevariabile
sono accessibili al di fuori anche a chi non conosce il nome della classe ed anche se non sono state ancora create delle istanze della stessa
I metodi
I metodi sono le funzioni di una classe, come primo argomento devono avere self che viene automaticamente passato nel momento in cui viene chiamata la funzione da un elemento (finestra.run() diventa classe[finestra].run(finestra) )
Pygame
Questa spiegazione è a richiesta ovvero potete postare chiedendo cosa non capite ed io ve la spiego (preferisco questo rispetto a lunghe spiegazioni esaustive che annoiano tutti, anche per capire a che livello siete)

Edited February 15, 2012 by Keroro

Keroro · October 22, 2008

Un TRIS in PAIGHEIM

Vediamo se con questo incito qualcuno a postare...

http://img159.imageshack.us/img159/2199/trisfy6.th.png http://img159.imageshack.us/images/thpix.gif

L'ho iniziato oggi alle 20.00 e ripreso a spizzichi mentre guardavo le iene:

Features:

-giocabile con il mouse

-si gioca contro il pc, che per ora ha una ia base (presto quella media e quella imbattibile)

-valuta se la posizione è vinta o patta

Todo:

-immagini per segnalare lo stato di gioco (partita patta, partita vinta) che finora viene stampato solo su console

-immagini per continuare con una nuova partita od uscire

-segnare il punteggio con un font

Il gioco è nel file tris.py (189 linee di codice incluse linee bianche e linee solo con commenti).

tris.py importa una versione migliorata di finestra.py (33 linee di codice)

Versione 0002: Finestra importabile da altri sorgenti; tasto ESC per uscire dal gioco

finestra.py

#!/usr/bin/python
import pygame, sys
from pygame.locals import *

class GameWindow(object):
game_running = True
def __init__(self,title,width=640,height=480):
	self.width = width
	self.height = height
	pygame.init()
	self.schermo= pygame.display.set_mode((width,height),DOUBLEBUF)
	pygame.display.set_caption(title)
def game_end(self):
	pygame.display.quit()
	sys.exit(0) 
def run(self):
	clock = pygame.time.Clock()
	while (self.__class__.game_running):
		clock.tick(60)
		for evento in pygame.event.get():
			self.input(evento)
		self.draw()
		pygame.display.flip() 
	self.game_end()
def input(self,evento): 
	if evento.type == QUIT or (evento.type == KEYDOWN and evento.key == K_ESCAPE):
		self.__class__.game_running = False;
def draw(self):
	self.schermo.fill(0x39d2c2)	
	
if __name__ == "__main__":
finestra = GameWindow("Finestra Colorata")
finestra.run()

Ribadisco, non vi farò un tutorial estensivo su Pygame o su python ma se avete una o più domanda non generica ma specifica su un costrutto del linguaggio od un metodo di libreria, chiedete!

Inoltre se non vedo interesse non rilascerò alcun sorgente che non riguardi miglioramenti della classe base =D

Edited October 22, 2008 by Keroro

PICCOLO · October 22, 2008

Mmmmmh... Sono cieco io o ti sei dimenticato di mettere il file tris.py? :D

Ad ogni modo sto guardando finestra.py e, per sapere poco o niente di python (e zero dei metodi di pygame :D ), apprezzo quel che mi pare il miglior pregio del linguaggio: la chiarezza :P

Se posso volevo chiederti una cosa:

if __name__ == "__main__":
finestra = GameWindow("Finestra Colorata")
finestra.run()

è solo per fare dei test o ha anche altri utilizzi? (o, altra alternativa, ne ho travisato il significato? :D )

Mo' guardo un po' il resto di pygame (appena riesco) che mi pare interessante e strutturata bene la documentazione :wink:

Attendo il tris :ph34r:

Edited October 22, 2008 by PICCOLO

Keroro · October 22, 2008

il tris non l'ho messo volutamente per evitare che ci fossero solo lurker mentre voglio persone attive desiderose di imparare (ma se ci saranno altri post presto lo pubblicherò anche perché penso di aver fatto un buon lavoro :D)

Rispondo alla tua domanda:

__name__ è il parametro che identifica il modulo (o file sorgente .py)

se il file viene eseguito direttamente, __name__ nel file assume valore "__main__"

A che serve quell'if?

Crea una istanza della classe GameWindow soltanto se io eseguo finestra.py, se invece importo finestra.py in un altro file ed eseguo l'altro file, questo __name__ non vale "__main__" e quindi non creo nessuna istanza.

E' utile perché che ti da la possibilità di testare il componente, spezzando con il manicheismo delle classi java che tranne una (quella con lo static main) sono librerie passive

DaD · October 22, 2008

In Pygame feci uno snake molto rudimentale, ma la questione è che python mi sta sui maroni e quindi non credo proprio che lo riprenderò mai più :wink:

PICCOLO · October 25, 2008

il tris non l'ho messo volutamente per evitare che ci fossero solo lurker mentre voglio persone attive desiderose di imparare (ma se ci saranno altri post presto lo pubblicherò anche perché penso di aver fatto un buon lavoro :D)

Ah, ok.

Mi ha tratto in inganno la frase

Il gioco è nel file tris.py (189 linee di codice incluse linee bianche e linee solo con commenti).

(e io ero li che cercavo il file tris.py :D )

Grazie per la spiegazione: è un metodo comodo e intelligente devo dire :biggrin:

Sto provando a fare il tris, ma ho avuto il tempo di starci attaccato solo 10 minuti (e stavo guardando Ratatouille in contemporanea, quindi... XD ).

Appena riesco a produrre qualcosa di decente (e non pericoloso: l'ultima cosa che ho scritto mi ha costretto ad un ripristino del sistema :tongue: ) la posto :P

Edited October 25, 2008 by PICCOLO

Keroro · October 25, 2008

Considerando che sono dai miei, non ho il tris.py da upparvi

Ho deciso di andare per gradi presentando una classe che possa caricare dei file immagine, poi sempre nel file ho fatto una classe che eredita da GameWindow (in finestra.py) e presenta un esempio di utilizzo (mostra il logo del sito :D)

V003: Caricare immagini

immagine.py

#!/usr/bin/python
import finestra
import pygame, os
from pygame.locals import *
from finestra import *

class ImageLoader:
img_path = "img" #la cartella dentro cui mettere le immagini
ext = ".png" 
def __init__(self):
	if not pygame.image.get_extended():
		raise SystemExit, "Spiacente, e' necessaria la libreria SDL_image!"
def image_path(self,name):
	return os.path.join(self.img_path,name+self.ext)
def image_load(self,name):
	img_name = self.image_path(name)
	try:
		img = pygame.image.load(img_name)
	except pygame.error:
		raise SystemExit, 'Impossibile caricare "%s" %s'%(img_name, pygame.get_error())
	return img.convert()

class Viewer(GameWindow):
def __init__(self,title="Image Viewer",width=410,height=205):
	GameWindow.__init__(self,title,width,height)
	loader = ImageLoader()
	self.logo = loader.image_load("logo")
def draw(self):
	self.schermo.blit(self.logo,(0,0))

#solo quando il file viene eseguito direttamente
if __name__ == "__main__":
finestra = Viewer()
finestra.run()

Allego un esempio di funzionamento completo (dovete avere installato pygame e python e cliccare due volte su immagine.py se siete su windows):

immagine.zip

Keroro · October 26, 2008

Visto che stasera non ha postato nessuno mi sono divertito nel riprodurre rpgmaker 2000 (scusate il doppio post :biggrin: )

V 004: Visualizzare parti di Immagini, in particolare i charset ed i chipset di RM2K e creare una classe per i movimenti su griglia

rm2k.py (141 righe)

http://img171.imageshack.us/img171/7780/rpgmakerwg4.th.png http://img171.imageshack.us/images/thpix.gif

import pygame,immagine,finestra,random
from pygame.locals import *
from immagine import *
from finestra import *

#variabile globale: dove stampare l'immagine
schermo = 0

#Classe che carica una immagine ed eventualmente la scala2x ed applica un colore alpha
class DoubleLoader(ImageLoader):
def image_load(self,name,double=0,alpha=0,color=(255,103,139)):
	img_name = self.image_path(name)
	try:
		img = pygame.image.load(img_name)
	except pygame.error:
		raise SystemExit, 'Impossibile caricare "%s" %s'%(img_name, pygame.get_error())
					
	if alpha:
		img.set_colorkey(color,RLEACCEL)
	if double:
		img = pygame.transform.scale2x(img)
	
	return img.convert()


#Classe che carica charset e chipset		
class SpriteSheet:
#alpha: verdino charset, viola chipset
alpha = ((35,156,0),(255,103,139))
def __init__(self,name,type=0):
	loader = DoubleLoader()
	self.sprite = loader.image_load(name,1,1,self.alpha[type])
def get_sprite(self):
	return self.sprite
	
class Character:
tile_x = 48
tile_y = 64
def __init__(self,sprite,position=0,x=0,y=0):
	self.sprite = sprite
	self.position = position
	self.image_speed = 0.15
	self.image_index = 1.0
	self.image_max = 3.0
	self.face = random.randint(0,3) #NESO
	#coordinate intere mappa
	self.map_x = x 
	self.map_y = y
	#pixel
	self.x = self.map_x*32-8
	self.y = self.map_y*32-32
	self.target_x = x
	self.target_y = y
	#
	self.frame = 0
	self.pause = False
	self.hspeed =0
	self.vspeed =0
	self.muovi(self.face/2,(self.face/2 ==0)*random.choice((-1,1)))
def muovi(self,dx,dy):
	#funziona solo per movimenti unitari
	#mancano gli sprite per fare movimento diagonale
	#se non e' ancora arrivato, non accetta nuovi movimenti :|
	#da fare uno stack per movimenti preprogrammati
	if self.target_x != self.map_x or self.target_y != self.map_y:
		return
	if dx:
		self.face = 2*(dx<0)+1
	else:
		self.face = 2*(dy>0)
	self.target_x = float(self.x+16*(dx<0)-16*(dx>0)+dx*self.tile_x)
	self.target_y = float(self.y+32*(dy<0)-32*(dy>0)+dy*self.tile_y)
	self.hspeed = 0.2*dx
	self.vspeed = 0.2*dy
def step(self):
	#se non e' ancora arrivato a destinazione, somma hspeed e vspeed
	#h e v stanno per horizontal e vertical
	if abs(self.target_x - self.x)>abs(self.hspeed/2) or abs(self.target_y - self.y)> abs(self.vspeed/2):
		self.x+=self.hspeed
		self.y+=self.vspeed
		print "("+str(self.x)+","+str(self.y)+")->(" +str(self.target_x)+ "," +str(self.target_y)+")"


def draw(self):
	#se l'animazione e' ferma, non ricalcoliamo il frame
	if self.pause:
		schermo.blit(self.sprite,(self.x,self.y),self.frame)
		return
	self.image_index+=self.image_speed
	if (self.image_index > self.image_max):
		self.image_index = 0
	self.frame = ((int(self.image_index)+self.position%4*3)*self.tile_x, (self.face+self.position/4*4)*self.tile_y, self.tile_x,self.tile_y)
	schermo.blit(self.sprite,(self.x,self.y),self.frame)
	
	
class Map:
tile_x = 32
tile_y = 32
def __init__(self,sprite,width=20,height=15):
	self.sprite = sprite
	self.width = width
	self.height = height
	self.random()
	self.eventi = []
def evento(self,obj):
	self.eventi.append(obj)
def random(self):
	self.mappa = []
	for j in range(self.height):
		for i in range(self.width):
			self.mappa.append(random.randint(0,5)+random.randint(8,15)*30)
def draw(self):
	for i in self.eventi:
		i.step()
	for j in range(self.height):
		for i in range(self.width):
			schermo.blit(self.sprite,(i*self.tile_x,j*self.tile_y), ((self.mappa[i+j*self.width]%30)*self.tile_x, (self.mappa[i+j*self.width]/30)*self.tile_y,self.tile_x,self.tile_y))
	for i in self.eventi:
		i.draw()
		

class RpgMaker(GameWindow):
def __init__(self,title="Rpg Maker 2000",width=640,height=480):
	GameWindow.__init__(self,title,width,height)
	random.seed()
	self.chipset = SpriteSheet("basis",1)
	self.charset = SpriteSheet("Chara1")
	self.mappa = Map(self.chipset.get_sprite())
	self.mappa.evento(Character(self.charset.get_sprite(),random.randint(0,7),4,5))
	self.mappa.evento(Character(self.charset.get_sprite(),random.randint(0,7),6,7))
	self.mappa.evento(Character(self.charset.get_sprite(),random.randint(0,7),9,9))
	global schermo
	schermo = self.schermo
def draw(self):
	schermo.fill(0x000000)
	self.mappa.draw()
		
if __name__ == "__main__":
os.environ["SDL_VIDEO_CENTERED"] = "1"
finestra = RpgMaker()
finestra.run()

Nota: il [ code ] spezza alcune righe

E' tutto random, dalla scelta dei personaggi alla scelta della direzione in cui muoversi alla disposizione dei tile, quello che non cambia sono solo le disposizioni su mappa.

Non esiste alcun check se il tile è occupato, per ora volevo fare qualcosa di semplice :) e non ho ancora deciso come fare il sistema delle collisioni (sprite_based? map_based? other?)

Sorgenti+Immagini: rm2k.zip

Edited October 26, 2008 by Keroro

Alato · October 26, 2008

Bella iniziativa mi spiace che per ora sospetto che andare ad imparare un ulteriore linguaggio mi confonderebbe le idee che già sono abbastanza confuse di mio. :biggrin:

Quindi per ora passo, mi spiace..

Anyway, che cosa intendi per migliorare la visibilità? Cosa proporresti?

Keroro · October 26, 2008

Alato: Susu lasciati confondere le idee, non è tanto diverso dal ruby :*

su linux il font del code manca quindi si vede molto più piccolo ed in azzurrino poco marcato

tra i css si dovrebbe mettere con la virgola un font che c'è anche sul linux (ora non ti so dire, stasera sì)

PICCOLO: bravo :) voglio vedere qualcosa di tuo!

stasera uppo il mio tris, magari ti puo' ispirare a riprendere a scriptare

Appena sviluppo abbastanza classi sintetizzo una libreria, per ora sto importando i file un po' a muzzo, se avete consigli o note su qualche implementazione e pensate che la vostra sia migliore, suggeritemela con un post :D

Alato · October 26, 2008

Ho capito, anch'io avevo questo problema ma ho risolto importando i font di windows (anche perché altri siti mi davano questo tipo di problemi). Comunque lo dico ai boss e cerchiamo di risolvere.

Per il python prometto che tra qualche giorno ci provo.. xD

E' che la somiglianza tra la sintassi di C e quella di Java e la somiglianza tra la semantica di Java e quella di Ruby, mi sta facendo scrivere erorri stupidi. Non li cito neanche che mi vergogno, comunque spesso fondo i linguaggi.. ;O;

Keroro · October 27, 2008

Come promesso ecco il tris.py (aggiornato per usare la classe ImageLoader presente in immagine.py, ma ancora con i difetti sopracitati perché non ho avuto il tempo materiale di lavorarci)

In fondo alla pagina c'è uno zip con allegati sorgenti ed immagini :)

V 005: Creare un minigioco interattivo con il mouse

tris.py

#!/usr/bin/python
import pygame, sys, os,random
import finestra,immagine
from pygame.locals import *
from finestra import *
from immagine import *

#classe utile per gestire l'output di debug durante lo sviluppo
class Debug:
def __init__(self,tabellone):
	self.base = tabellone
def mossa(self,piena,mosse,index=0):
	print "#Mossa "+str(mosse)+": ",
	if piena=="Piena":
		print "Casella Piena"
	elif piena == "Fuori":
		print "Cliccato Fuori"
	elif piena == "PC":
		print "PC: ("+ str(index%3)+","+str(index/3)+")"
	else:
		print "Casella Vuota"
def fatal(self):
	print "Errore Imprevisto"
	self.base.game_end()
	

class Segno:
def __init__ (self, sprite,schermo,punto):
	self.sprite_index = sprite
	self.schermo = schermo
	self.punto = punto
def draw(self):
	self.schermo.blit(self.sprite_index,self.punto)

class Tabellone(GameWindow):
def __init__ (self,title="Tris",width=640,height=480):
	GameWindow.__init__(self,title,width,height)
	#grafica
	loader = ImageLoader()
	self.tabella = loader.image_load("tabella")
	self.sprite_x = loader.image_load("X")
	self.sprite_o = loader.image_load("O")
	#logica
	self.can_play = True
	self.partita = 0
	self.debug = Debug(self)
	self.mosse = 0
	self.mouse = pygame.Rect(0,0,1,1)
	self.oggetti = []
	square = 105
	self.x = [43,167,291]
	self.y = [76,203,330]
	self.rectList = []
	self.muovi = [ self.muoviHU, self.muoviPC ]
	#preparo la lista delle caselle con cui confrontare il click
	for j in self.y:
		for i in self.x:
			self.rectList.append(pygame.Rect(i,j,square,square))
	#mappa: 0-> vuoto, 1-> croce (player), 2-> cerchio(pc)
	self.mappa = []
	for i in range(9):
		self.mappa.append(0)
		
#aggiunge un tassello per il giocatore
def aggiungi(self,giocatore,dove,sprite):
	self.mappa[dove]=giocatore
	self.oggetti.append(Segno(sprite,self.schermo,(self.x[dove%3],self.y[dove/3])))
	self.mosse +=1

#gestisce la pressione del mouse
def input(self,evento):
	GameWindow.input(self,evento)
	if self.partita:
		return
	if evento.type == MOUSEBUTTONDOWN and evento.button == 1:
		if not self.can_play:
			return 
		id = self.mouse.move(pygame.mouse.get_pos()).collidelist(self.rectList)
		if (id < 0):
			self.debug.mossa("Fuori",self.mosse)
			return
		if (id > 8):
			self.debug.fatal()
			return	
		if (self.mappa[id]):
			self.debug.mossa("Piena",self.mosse)
		else:
			self.debug.mossa("Dentro",self.mosse)
			#mossa giocatore
			self.muovi[0](id)
			#controllo se la partita e' finita	
			if self.partita:
				return
			#mossa computer
			self.muovi[1](id)
			

def draw(self):
	self.schermo.blit(self.tabella,(0,0))
	for obj in self.oggetti:
		obj.draw()
		
def muoviHU(self,index):
	self.aggiungi(1,index,self.sprite_x)
	self.can_play = False
	self.check_end(index)

def muoviPC(self,garbage):
	#casuale, non ancora implementata una ia
	passi = random.randrange(1,9-self.mosse)
	index = -1
	while passi>0:
		index+=1
		if (self.mappa[index]):
			continue
		passi-=1
	self.debug.mossa("PC",self.mosse,index)
	self.aggiungi(2,index,self.sprite_o)
	self.can_play = True
	self.check_end(index)

###CONTROLLO###

def short_check(self,base,incremento):
	if (self.mappa[base] == self.mappa[base+incremento] == self.mappa[base+incremento*2]):
		return 1
	return 0
	
def controlla(self,index,i):
	#non controllo se sono tutti uguali a seme, lo sono sicuramente
	if i == 0: #orizzontale
		riga = index-index%3
		return self.short_check(riga,1)
	if (i==1): #verticale
		colonna = index%3
		return self.short_check(colonna,3)
	if (i==2): #diagonale principale
		if index not in [0,4,8]:
			return 0
		return self.short_check(0,4)
	if (i==3): #diagonale secondaria
		if index not in [2,4,6]:
			return 0
		return self.short_check(2,2)			


def vittoria(self,risultato):
	self.partita = 2
	self.can_play = False
	if risultato == 1:
		print "Hai Vinto!"
	else:
		print "Hai Perso!"
		
def patta(self):
	self.partita = 1
	self.can_play = False
	print "Patta"


def check_end(self,index):
	seme = self.mappa[index]
	win = 0
	for i in range(4):
		win+= self.controlla(index,i)
	if win>0:
		self.vittoria(seme)
		return
	if self.mosse == 9:
		self.patta()
		return
#per nuove partite
def resetta(self):
	self.partita = 0
	for i in self.mappa:
		self.mappa[i] = 0
	for i in self.oggetti:
		self.oggetti.remove(i)


if __name__ == "__main__":
os.environ["SDL_VIDEO_CENTERED"] = "1"
finestra = Tabellone()
finestra.run()

Il fulcro del gioco sta nel gestire il mouse:

#gestisce la pressione del mouse
def input(self,evento):
	GameWindow.input(self,evento)
	if self.partita:
		return
	if evento.type == MOUSEBUTTONDOWN and evento.button == 1:
		if not self.can_play:
			return 
		id = self.mouse.move(pygame.mouse.get_pos()).collidelist(self.rectList)
		if (id < 0):
			self.debug.mossa("Fuori",self.mosse)
			return
		if (id > 8):
			self.debug.fatal()
			return	
		if (self.mappa[id]):
			self.debug.mossa("Piena",self.mosse)
		else:
			self.debug.mossa("Dentro",self.mosse)
			#mossa giocatore
			self.muovi[0](id)
			#controllo se la partita e' finita	
			if self.partita:
				return
			#mossa computer
			self.muovi[1](id)

Spiegazioni

Prima di tutto chiamo la funzione che gestisce l'input ereditata dal padre (si occupa della chiusura di finestra se clicco sulla croce o schiaccio il tasto esc)

poi c'è un if che si "accende" se la partita è finita, è a carattere provvisorio, devo rielaborare in vista di più partite

Quindi inizia la gestione dell'evento, se rappresenta la pressione di un tasto del mouse e il bottone è quello sinistro analizza ulteriormente

se non è il mio turno esci

poi genero l'id con una formula magica

Praticamente ho creato una SDL_Rect di dimensione 1x1 che aggiorno con le coordinate attuali del mouse (al momento del click+)

Poi vedo se questa rect interseca altre SDL_Rect che ho immesso in una lista (definita nell'__init__)

Se ne interseca una (bisogna badare che prima di tutto queste non si intersechino) restituisce la posizione dell'indice della lista vista come array.

Controllo poi su un array se la casella corrispondente all'id è già piena

Se è vuota creo l'istanza puramente grafica ed aggiorno l'array, all'interno della funzione poi chiamo i metodi di controllo

Faccio muovere l'avversario e riattivo il controllo

NOTA

Applico un principio che per i giochi da tavolo è bene imparare, controllare le condizioni di vittoria solo quando esse si possono verificare, ovvero non ha senso controllare se la posizione è vinta ogni frame ma solo dopo che ciascuno ha mosso ed in particolare se qualcuno ha vinto è colui che ha mosso per ultimo (non vero per tutti i giochi da tavolo ma per la maggior parte)

Prima di iniziare a programmare un gioco quindi bisogna avere cura di carpirne le dinamiche e cercare un modello che funzioni anche solo su console e poi aggiungere le immagini (il tutto dipende dalla capacità e soprattutto dall'esperienza del programmatore, non c'è nulla di vergognarsi nel prendere un block notes e schizzare idee e stralci di codice, l'ho fatto per anni :D)

NOTA2

Data la semplicità del gioco ho ridotto l'oop all'essenziale, i puristi storceranno il naso ma mi sembrava esagerato creare altre classi, del resto si parla di un array di 9 caselle :)

NOTA3

Se avete incipit, commenti o bug non esitate a postare!

Sorgenti+Immagini: tris.zip

Edited October 27, 2008 by Keroro

PICCOLO · October 28, 2008

PICCOLO: bravo :) voglio vedere qualcosa di tuo!
stasera uppo il mio tris, magari ti puo' ispirare a riprendere a scriptare

Non aspettarti grandi cose: sono un informatico pigro e scadente :nana:

Appena ho tempo do un occhio anche al codice di rm2k.py.

Per ora ho guardato tris.py e, beh, ti invidio la capacità di saper scrivere codice così comprensibile :P

Visto che te hai fatto il tris, io ho provato ad imbarcarmi in qualcos'altro (ovviamente sfruttando quello che hai già fatto te, visto che sono un lurkone :P ).

Mi scuso in anticipo per la mancanza di commenti e di print per il debug >_

Visto che stavo cazzeggiando mi son completamente scordato di metterli (continuavo a cancellare e riposizionare linee di codice XD )...

Non ho ben capito perché ogni tanto si incasinano i tasti... probabilmente devo aver dato alla pygame.key.set_repeat dei valori troppo bassi (1,1): devo fare delle prove.

Per ora c'è solo il movimento, ma ancora non mi convince del tutto (più che altro visto che ridipingo ogni volta lo sfondo e penso vi sia una classe più adatta per gestire gli sprites >_> ).

Grafica fatta, in un attimo di professionalità, con paint.

Nel .rar ci sono i due file di Keroro finestra.py e immagine.py

ah, dimenticavo il brutterrimo codice (che appena posso amplio e commento >_

prova.py

#!/usr/bin/python
import pygame, sys
import finestra,immagine
from pygame.locals import *
from finestra import *
from immagine import *

class Sprite:
def __init__(self,schermo,sprite_name="aereo",trasp=(0,0,0)):
	loader = ImageLoader()
	self.img = loader.image_load(sprite_name)
	self.img.set_colorkey(trasp,RLEACCEL)
	self.img.convert()
	self.schermo = schermo
def draw(self,dest,frame):
	self.schermo.blit(self.img,dest,(frame*20,0,20,20))

class Game(GameWindow):
def __init__ (self,title="Paper-Plane",width=640,height=480):
	GameWindow.__init__(self,title,width,height)

	loader = ImageLoader()
	self.sfondo = loader.image_load("sfondo")
	self.eroe = Sprite(self.schermo)		

	self.game_running = True
	self.aereo_x = 320
	self.aereo_y = 240
	self.map_y = 1000
	self.frame = 0
	pygame.key.set_repeat(1,1)

def muovi(self,spost_x = 0,spost_y = 0):
	self.aereo_x += spost_x
	self.aereo_y += spost_y

def input(self,evento):
	GameWindow.input(self,evento)
	spost_x = 0
	spost_y = 0
	key_list = pygame.key.get_pressed()
	if (evento.type == KEYDOWN):
		if (key_list[K_UP] and self.aereo_y > 4):
			spost_y = -3
		if (key_list[K_DOWN] and self.aereo_y <456):
			spost_y = 3
		if (key_list[K_LEFT] and self.aereo_x > 4):
			spost_x = -3
			self.frame = 1
		if (key_list[K_RIGHT] and self.aereo_x <616):
			spost_x = 3
			self.frame = 2
	if (not key_list[K_LEFT] and not key_list[K_RIGHT]):
		self.frame = 0
	self.muovi(spost_x,spost_y)

def draw(self):
	if (self.map_y > 0):
		self.map_y -= 1
	self.schermo.blit(self.sfondo,(0,0),(0,self.map_y,640,480))
	self.eroe.draw((self.aereo_x,self.aereo_y),self.frame)

if __name__ == "__main__":
finestra = Game()
finestra.run()

Spero arrivi qualcun altro interessato :ahsi:

Bon Suar!

PS:

E' che la somiglianza tra la sintassi di C e quella di Java e la somiglianza tra la semantica di Java e quella di Ruby, mi sta facendo scrivere erorri stupidi. Non li cito neanche che mi vergogno, comunque spesso fondo i linguaggi.. ;O;

Fatti confondere le idee :sisi:

Io sono uno che segue fin troppo alla lettera la regola dell'RTFM: Read The Fucking Manual.

Senza manuale o appunti con la sintassi non riesco a scrivere "Hello World!" in Turbo-Pascal XD

aereo.rar

Edited October 28, 2008 by PICCOLO

Keroro · October 29, 2008

Uh del codice :D

Considera che all'inizio scrivo tutto di getto e faccio un accrocchio procedurale

Poi quando mi accorgo che c'è del codice ripetuto o ho ben definito le fasi di gioco condenso tutto in funzioncine

Infine sapendo che poi dovevo farlo leggere ho cercato di abbellirlo il più possibile per renderlo comprensibile :)

Per farlo, una volta fatta una demo funzionante finisco il design dell'applicazione (per un gioco 2d si può fare così, per uno 3d e molto complesso conviene prima ultimare il design).

Mi sono posto l'obiettivo classico: funzioni (in questo caso metodi) che non superino le 20 righe di codice

pygame.key.set_repeat(delay, interval)

delay è il tempo di attivazione del repeat, in millisecondi

interval è l'intervallo tra gli eventi ripetuti, in millisecondi

E' chiaro che se usi 1 a delay ti spamma gli eventi :D

a mio parere puoi provare qulacosa come pygame.key.set_repeat(20,15)

Non mi piace però la chiamata di pygame.key.get_pressed(), sei già all'interno della funzione che gestisce un singolo evento, non ha senso e non ti serve leggere anche le altre keys.

ti conviene quindi fare un array locale

self.tasti = []
for i in range(4):
self.tasti.append(False)

def input....
if (evento.type == KEYDOWN):
	if (evento.key == K_UP and self.aereo_y > 4):
		spost_y = -3
		self.tasti[0] = True
	#ecc...
	if (not (self.tasti[2] and self.tasti[3])):
		self.frame = 0
elif (evento.type == KEYUP):
	if (evento.key == K_UP): self.tasti[0] = False
	#ecc

Un'altra cosa che non mi è piaciuta è l'applicare la trasparenza dopo il caricamento che già chiamava la funzione convert, questo però è un mio errore di design dell'ImageLoader in quanto l'image preprocessing si usa spesso (entro stanotte posto qualcosa di meglio, pensavo ad un metodo di filtro personalizzabile oppure restituisco la surface non convertita)

Il difetto principale è che su linux lo sfondo mi lagga un pochino e la cosa non migliora a schermo intero e surfaces hardware, devo informarmi sul motivo, ma il mio obiettivo finale è di fare delle classi che embeddano le opengl quindi dovrebbe tutto scorrere meglio :)

PICCOLO · October 29, 2008

Considera che all'inizio scrivo tutto di getto e faccio un accrocchio procedurale
Poi quando mi accorgo che c'è del codice ripetuto o ho ben definito le fasi di gioco condenso tutto in funzioncine
Infine sapendo che poi dovevo farlo leggere ho cercato di abbellirlo il più possibile per renderlo comprensibile :)

Almeno in questo mi ci rivedo XD

if (evento.type == KEYDOWN):
	if (evento.key == K_UP and self.aereo_y > 4):
		spost_y = -3
		self.tasti[0] = True
	#ecc...

Era quello che avevo fatto inizialmente, ma mi dava problemi: mi prendeva un solo tasto direzionale per volta.

Ora riprovo (il codice l'ho cambiato e ricambiato, magari il problema era un altro e non me n'ero accorto... anche se sono convinto fosse uguale a quello che hai postato), ma pygame.key.get_pressed() l'avevo chiamata apposta per questo problema.

Giustamente però il controllo evento.type == KEYDOWN diventa inutile se chiamo la .get_pressed (non ricordo perché l'ho rimesso dopo averlo tolto >_

Un'altra cosa che non mi è piaciuta è l'applicare la trasparenza dopo il caricamento che già chiamava la funzione convert, questo però è un mio errore di design dell'ImageLoader in quanto l'image preprocessing si usa spesso (entro stanotte posto qualcosa di meglio, pensavo ad un metodo di filtro personalizzabile oppure restituisco la surface non convertita)

No, no, sono un pirla io: dovevo crearmi una mia ImageLoader derivata dalla tua e sovrascrivere i metodi (o farne direttamente una nuova gestendo la trasparenza... anche se tenere anche i metodi "lisci" può essere utile in certi casi suppongo).

Stamattina (invece che seguire Calcolo Probabilità e Statistica :nana: ) ho messo a posto un po' la classe Sprite, rendendola più parametrica: l'idea è di poterla utilizzare sia per l'aereo/eroe che per i nemici che per gli spari.

Ho avuto invece un po' di problemi mentre cercavo di sovrascrivere la .run di finestra (Game deriva da GameWindow) visto che mi dava un problema di indentazione inesistente: lo spostamento della mappa nel metodo draw non mi piace (per non dire "non ha senso"), ma per fare una prova è risultato funzionale; volevo però crearmi un metodo run specifico per il gioco.

Il difetto principale è che su linux lo sfondo mi lagga un pochino e la cosa non migliora a schermo intero e surfaces hardware, devo informarmi sul motivo, ma il mio obiettivo finale è di fare delle classi che embeddano le opengl quindi dovrebbe tutto scorrere meglio :)

E' la prima volta che provo a fare qualcosa di grafico (perlomeno di questo tipo): ridipingo ogni volta il pezzo dell'immagine di sfondo che mi serve... Probabilmente c'è un metodo più rapido ma non l'ho ancora visto, devo cercare.

Edited October 29, 2008 by PICCOLO

Keroro · October 30, 2008

L'esigenza di una run personalizzato è perché probabilmente non ho ben commentato la classe GameWindow, per me l'update delle variabili di gioco è inteso nella prima parte del draw, come è mostrato in rm2k.py (chiamo la funzione step per continuità con gamemaker :D)

Perché quindi hai tutti quei casini?

L'errore è subdolo... Sono stato un pirla a non accorgermene subito:

chiami self.muovi(spost_x,spost_y) nel metodo input e ciò ti costringe a generare eventi input per continuare a farlo muovere.

La soluzione non è rivolgersi a set repeat ma quella di raffinare ulteriormente il sistema che ti avevo proposto con le boolean e fare un metodo che muova l'oggetto ad ogni frame, di conseguenza anche il check se è possibile muoversi non va fatto sul keyinput dove imposti il vettore velocità ma frame per frame dove sommi la velocità

Mi sono quindi permesso di riscrivere l'esempio, in primis per togliermi la lag XD, poi perché sono sicuro ne beneficerai nonostante l'atto che per alcuni può essere considerato pari di una violenza sessuale (per me era così xD), e ne beneficerò anch'io in quanto i movimenti pixel based sono all'ordine del giorno

modifica importante: con il colorkey anche allo sfondo, pygame ha meno cose da copiare a runtime perché per mostrare il nero self.schermo.fill(0x000000) è sicuramente la via più ottimizzata (è un memcpy)

nota1: odio i nomi spost_x e spost_y XD ma ho rispettato la tua scelta (in rm2k.py vedi l'uso di hspeed e vspeed =D)

ho reso il tutto un po' più comprensibile ed object oriented,

nota2: è ovvio che il codice funge solo da suggerimento/guida, sei tu che devi scegliere come implementare e sei libero di stravolgerlo a piacimento, del resto è un tuo progetto

#!/usr/bin/python
import pygame, sys
import finestra,immagine
from pygame.locals import *
from finestra import *
from immagine import *

class MyImageLoader(ImageLoader):
def image_load(self,name,trasp=(0,0,0)):
	img_name = self.image_path(name)
	try:
		img = pygame.image.load(img_name)
	except pygame.error:
		raise SystemExit, 'Impossibile caricare "%s" %s'%(img_name, pygame.get_error())
	img.set_colorkey(trasp,RLEACCEL)
	return img.convert()

class Aereo:
def __init__(self,schermo,sprite):
	self.schermo = schermo
	self.sprite = sprite
	self.spost_x = 0
	self.spost_y = 0
	self.x = 320
	self.y = 240
	self.frame = 0
def set_frame(self,a):
	self.frame = a
def muovi(self):
	if (not self.spost_x and not self.spost_y):
		return
	if ((self.spost_y < 0 and self.y > 4) or (self.spost_y > 0 and self.y <456)):
		self.y +=self.spost_y	
	if ((self.spost_x <0 and self.x > 4) or (self.spost_x > 0 and self.x <616)):
		self.x +=self.spost_x
def draw(self):
	self.schermo.blit(self.sprite,(self.x,self.y),(self.frame*20,0,20,20))

class Background:
def __init__(self, schermo, sprite, y = 1000, scroll = -1):
	self.schermo = schermo
	self.sprite = sprite
	self.y = y
	self.scroll = scroll
def draw(self):
	if (self.y > 0):
		self.y += self.scroll
	self.schermo.fill(0x000000)
	self.schermo.blit(self.sprite,(0,0),(0,self.y,640,480))


class Game(GameWindow):
def __init__ (self,title="Paper-Plane",width=640,height=480):
	GameWindow.__init__(self,title,width,height)
	#preferisco caricare le immagini da qui e non all'interno delle classi
	#perche' potrei usare la stessa immagine per piu' oggetti
	loader = MyImageLoader()
	self.sfondo = Background(self.schermo,loader.image_load("sfondo"))
	self.aereo = Aereo(self.schermo,loader.image_load("aereo"))

	self.tasti = []
	for i in range(4):
		self.tasti.append(0)
	self.nome_tasti = [K_UP,K_DOWN,K_LEFT,K_RIGHT]

def input(self,evento):
	GameWindow.input(self,evento)
	if (evento.type == KEYDOWN):
		if (evento.key not in self.nome_tasti):
			return
		if (evento.key == K_UP):
			self.aereo.spost_y = -3
			self.tasti[0] = True
		elif (evento.key == K_DOWN):
			self.aereo.spost_y = 3
			self.tasti[1] = True
		if (evento.key == K_LEFT ):
			self.aereo.spost_x = -3
			self.aereo.set_frame(1)
			self.tasti[2]= True
		elif (evento.key == K_RIGHT):
			self.aereo.spost_x = 3
			self.aereo.set_frame(2)
			self.tasti[3] = True
	elif (evento.type == KEYUP):
		if (evento.key not in self.nome_tasti):
			return
		if (evento.key == K_UP and self.aereo.spost_y <0):
			self.aereo.spost_y = 0
			self.tasti[0] = False
		if (evento.key == K_DOWN and self.aereo.spost_y >0):
			self.aereo.spost_y = 0
			self.tasti[1] = False
		if (evento.key == K_LEFT and self.aereo.spost_x < 0):
			self.aereo.spost_x = 0
			self.tasti[2]= False
			self.aereo.set_frame(0)
		if (evento.key == K_RIGHT and self.aereo.spost_x > 0):
			self.aereo.spost_x = 0
			self.tasti[3] = False
			self.aereo.set_frame(0)

def draw(self):
	#update
	self.aereo.muovi()
	#draw
	self.sfondo.draw()
	self.aereo.draw()


if __name__ == "__main__":
finestra = Game()
finestra.run()

Allego il sorgente perché il tag [ code ] converte le tabulazioni in spazi ed è scomodo:

prova.py.zip

Edited October 30, 2008 by Keroro

Keroro · October 30, 2008

V 006: Usare i font TTF

font.py

#!/usr/bin/python
import finestra
import pygame, os
from pygame.locals import *
from finestra import *

class FontMGR:
f_path = "font"
ext = ".ttf"
def __init__(self,schermo):
	if not pygame.font:
		raise SystemExit, "Spiacente, e' necessaria la libreria SDL_font!"
	pygame.font.init()
	self.schermo = schermo
	self.font_list = []
def font_path(self,name):
	return os.path.join(self.f_path,name+self.ext)
def font_load(self,name,size):
	f_name = self.font_path(name)
	try:
		self.font_list.append(pygame.font.Font(f_name,size))
	except pygame.error:
		raise SystemExit, 'Impossibile caricare "%s" %s'%(f_name, pygame.get_error())
	return len(self.font_list)-1
def text(self,font_id,testo,colore):
	return self.font_list[font_id].render(testo,True,colore)
def draw_text(self,x,y,testo):
	self.schermo.blit(testo,(x,y))
	
class FontViewer(GameWindow):
def __init__(self,title="Font Viewer",width=640,height=480):
	GameWindow.__init__(self,title,width,height)
	self.fontmgr = FontMGR(self.schermo)
	font_id = self.fontmgr.font_load("base",48)
	self.ciao = self.fontmgr.text(font_id,"Ciao Mondo!",(105,200,0))
	self.inc = 0x000000
def draw(self):
	self.inc +=0x1
	if (self.inc > 0x300):
		self.inc = 0
	self.schermo.fill(self.inc)
	self.fontmgr.draw_text(20,30,self.ciao)


if __name__ == "__main__":
finestra = FontViewer()
finestra.run()

Short Documentation

font_load: Carica un font dalla cartella specificando nome e dimensione e restituisce l'id (un numero naturale)

text: Genera una nuova surface con il font id, il testo e il colore

draw_text: disegna la surface alla posizione x e y, ma è equivalente a blittarla direttamente sullo schermo, utile per veloci prototipi

font.zip

PICCOLO · November 4, 2008

Scusa se non ho risposto subito ma non ho più avuto tempo di mettermi all'opera >_

Grazie comunque per la risposta!

Allora:

L'esigenza di una run personalizzato è perché probabilmente non ho ben commentato la classe GameWindow, per me l'update delle variabili di gioco è inteso nella prima parte del draw, come è mostrato in rm2k.py (chiamo la funzione step per continuità con gamemaker :D)

Si, l'avevo immaginato :rovatfl: (non subito, ma l'avevo immaginato :D ).

Alla fine il problema è una pura questione di nome: per me un metodo Draw ha una funzione ben specifica, ovvero quella di disegnare.

Dal mio punto di vista dovrebbe accadere il contrario (una funzione Step che richiama la funzione Draw), ma essendo una semplice questione di nome mi cambia poco. La run personalizzata infatti era più per questioni di prova che reale necessità (anche se, ovviamente, il tutto era partito dal non aver interpretato correttamente il codice iniziale).

Perché quindi hai tutti quei casini?
L'errore è subdolo... Sono stato un pirla a non accorgermene subito:
chiami self.muovi(spost_x,spost_y) nel metodo input e ciò ti costringe a generare eventi input per continuare a farlo muovere.

:o

Vero! Mi ero premurato di richiamare la self.muovi anche senza che vi fossero tasti premuti, ma mi ero dimenticato che la input non viene chiamata ad ogni frame >_

Mi sono quindi permesso di riscrivere l'esempio, in primis per togliermi la lag XD, poi perché sono sicuro ne beneficerai nonostante l'atto che per alcuni può essere considerato pari di una violenza sessuale (per me era così xD), e ne beneficerò anch'io in quanto i movimenti pixel based sono all'ordine del giorno

Naa, niente violenza sessuale :D

Perlomeno non finché sto ancora giochicchiando >:D

Grazie per il codice: lo sto guardando ora e vedo già parecchi miglioramenti :sisi:

E grazie anche per la dritta sul fattore sfondo :wink:

Bella la font.py :sisi:

Tralaltro mi ha fatto venire in mente un'idea (un'idea banale, ma sempre idea è :P )... Chissà se trovo il tempo...

(mmmh... ma si che lo trovo...)

Keep up the good work :Ok:

PS: spost_x e spost_y non piacciono neanche me :P

Però non mi piacciono neanche hspeed e vspeed (semplice abitudine mia a pensare in termini di x e y piuttosto che di horizontal e vertical): penso che opterò per la via di mezzo x_speed e y_speed XD

Edited November 4, 2008 by PICCOLO

Keroro · November 5, 2008

Sto progettando di mettere le classi in un file unico che fungerà da libreria (devo trovare un nome) e creare un map editor ibrido tra rpg maker e game maker con le tk

Per quanto riguarda il codice, ci ho riflettuto su e ho pensato a diverse migliorie:

Inserire update() in game window, la libreria è fatta per essere semplice da usare e ci sono dei benefici nel separare il processing delle variabili dal draw (primo fra tutti, poter in un secondo momento passare alle opengl), anche per chiarezza verso gli utilizzatori diretti e tramite la futura gui :)
```
def run(self):
	clock = pygame.time.Clock()
	while (self.__class__.game_running):
		clock.tick(60)
		for evento in pygame.event.get():
			self.input(evento)
		self.update()
		self.draw()
		pygame.display.flip()
	self.game_end()	
def update(self):
	pass
```
(identato da schifo)
Libreria font.py: Non ha senso passare la surface su cui disegnare alla creazione del manager, si può benissimo chiamarla in draw in modo che sia flessibile
```
def draw_text(self,x,y,testo,schermo):
	schermo.blit(testo,(x,y))
```
Novità riguardanti la gestione di mouse e tasti

mikb89 · November 20, 2008

io mi intrufolo perchè ho scoperto che in python posso programmare anche sul cellulare dato che c'è l'interprete per symbian. come posso provo se pygame ci funziona anche se mi sa molto difficile.

volevo chiedere alcune cose:

1) non ho trovato "end", funzioni, classi, cicli, condizioni funzionano solo a indentazioni? e se si, devono essere tabulazioni o spazi? e quanti devono essere per ogni indentazione?

2) prendendone uno a caso

import finestra
from finestra import *

"*" significa "tutto"? e che differenza c'è fra le due righe?

sono tante domande, non ho mai toccato python. ringrazio anticipatamente^^

Keroro · November 28, 2008

l'indentazione è quella che vuoi tu

con import per usare le classi devi usare finestra.nomeclasse

con from ... import * importi tutto nel tuo namespace, quindi puoi usare nomeclasse

Comunque quelle sono vecchie versioni, adesso sono andato avanti ma devo ancora decidere in che direzione andare e che obiettivo pormi prima di rilasciare la nuova versione..

Thomas · November 28, 2008

Deve essere carino...comuncue si legge con la e legermente simile alla A, quasi "EA" Edited November 28, 2008 by Thomas

Thomas · November 28, 2008

Deve essere carino...comuncue si legge con la e legermente simile alla A, quasi "EA" Edited November 28, 2008 by Thomas

mikb89 · November 28, 2008

capito, ti ringrazio ^^

HitCAT · March 25, 2016

Caspita, era un bel post... solamente risale al 2008... XD

C'è ancora qualcuno che bazzica con le pygame oltre a me? :cool:

Sign In

Pygame

Question

Link to comment

Share on other sites

24 answers to this question

Recommended Posts

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Create an account or sign in to comment

Create an account

Sign in