Struttura di "Solitario"

[amivaleo]

Ciao a tutti,

avrei intenzione di creare un programma "copia" di Solitario (come quello di windows).

Non ho però la minima idea di come strutturare il programma.

Facendo una sintesi brutale, la creazione di un programma è divisa in due parti: (1)progettazione in linguaggio semi-informatico e (2)stesura in linguaggio di progetto. Io non riesco nemmeno ad abbozzare la progettazione nella prima fase.

Vi chiedo, quindi, di dirmi/passarmi un'idea di come funzioni il programma o il listato con un linguaggio di progetto ad oggetti.

Badate che non vi sto chiedendo di descrivermi quello che "vedete" quando giocate a solitario, messaggi di questo tipo: "devi mettere 28 carte in 7 colonne e le restanti in un mazzo" non mi servono. Ho bisogno di sapere com'è la struttura del programma in termini di array, variabili, etc.

 

... mi rendo conto della richiesta assurda che potrebbe farvi dire "ma che ca**o lo fa a fare?", ma... beh, è un mio progetto. Tutto qui. Solo che mi serve un strada da seguire per poterlo iniziare davvero.

[ProGM]

più che altro mi chiedo...

eh XD???

in che linguaggio? hai un minimo di conoscenza di applicazioni per desktop? esattamente cosa cerchi @_@?

[amivaleo]

rgss...

 

in realtà il programma finale sarà scritto con il lua, ma dato che il lua è molto simile all'rgss e qui l'rgss dovrebbe essere maggiormente noto...

va bene l'rgss o il c++, penso di potermela cavare pure col visual basic, ma ho molta meno esperienza in visual basic.

[DarkSchneider]

L unico oggetto che ti serve è per la carta e contiene numero, seme e un variabile booleana per indicare se la carta è scoperta poi crei 2 array uno per il mazzo da cui pescare e uno per i scarti; 4 array(o un matrice) per le carte riordinate e 7 array (o una matrice) per le colonne

 

La disposizione delle carte nel mazzo e nelle colonne le fai naturalmente con i numeri random passando carta per carta per ogni seme facendo attenzione a quelle che devi lasciare scoperte

 

il motore del gioco è semplice (credo) prendi una carta dal mazzo (l ultimo elemento dell array) lo sposti negli scarti (nella prima cella dell array scarti spostando altri eventuali elementi presenti di una cella) poi controlli le colonne: se si cerca di mettere la carta sotto un altra si scorre l array di quella colonna fino a trovare l ultima carta scoperta controlli seme e numero quindi aggiungi il primo elemento dell array scarti nella prima cella vuota dell array colonna oppure un suono di errore e rimane tutto invariato

 

spero di non averci lasciato nulla è il primo procedimento che mi è venuta in mente

Edited February 21, 2008 by DarkSchneider

[amivaleo]

ok, in linea di massima, ho capito.

ora non ho tempo per mettermi a programmare, probabilmente farò qualcosa questo weekend.

grazie per l'aiuto, vedrò se funziona e se riesco a tradurla in "luese"

[Keroro]

al massimo in "luano", il trans della 13° strada XD

all'inizio quando ho letto il titolo Solitario ho pensato ad un topic sul cinque contro uno XD

 

scrivo codice in C/C++

 

sono d'accordo per:

struct carta {
int valore;
char scoperta;
};

 

il valore è un numero da 0 a 51 (le carte da poker sono 52)

