Newsgroup: it.comp.lang.c++
Titolo: [1/2 OT] gioco in C++, usando le MFC

Va bene va bene,
lo so mi sottopongo alla vostra gogna, svergognandomi pubblicamente col mio
codice.
Ho scritto mezzo OT, perche' il programma in questione e' fatto col Visual
C++, usando le MFC.
Ma a me interessa il vostro parere sulla parte STL, dove ho usato le map, i
vectors per gestire al meglio le carte da gioco.
Ho pubblicato per hobby un giochino fatto con le MFC e con le STL in C++.
Andate a vedere qua:
http://www.codeproject.com/useritems/Italiangamecard.asp
Ditemi cosa ne pensate sia del gioco...(vabbe' lo so che non e' complicato),
sia soprattutto del codice.
Dove ho cannato di brutto e cosa avreste cambiato e se ci sono bachi.
Potete anche dare un voto e un giudizio direttamente nel sito, tanto non
guadagno nulla oltre che la gloria.
L'importante per me e' migliorare nella programmazione sia C++, sia di Win32
e MFC.
Poi magari potete anche pubblicarvi qualcosa anche voi, non solo giochi ma
anche piccole applicazioni.
E' un modo per far vedere il vostro codice, affinche' gli altri vi
suggeriscano come migliorare, ed anche un modo per migliorare gli altri che
chissa', potrebbero imparare da voi.
Grazie per l'attenzione e aspetto vostri suggerimenti e vostri link a
codici!
Maurus

 codici!
non si sa mai.....
Tommy


Con un po' di tempo libero e impegno, vedrai che poi pubblichi qualcosa
anche tu e rimpolpiamo la squadra italiana.
Maurus

m_CardMap[(i/10 << 8) | ((i%10)+1)] = gpPic[i];
Fra due giorni incominciero' nuovamente ad avere tempo e .... magari mi ci
faccio anche delle partitine!!!! ;-)
Tommy

 Tommy
Ciao Tommy,
innanzitutto ti ringrazio per l'interesse e per la tua domanda che mi ero
posto anche io.
Ti spiego in breve il problema che mi ha fatto optare per map piuttosto che
per altri tipi di contenitori.
Allora, ogni carta e' individuata univocamente dal valore e dal seme (2 di
picche per esempio di una carta famosa!)
La funzione random mette tutte le carte nel mazzo che e' un vector di
puntatori a oggetti di tipo Card, facendo uno swap degli indici.
A questo punto pescare dal mazzo e' semplice, perche' basta utilizzare un
indice che va consecutivamente a prendere una ad una le carte nel vettore.
Ho voluto separare i files propriamente standard di C++, da quelli legati
alla visualizzazione grafica che fanno uso delle MFC, per cui non ho voluto
mettere riferimenti a bitmap nella classe Card.
Per cui una volta pescata la carta, voglio passare le sue informazioni alla
dialog box che dovra' visualizzarmela.
Ma ora ho bisogno di abbinare la carta all'immagine da visualizzare, per cui
ho da "mappare" il codice unico legato alla carta, al puntatore alla bitmap
che le corrisponde.
Per questo la map mi e' sembrata la scelta piu' naturale, anche perche' una
volta calcolato il codice chiave della carta (basta passare la carta a una
funzione che ne combina i 2 campi: valore e seme), basta fare una find sulla
map ed ottengo il puntatore alla bitmap che uso per visualizzarla.
Eccoti un esempio:
int idCard = card.GetIdCard();
// Qui la card ha un metodo per ricavarne l'identificativo chiave unico
// e lo metto in idCard
m_itMyCard = m_CardMap.find(idCard);
// qui m_itMyCard e' un puntatore a bitmap (o jpeg non importa)
// e mediante l'algoritmo find delle map, passandogli il codice chiave
primaria
// ottengo il secondo campo della map che gli corrisponde
// e ci carico il puntatore alla bitmap.
Con array o vettori, sarebbe stata piu' macchinosa questa cosa, o almeno non
so come si possa fare in modo semplice.
Ricordati che il mio scopo e' mappare l'oggetto carta alla sua immagine (bmp
o jpeg) e un vincolo e' che non voglio che nella classe Card vi siano
riferimenti o puntatori a bitmap, in quanto vorrei separare la parte
standard C++ dalla parte dipendente dalla piattaforma e dalla grafica.
Dimmi pure se ho chiarito i tuoi dubbi o se pensi che si possa fare in un
altro modo.
Grazie
Maurus

 puntatori a oggetti di tipo Card, facendo uno swap degli indici.
Per il fatto di mischiare le carte.... crei un array di 40 puntatori ad
oggetti win32_card. (puntatori in quanto tu stesso hai detto di usare un
vettore di puntatori), per ognuno crei un oggetto carta inizializzando
(passando al costruttore) il  numero della carta e il puntatore alla bitmap.
Essendo tutto cio' in un ciclo ripetuto 40 volte:
for(i=0;i<40;++i){
    pBitmap=GetBitmapForCardNumber(i);  // funzione e tipo diversi per ogni
piattaforma
    array_di_pCarte[i]=new win32_card(i,pBitmap);
}
Ok, fatto, hai il tuo array di puntatore a win32_card (ordinati).
A questo punto mischialo come vuoi. e puoi sempre usare:
int idCard=card.GetIdCard();
m_itMyCard = card.GetPointerBlaBlaBla();
Mah, ho steso in 2 minuti la base, ovvio che cosi' come ti ho detto magari
non funziona e bisogna ri-arrangiarlo!
Ad ogni modo a meno che uno non abbia in testa il pallino della portabilita'
questo e' un lavoraccio che si puo' evitare ed uno dei modi per evitarlo e'
di fare come hai fatto tu!
Rimango in attesa di fare una partitina con il tuo gioco ;-)
(ti sapro' dire i risultati ;-)
Tommy

 di fare come hai fatto tu!
Immagino che per un gioco di questo tipo, avendo il pallino della
portabilita', Java sarebbe una scelta piu' adatta.
Tommy
P.S. non mi piace java, ma visto che va ovunque, se quello fosse lo
scopo.... (scopo che ho supposto io, sicuramente non e' il tuo scopo!).

 (ti sapro' dire i risultati ;-)
Ho sempre perso!
Maurus

Tommy wrote:

dato che siamo già OT, posso segnalare la presenza di librerie grafiche come
l'SDL,
che permette di utilizzare grafica e compilare su più piattaforme senza
alcuna
modifica al codice o l'utilizzo di classi separate come hai fatto tu con
linux_card
e win32_card.
--
Andrea Spadaccini - Catania (Italy)
Mail: _
lupin85...@libero.it
ICQ#: 91528290
 - It is not important what you believe, only that you believe -