(per approfondimento sull'uso ho scritto in fondo)

 

ma usare 2 array, uno per il mazzo e uno per gli scarti è uno spreco perché ad ogni passo devi riscrivere, qui hai due scelte:

la prima (semplice, lineare, senza seghe mentali) è quella di usare due liste dinamiche, in questo modo il girare una carta diventa un semplice scambio di puntatori

la seconda è quella di usare un solo array affidandosi a ->scoperta, magari salvandosi in un int il valore

 

Io che trovo i puntatori facili facili e non voglio sbattermi implementerei la 1° con le liste orientate in modo che le carte più in alto del mazzo (la prima che peschi) e degli scarti (quella con cui puoi interagire) siano le teste di lista

 

struct nodo {
struct carta * card; //la chiamerei carta ma poi non sarebbe C++ compatibile
struct nodo * next;
};	

struct nodo * mazzo;
struct nodo * scarti;

void pesca(){
struct nodo * p,*q;

//se il mazzo è finito riavvolgo tutto
if (!mazzo) {
	mazzo = scarti;
	scarti = 0;
	p = mazzo->next;
	while (p){
		q = p->next;
		p->next = mazzo;
		mazzo = p;
		p = q;
	}
	return; //se si vuole che riavviando estragga anche la prima carta basta toglierlo
}
//pesco la carta
p = mazzo;
mazzo = mazzo->next;
p->next = scarti;
scarti = p;
}

 

per le colonne basta usare altre liste (nell'esempio le uso come variabili globali per non portarmele in giro nelle funzioni)

#define NUM_COLONNE 7
struct nodo * colonna[NUM_COLONNE]

per trovare il nodo della prima scoperta (per il trascinamento) (anche se andrebbe modificata per salvare anche l'ultimo nodo che rimarrà nella colonna di partenza per separare dopo la fusione)

struct nodo * prima_scoperta(int col){
struct nodo * p = colonna[col];
if (!p) return NULL;
while (p){
	if (p->card->scoperta) return p;
	p=p->next;
}
return NULL;
}

per trovare l'ultima scoperta (per l'aggancio) (per comodità chiamando la funzione su)

struct nodo * ultima_scoperta(int col){
struct nodo *p = prima_scoperta(col);
if (!p) return NULL;
while (p->next) p = p->next;
return p;
}

 

il seme della carta lo ritrovi con valore /13, il numero sulla carta è (valore %13+1), non serve neanche specificare l'esistenza di K Q J ( a meno che l'applicazione sia via console e non grafica).

Per l'ordine dei semi userei ROSSO-NERO-ROSSO-NERO così un semplice controllo se una carta può attaccarsi ad un altra si fa con

 

int can_cardcpy(struct nodo * quale,struct nodo * dove){ 
if ((quale->card->valore/13) %2 == (dove->card->valore/13) %2) return 0; //carte dello stesso colore
if ((quale->card->valore%13) == (dove->card->valore%13)-1) { //se è quello che viene dopo
	return 1;
}

 

poi naturalmente c'è la gestione delle carte per la vittoria ma è tutto molto banale ;)

[PICCOLO]

Il codice scritto da Keroro è fatto bene, però non ho capito l'utilità della lista scarti: se è come il solitario di windows gli scarti non servono a niente.

 

Tanto vale sfruttare fino in fondo il fatto che la lista è unidirezionale e scorrerla semplicemente utilizzando un puntatore apposito: quelle prima del puntatore sono quelle scartate, quelle dopo quelle coperte e quella puntata la carta corrente.

Così quando si arriva alla fine basta tornare all'inizio del mazzo ed è già in ordine.

O se proprio servisse la pila degli scarti (per una variante di gioco) metterla direttamente in ordine (ti eviti un ciclo :rovatfl: ).

 

(per carità, si parla di numeri talmente bassi che cambia praticamente niente, ma visto che gà si diceva che un'array di 52 elementi è uno spreco meglio essere pignoli fino in fondo ^^ )

[Testament]

sono d'accordo col sergente Keroro, l'utilizzo delle liste dinamiche (alla fine è una struttura a pila) è molto meglio di quello di semplici vettori. invece di ricompattare questi ultimi si tratta solo di fare un'operazione di taglia&cuci coi puntatori.

magri la complessità aumenta nel caso in cui invece di una singola carta se ne voglia spostare un gruppo prendendone una in mezzo ad una fila per spostare tutte quelle sotto incluse da un'altra parte (può essere utile per scoprire un seme che ci serve a parità di numero), ma mi pare che per una prima bozza c'è materiale a sufficienza.

[Keroro]

per essere pignoli fino in fondo allora ti rispondo

perché sono meglio due liste dinamiche piuttosto che una?

perché così per disegnare la carta non devi scorrere tutto (si, lo stesso risultato si ottiene con un puntatore ausiliario, ma del resto scarti cos'è :D?)

void disegna_mazzo(){
if (scarti) disegna(xs,ys,scarti->card);
if (mazzo) disegna(xm,ym,NULL); //NULL sta per carta girata
}

perché così quando usi la carta presente nella pila degli scarti sai subito quella che c'è sotto senza dover rifare un ciclo (visto che secondo la tua idea quelle già mostrate vengono prima)

 

immaginando destinazione = ultima_scoperta(N);

if (can_crdcpy(scarti,destinazione)) {
destinazione->next = scarti;
scarti = scarti->next;
}

 

con due liste dinamiche viene effettuato un ciclo while solo per il riordino del mazzo, operazione che nelle regole del solitario è concessa solo tre volte (modalità vegas 3 carte) o una volta (modalità vegas 1 carta) e che comunque si verifica meno frequentemente della pesca di una carta dal mazzo degli scarti ;)

 

spero di averti convinto che è la soluzione migliore, del resto se ho postato questo codice ieri è perché avevo già scartato la tua opzione. l'unica alternativa a due liste abbastanza efficiente sarebbe stata quella di utilizzare una lista double linked, ma questa a mio avviso spreca troppa memoria (ogni nodo conserva un puntatore in più, sono 1 puntatore * 52 carte - 1 puntatore a scarti byte in più, che su macchina a 32 bit sono 204 byte in più, una stupidaggine, ma poi mi tocca portarmi i nodi double linked in giro anche sulle colonne (dove il secondo puntatore è totalmente inutile) oppure riconvertirli in nodi single linked (ma spendo del tempo oltre che memoria))

 

 

nota: nelle funzioni manca ancora l'implementazione di possibilità di mettere K su colonna vuota ma sono dettagli, basta mettere un

if (p->card->valore %13 == 12 && !colonna[i] )

Edited February 22, 2008 by Keroro

[amivaleo]

O_O

 

... mostruoso!

raga, non ho capito niente...! mi son perso a metà del primo messaggio di keroro...

ma studiate informatica o siete amanti del 5 contro 1 citato da kero (e quindi smanettate molto sul pc)?... io non ho capito praticamente nulla...

vado a ripescare il mio libro sul C++...

[PICCOLO]

(si, lo stesso risultato si ottiene con un puntatore ausiliario, ma del resto scarti cos'è :D?)

 

No, ma il problema non era lo spazio di un puntatore (ci mancherebbe :rovatfl: ), era l'utilità di memorizzare gli scarti, ovvero: non mi ero mai accorto che si potessero rigiocare le carte tra gli scarti

Pensavo che finite le 3 pescate si potesse solo pescarne delle altre (non sono un gran giocatore di solitario o_ ).

 

Giusto a 2 liste a sto punto

[ragnarokM]

O_O

 

... mostruoso!

raga, non ho capito niente...! mi son perso a metà del primo messaggio di keroro...

ma studiate informatica o siete amanti del 5 contro 1 citato da kero (e quindi smanettate molto sul pc)?... io non ho capito praticamente nulla...

vado a ripescare il mio libro sul C++...

 

Se studi informatica sarà il tuo pane quotidiano

[amivaleo]

uhm... no...

sono un liceale "scienzista" a cui piace smanettare coi linguaggi di progetto... spesso non ottenendo mai grandi risultati...

per l'università... ingegneria edile! ARRIVOOOOOOOOOO!!!