• Random: questo esempio sfrutta la gestione degli eventi in Javascript per catturare il click del mouse e disegnare sul context delle forme quali cerchi o quadrati; sfrutta il costrutto rgba() e la codifica in base64 messa a disposizione da .toDataURL();
• Canvas e Circle invece mostrano alcune delle funzioni base dell’elemento canvas unite a tecniche molto semplice di grafica 2D.

Simboli speciali
.     Indica un solo carattere di qualunque tipo ma non un carattere di newline (\n)
^     L'inizio di una linea/sequenza
$     La fine di uan linea/sequenza
*     Zero o più caratteri di qualunque tipo
+     Uno o più caratteri di qualunque tipo
?     Zero o un carattere di qualunque tipo
\n    Carattere di nuova linea
\t    Carattere di tabulazione
\s    Qualunque carattere di spazio, tabulazione, newline...
\w    Qualunque carattere alfanumerico (quindi qualunque carattere da 0~9 e da a~zA~Z)
\W    La negazione di \w
\d    Qualunque carattere numerico (quindi qualunque carattere da 0~9)
\D    La negazione di \d

Si possono creare dei pattern utilizzando le parentesi tonde () e la pipe | rappresentate l'unione (OR)
(ae)            Individua la stringa "ae"
(a|e)lollo      Individua la stringa "alollo" O la stringa "elollo"
(a|e+)lollo     Individua la stringa "alollo" O le stringhe "elollo", "eelollo", "eeelollo" etc...

#!/usr/bin/perl

my $in = open IN, "< text2.txt" or die "CANNOT";
@_ = <IN>;

if($in) {
 foreach (@_) {
 # /Piove.*assurdo/

 # /ho +le/i
 # cerca il pattern che inizia con 'ho', che continua con almeno 1 spazio e subito dopo 'le'

 # /in ?(.*)/i
 # cerca il pattern che inizia con 'in' e che può avere o non può avere
 # uno spazio subito dopo e continua con qualsiasi cosa

 # /(.)\1/i
 # cerca il pattern che contiene un qualsiasi carattere e che subito dopo
 # ha lo stesso carattere (\1 = ripetere l'elemento contenuto
 # nella parentesi numero 1; in questo caso, cerca le doppie)

 # /(.)(.)\2\1/i
 # cerca un pattern palindromo! abbiamo due caratteri (.)(.):
 # \2 significa che dobbiam trovare un pattern dove il carattere nella seconda parentesi
 # si ripete;
 # \1 significa che subito dopo la ripetizione della seconda parentesi si deve ripetere
 # il carattere nella prima parentesi
 # ESEMPIO: stringa ABBA
 # (.)(.) INDICA I NOSTRI PRIMI DUE CARATTERI: AB
 # \2 INDICA CHE IL CARATTERE B SI DEVE RIPETERE: ABB
 # \1 INDICA CHE IL CARATTERE A SI DEVE RIPETERE: ABBA

 # /(\w+):\s)/
 # cerca il pattern con una stringa prima del carattere : e subito dopo uno spazio;
 # la peculiarit di questo esempio è che la stringa prima del carattere sarà memorizzata in $1

 # /(\d)+\s?(?:\+|\-)\s?i\*?(\d)+/i
 # riconosce i numeri complessi nella forma: x+iy, x + iy o i*y

 if(/(\d)+\s?(?:\+|\-)\s?i\*?(\d)+/i) {
     print "OK\n";
     print "it matches on: " . $_ . "\n";
     print "the variable was: $1 and $2\n";
 }
 }

} else {
 print "DEAD";
}

close(IN);

Traccia:

Costruire il gioco dell’impiccato. La parola da indovinare è data in input ed il numero di tentativi è fissato a 6. Inoltre, ad ogni tentativo, dovrà essere stampato il risultato parziale, dove nel caso in cui la lettera non sia ancora stata “indovinata” dovrà essere stampato il carattere ‘ – ‘.

#include <iostream>
using namespace std;

char input[1000];
int size=-1;
char lettura;
bool indovinati[1000]={0};
int tentativi=6;

bool presente(char input[], char lettura, int size, bool ind[]);

int main()
{
	cout<<"Dammi parola terminata da '-'"<<endl;
	cin>>lettura;

	while(lettura != '-')
	{	
		size++;
		input[size]=lettura;
		cin>>lettura;
	}
	if(size==-1)
		return 0;

	for(int i=0; i<=size; i++)
		cout<<" - ";
		
	cout<<endl;
	cout<<"Dammi lettura"<<endl;
	cin>>lettura;
	while(tentativi != 0)
	{
		if(presente(input,lettura,size,indovinati))
		{
			for(int i=0; i<=size; i++)
			{
				if(indovinati[i])
					cout<<input[i]<<" ";
				else
					cout<<" - ";
			}
			cout<<endl;

		}
		else
		{
			tentativi--;
			cout<<"Tentativi rimamenti"<<tentativi<<endl;
		}
		bool b=true;
		for(int i=0; i<=size; i++)
		{
			if(!indovinati[i])
			{
				i=size+1;
				b=false;
			}
		}
		if(b)
		{
			cout<<"Hai indovinato"<<endl;
			return 0;
		}
		cin>>lettura;
		
	}
	cout<<"HAI PERSO"<<endl;
	return 0;

	
}

bool presente(char input[], char lettura, int size, bool ind[])
{

	bool done=false;
	for(int i=0; i<=size; i++)
		if(input[i]==lettura)
		{
			ind[i]=true;
			done=true;
		}
	return done;
}

Scarica l’articolo

Per questo tipo di problemi ritengo molto più semplice utilizzare un linguaggio di scripting, magari leggero, semplice e tipizzato dinamicamente. La mia scelta, questa volta, è ricaduta su Python e sulla libreria PIL (Python Imaging Library): con qualche riga di codice e un po’ di prove, il lavoro era praticamente svolto.

Vediamo insieme come svolgere un’operazione del genere.

import Image
import os
import subprocess
import string
from string import Template

def menu():
    subprocess.Popen([r"clear"]).wait()
    print '=' * 25
    print "PY-MANIPULATOR; PLEASE ENTER A COMMAND"
    print '=' * 25

def processing(operation, path, value):
    i = 1

    if( not os.path.isdir("redim") ):
       os.mkdir("redim")

    convertTemplate = Template('redim/$index.jpg')

    for infile in os.listdir(path):
        try:
            # apro l'immagine
            img = Image.open(path + infile)

            # operazione di conversione
            if(operation == "convert"):
                # prendo la dimensione
                w, h = img.size
                # converto del value%
                resize_w = (w * int(value)) / 100
                resize_h = (h * int(value)) / 100
                # safe operation
                w = w - resize_w
                h = h - resize_h
                print "CONVERTING -> ", infile
                # resize
                img = img.resize((w,h), Image.ANTIALIAS)
                img.save(convertTemplate.substitute(index=i))

            # incremento il valore progressivo
            i = i+1

        except IOError:
            pass

def parseInput():
    checked = False
    s = raw_input(">> ")

    while(not checked):
        # parso la stringa in una lista
        l = string.split(s)

        # leggo il comando (primo elemento)
        if( l[0] == "convert" ):
            processing(l[0],l[1],l[2])
            checked = True
        elif( s == '1' ):
            print "EXIT -1"
            exit(-1)
        else:
            print "INVALID COMMAND; PLEASE RETRY OR TYPE 1 TO EXIT"
            s = raw_input(">> ")

# main
menu()
parseInput()

Analizziamo un po’ il codice (tra parentesi la riga di codice corrispondente alla spiegazione):
(01~05) importiamo un po’ di librerie utili: Image è la libreria di riferimento per la manipolazione delle immagini; os, subprocess, string fanno parte della libreria ufficiale del linguaggio e ci permettono tra le altre cose di interagire con il sistema operativo, di manipolare i processi e le stringhe.
(08) grazie alla libreria subprocess possiamo usare la funzione membro Popen(proc) per avviare un processo a nostra scelta (in questo caso avvio clear semplicemente per eliminare dalla shell qualunque cosa presente prima dell’avvio del nostro script).
(16) la funzione os.path.isdir(d) ritorna vero se d è una directory. In questo caso, controllo se redim è stata già creata; in caso contrario, la funzione os.mkdir(d) la crea nella directory corrente di lavoro (riga 17).
(19) la classe Template della libreria string è una classe che permette una manipolazione di stringhe a livello di end-user, aumentando esponenzialmente la versatilità di uno programma. In questo esempio, prepariamo un template “/redim/$index.jpg”. Scopo di questo template sarà quello di dare un path e un nome ad ogni immagine che convertiremo. $index è un parametro speciale che verrà sostituito ogni volta con un valore incrementale (0, 1, …) o con un qualunque valore letterale.
(24) leggendo tutti i file (riga 21) presenti nella cartella path, cerco di aprire il corrente (infile) come un’immagine, tramite la funzione open(file) della libreria Image. Notiamo che siamo dentro un try e l’unica eccezione che potrà essere sollevata è una IOError se e solo se in questo punto non riusciamo a leggere il file come un’immagine (l’eccezione verrà catturata e semplicemente non faremo operazioni sul file, riga 44).
(29) questa dichiarazione può risultare un po’ dispersiva per alcuni utenti di linguaggi come C. In questo caso, il membro size dell’oggetto img è formato dai campi (width, height), rispettivamente larghezza e altezza dell’immagine in pixel, e assegnati alle variabili w e h.
(38) ridimensiono l’immagine dopo alcuni calcoli utilizzando la funzione resize(size, filter) la quale prende w e h, e una costante della classe Image, ANTIALIAS la quale indica l’effetto da applicare nel ridimensionamento dell’immagine (fate riferimento alla documentazione della libreria per maggiori informazioni).
(39) salviamo l’immagine nel percorso specificato nel nostro convertTemplate sostituendo a $index il valore corrente di i (quindi avremo redim/1.jpg, redim/2.jpg, …).
(47) dichiariamo la funzione parseInput() che servirà a gestire l’input dell’utente, nel formato comando path valoreDiRiduzione.

Ecco un esempio dello script e della sua esecuzione, nominato pmanip.py:

kalimdor:pizza finalfire$ ls
DSC_0091.JPG    DSC_0096.JPG    DSC_0099.JPG    DSC_0102.JPG
DSC_0095.JPG    DSC_0097.JPG    DSC_0100.JPG    pmanip.py
kalimdor:pizza finalfire$ python pmanip.py
=========================
PY-MANIPULATOR; PLEASE ENTER A COMMAND
=========================
>> convert ./ 60
CONVERTING ->  DSC_0091.JPG
CONVERTING ->  DSC_0095.JPG
CONVERTING ->  DSC_0096.JPG
CONVERTING ->  DSC_0097.JPG
CONVERTING ->  DSC_0099.JPG
CONVERTING ->  DSC_0100.JPG
CONVERTING ->  DSC_0102.JPG
kalimdor:pizza finalfire$ ls redim/
1.jpg    2.jpg    3.jpg    4.jpg    5.jpg    6.jpg    7.jpg

Per qualunque consiglio, critica, aiuto o informazioni sentitevi liberi di lasciare un commento!

Scarica l’articolo

Enjoy!

//Card.h

#ifndef CARD_H_

#define CARD_H_



#include <string>

using namespace std;



class Card{

	friend ostream& operator<<(ostream& out, Card& c);


public:

	Card(string s="", string n="", float v=0, float fv=0);

	void setSeed(string s);
	void setName(string n);

	void setValue(float v);
	void setFValue(float fv);

	void setFigure(bool f);

	void setMatta(bool m);

	void setValueMatta();

	bool isMatta();

	bool isFigure();

	string getSeed();
	string getName();

	float getValue();
	float getFValue();
	



private:

	string seed;
	string name;

	float value;
	float fValue;

	bool figure;

	bool matta;



};



#endif /* CARD_H_ */


//End of Card.h

//Card.cpp

#include "Card.h"

#include <iostream>

using namespace std;



Card::Card(string s, string n, float v, float fv)

	:figure(false),matta(false)

{

	seed=s;
	name=n;

	value=v;
	fValue=fv;



}



void Card::setSeed(string s)

{

	seed=s;



}


void Card::setName(string n)
{
	name=n;
}


void Card::setValue(float v)

{

	value=v;

}


void Card::setFValue(float fv)
{
	fValue=fv;
}


string Card::getSeed()

{

	return seed;

}

string Card::getName()
{
	return name;
}



float Card::getValue()

{

	return value;

}

float Card::getFValue()
{
	return fValue;
}



void Card::setFigure(bool f)

{

	figure=f;

}



bool Card::isFigure()

{

	return figure;

}



void Card::setMatta(bool m)

{

	matta=m;

}



bool Card::isMatta()

{

	return matta;

}



void Card::setValueMatta()

{

	float value;

	cin>>value;

        value=value;

}

ostream& operator<<(ostream& out, Card& c)
{
	//Name Seed Value FValue
	out<<c.getName()<<" "<<c.getSeed()<<" "<<endl;
	return out;
}

//End of Card.cpp

//Deck.h

#ifndef DECK_H_

#define DECK_H_



#define NUMCARDS 40



#include "Card.h"

#include <iostream>



using namespace std;



class Deck {



public:

	Deck();

	~Deck();

	Card& operator[](int x);

	void inizializeDeck();

	void inizializeFigures();
	void inizializeBriscola();

	void shuffleDeck();

	void inizializeMatta();



private:

	Card deck[NUMCARDS];



};



#endif /* DECK_H_ */


//End of Deck.h

//Deck.cpp

//Deck.cpp



#include "Deck.h"

#include <time.h>

#include <cstdlib>







Deck::Deck() {



	// TODO Auto-generated constructor stub



}



Deck::~Deck() {

	// TODO Auto-generated destructor stub

}



Card& Deck::operator[](int x)

{

	return deck[x];

}



void Deck::inizializeDeck()

{

	float x=1.0;



		for(int i=0; i<10; i++){

			deck[i].setSeed("Mazze");

			deck[i].setValue(x);
			deck[i].setFValue(x);

			x++;

			if(x>8.0)

				deck[i].setFigure(true);

		}



		x=1.0;



		for(int i=10; i<20; i++){

			deck[i].setSeed("Spade");

			deck[i].setValue(x);
			deck[i].setFValue(x);

			x++;

			if(x>8.0)

			deck[i].setFigure(true);

		}



		x=1.0;



		for(int i=20; i<30; i++){

				deck[i].setSeed("Coppe");

				deck[i].setValue(x);
				deck[i].setFValue(x);

				x++;

				if(x>8.0)

				deck[i].setFigure(true);

		}



		x=1.0;



		for(int i=30; i<40; i++){

				deck[i].setSeed("Oro");

				deck[i].setValue(x);
				deck[i].setFValue(x);

				x++;

				if(x>8.0)

				deck[i].setFigure(true);

		}

		for(int i=0; i<40; i++)
		{
			if(deck[i].getValue()==1)
				deck[i].setName("ASSO");

			else if(deck[i].getValue()==2)
				deck[i].setName("DUE");
	
			else if(deck[i].getValue()==3)
				deck[i].setName("TRE");
			
			else if(deck[i].getValue()==4)
				deck[i].setName("QUATTRO");

			else if(deck[i].getValue()==5)
				deck[i].setName("CINQUE");
	
			else if(deck[i].getValue()==6)
				deck[i].setName("SEI");

			else if(deck[i].getValue()==7)
				deck[i].setName("SETTE");

			else if(deck[i].getValue()==8)
				deck[i].setName("DONNA");

			else if(deck[i].getValue()==9)
				deck[i].setName("CAVALLO");
			
			else if(deck[i].getValue()==10)
				deck[i].setName("RE");

		}
			

}







void Deck::shuffleDeck()

{

	srand(time(NULL));



	Card tmp;

	int x=0;

	int y=0;



	for(int i=0; i<80; i++){

		x=rand()%40;

		y=rand()%40;

		tmp=deck[y];

		deck[y]=deck[x];

		deck[x]=tmp;

	}



}





void Deck::inizializeFigures()

{

	for(int i=0; i<40; i++)

        if(deck[i].isMatta()==false)

                if(deck[i].isFigure()==true)

			         deck[i].setValue(0.5);

}

void Deck::inizializeBriscola()
{
	for(int i=0; i<40; i++)
	{		
		if(deck[i].getName()=="ASSO")
		{
			deck[i].setValue(11);
			deck[i].setFValue(11);
		}

		else if(deck[i].getName()=="TRE")
		{
			deck[i].setValue(10);
			deck[i].setFValue(10);
		}

		else if(deck[i].getName()=="DONNA")
		{

			deck[i].setValue(2);
		}
		
		else if(deck[i].getName()=="CAVALLO")
			deck[i].setValue(3);

		else if(deck[i].getName()=="RE")
			deck[i].setValue(4);

		else
			deck[i].setValue(0);
	}
}



void Deck::inizializeMatta()

{

	for(int i=0; i<40; i++)

		if(deck[i].getSeed()=="Oro" && deck[i].getValue()==10){

			deck[i].setMatta(true);

			deck[i].setValue(0);

        }

}


//End of Deck.cpp

//main.cpp

#include "Deck.h"
#include <time.h>
#include <list>
#include <iostream>
#include <cstdlib>

using namespace std;

void wait ( int seconds )  //Funzione tempo, utilizzata per rallentare il turno del computer

{

  clock_t endwait;

  endwait = clock () + seconds * CLOCKS_PER_SEC ;

  while (clock() < endwait) {}

}



void start(Deck napoletane, list<Card>& player, list<Card>& computer, Card& briscola, int& it);

void playerTurn(Deck napoletane, list<Card>& player, list<Card>& pPlayer, list<Card>& pComputer,
		 Card& table, Card briscola, int& it, string& got);

void computerTurn(Deck napoletane, list<Card>& computer,list<Card>& pComputer, list<Card>& pPlayer, 
			Card& table, Card briscola, int& it, string& got,Card& used);

void draw(Deck napoletane, list<Card>& hand, int& it);

Card chooseCard(list<Card>& hand);

Card getCard(list<Card>& hand);

bool get(Card c, Card table, Card briscola);

void printHand(list<Card>& hand);

void winner(list<Card>& pPlayer, list<Card>& pComputer);


int main()
{

	Deck napoletane;
	napoletane.inizializeDeck();
	napoletane.inizializeBriscola();
	
	list<Card> player;
	list<Card> computer;
	list<Card> pPlayer;
	list<Card> pComputer;
	Card briscola;
	Card table;
	Card blank,used;
	string got;
	
	for(int i=0; i<2; i++)
	{
		cout<<"ROUND N°"<<i+1<<endl;
		int it=-1;
		napoletane.shuffleDeck();
		start(napoletane,player,computer,briscola,it);
		cout<<"La briscola e': "<<briscola;
		playerTurn(napoletane,player,pPlayer,pComputer,
                                 table,briscola,it,got);
		wait(1);
		computerTurn(napoletane,computer,pComputer,pPlayer,table,
                                      briscola,it,got,used);
		cout<<"Il computer butta: "<<used<<endl;
		cout<<"Ha preso: "<<got<<endl;
		table=blank;
		wait(1);
		system("clear");
		while(!player.empty() && !computer.empty())
		{
			cout<<"ROUND N°"<<i+1<<endl;
			cout<<"La briscola e': "<<briscola;
			if(got=="computer")
			{
				wait(1);
				computerTurn(napoletane,computer,pComputer,pPlayer,
                                        table,briscola,it,got,used);
				cout<<"Il computer butta: "<<used<<endl;
				playerTurn(napoletane,player,pPlayer,pComputer,
                                                  table,briscola,it,got);
			}
			else
			{
				playerTurn(napoletane,player,pPlayer,pComputer,
                                table,briscola,it,got);
				wait(1);
				computerTurn(napoletane,computer,pComputer,pPlayer,
                                        table,briscola,it,got,used);
				cout<<"Il computer butta: "<<used<<endl;
			}
			table=blank;
			cout<<"Ha preso: "<<got<<endl<<endl;
			wait(1);
			system("clear");
		}
		
		
	}
	winner(pPlayer,pComputer);

	return 0;
}

void start(Deck napoletane, list<Card>& player, list<Card>& computer, Card& briscola, int& it)
{
	for(int i=0; i<3; i++)
	{
		player.push_back(napoletane[++it]);
		computer.push_back(napoletane[++it]);
	}

	briscola=napoletane[39];
		
}

void playerTurn(Deck napoletane, list<Card>& player, list<Card>& pPlayer, list<Card>& pComputer,
		 Card& table, Card briscola, int& it, string& got)
{
	cout<<endl;
	if(player.size()==2 && it<39)
	{
		draw(napoletane,player,it);
		cout<<"Le carte che hai in mano: "<<endl;
		printHand(player);
	}
	else
		printHand(player);

	if(table.getName()=="")
		table=chooseCard(player);
	else
	{
		Card p=chooseCard(player);
		if(get(p,table,briscola))
		{
			got="player";
			pPlayer.push_back(table);
			pPlayer.push_back(p);
		}

		else
		{
			got="computer";
			pComputer.push_back(table);
			pComputer.push_back(p);
		}
			
	}	


}

void computerTurn(Deck napoletane, list<Card>& computer,list<Card>& pComputer, list<Card>& pPlayer, 
			Card& table, Card briscola, int& it, string& got, Card& used)
{

	if(computer.size()==2 && it<39)
		draw(napoletane,computer,it);


	list<Card>::iterator tmp;
	Card cp;
	bool done=false;

	if(table.getName()=="")
	{
		table=getCard(computer);
		cp=table;
	}

	
	else
	{	

		for(list<Card>::iterator ith=computer.begin(); ith!=computer.end(); ith++)
		{
			if(get(*ith,table,briscola))
			{
				cp=*ith;
				tmp=ith;
				got="computer";
				done=true;
				
			}
		}
		if(done)
		{
			pComputer.push_back(table);
			pComputer.push_back(cp);
			computer.erase(tmp);
		}
		else
		{
			cp=getCard(computer);
			pPlayer.push_back(cp);
			pPlayer.push_back(table);
			got="player";
		}
		
	}
	used=cp;
	
}

void draw(Deck napoletane, list<Card>& hand, int& it)
{
	hand.push_back(napoletane[++it]);
}

Card chooseCard(list<Card>& hand)
{
	int choose;
	Card c;
	cout<<"Choose a card (0,1,2): ";
	do{
		cin>>choose;
	}while(choose<0 || choose>2);

	list<Card>::iterator ith=hand.begin();
	while(choose!=0)
	{
		ith++;
		choose--;
	}
	c=*ith;
	hand.erase(ith);
	return c;
		
}

Card getCard(list<Card>& hand)
{
	int min=12;
	Card cp;
	list<Card>::iterator tmp;
	for(list<Card>::iterator ith=hand.begin(); ith!=hand.end(); ith++)
		if(ith->getValue()<min)
		{
			min=ith->getValue();
			tmp=ith;
			cp=*ith;
		}

	hand.erase(tmp);
	return cp;
	
}

bool get(Card c, Card table, Card briscola)
{
	return ( 
			( (c.getFValue()>table.getFValue()) && (c.getSeed()==table.getSeed()) ) || 
			( (c.getSeed()==briscola.getSeed()) && (table.getSeed()!=briscola.getSeed()) ) ||
			( (c.getSeed()==briscola.getSeed()) && (table.getSeed()==briscola.getSeed()) && (c.getFValue()>table.getFValue()) )
		);
}

void printHand(list<Card>& hand)
{
	int tmp=0;
	for(list<Card>::iterator ith=hand.begin(); ith!=hand.end(); ith++)
	{
		cout<<tmp<<") "<<*ith;
		tmp++;
	}	
	
}

void winner(list<Card>& pPlayer, list<Card>& pComputer)
{
	int pP=0,pC=0;
	for(list<Card>::iterator itp=pPlayer.begin(); itp!=pPlayer.end(); itp++)
			pP+=itp->getValue();

	for(list<Card>::iterator itc=pComputer.begin(); itc!=pComputer.end(); itc++)
			pC+=itc->getValue();

	cout<<"Il tuo punteggio e': "<<pP<<endl;
	cout<<"Il punteggio del computer e': "<<pC<<endl;

	if(pP>pC)
		cout<<"HAI VINTO!"<<endl;

	else if(pP<pC)
		cout<<"IL COMPUTER VINCE!"<<endl;

	else
		cout<<"PARITA'"<<endl;		

}

//End of main.cpp

Per chiunque volesse provarlo, ho creato un file .zip dove ho messo l’eseguibile e il file dove vengono memorizzati i progressi durante il gioco( quindi i soldi virtuali ). Scarica File

Solita raccomandazione: non esitate a conttarmi per qualsiasi tipo di problema ^^

// Carta.h
#ifndef CARTA_H_
#define CARTA_H_

#include <string>
using namespace std;

class Carta{
public:
	Carta(string s="", float v=0);
	void setSeme(string s);
	void setValore(float v);
	void setFigura(bool f);
	void setMatta(bool m);
	void setValoreMatta();
	bool isMatta();
	bool isFigura();
	string getSeme();
	float getValore();

private:
	string seme;
	float valore;
	bool figura;
	bool matta;

};

#endif /* CARTA_H_ */

//Fine del file Carta.h

//Carta.cpp

#include "Carta.h"
#include <iostream>
using namespace std;

Carta::Carta(string s, float v)
	:figura(false),matta(false)
{
	seme=s;
	valore=v;

}

void Carta::setSeme(string s)
{
	seme=s;

}

void Carta::setValore(float v)
{
	valore=v;
}

string Carta::getSeme()
{
	return seme;
}

float Carta::getValore()
{
	return valore;
}

void Carta::setFigura(bool f)
{
	figura=f;
}

bool Carta::isFigura()
{
	return figura;
}

void Carta::setMatta(bool m)
{
	matta=m;
}

bool Carta::isMatta()
{
	return matta;
}

void Carta::setValoreMatta()
{
	float value;
	cin>>value;
        valore=value;
}

//Fine del file Carta.cpp

//Mazzo.h

#ifndef MAZZO_H_
#define MAZZO_H_

#define NUMCARTE 40

#include "Carta.h"
#include <iostream>

using namespace std;

class Mazzo {

public:
	Mazzo();
	~Mazzo();
	Carta& operator[](int x);
	void inizializzaMazzo();
	void inizializzaFigure();
	void mischiaMazzo();
	void inizializzaMatta();

private:
	Carta mazzo[NUMCARTE];

};

#endif /* MAZZO_H_ */

//Fine del file Mazzo.h

//Mazzo.cpp

#include "Mazzo.h"
#include <time.h>
#include <cstdlib>



Mazzo::Mazzo() {

	// TODO Auto-generated constructor stub

}

Mazzo::~Mazzo() {
	// TODO Auto-generated destructor stub
}

Carta& Mazzo::operator[](int x)
{
	return mazzo[x];
}

void Mazzo::inizializzaMazzo()
{
	float x=1.0;

		for(int i=0; i<10; i++){
			mazzo[i].setSeme("Bastoni");
			mazzo[i].setValore(x);
			x++;
			if(x>8.0)
				mazzo[i].setFigura(true);
		}

		x=1.0;

		for(int i=10; i<20; i++){
			mazzo[i].setSeme("Spade");
			mazzo[i].setValore(x);
			x++;
			if(x>8.0)
			mazzo[i].setFigura(true);
		}

		x=1.0;

		for(int i=20; i<30; i++){
				mazzo[i].setSeme("Coppe");
				mazzo[i].setValore(x);
				x++;
				if(x>8.0)
				mazzo[i].setFigura(true);
		}

		x=1.0;

		for(int i=30; i<40; i++){
				mazzo[i].setSeme("Oro");
				mazzo[i].setValore(x);
				x++;
				if(x>8.0)
				mazzo[i].setFigura(true);
		}
}



void Mazzo::mischiaMazzo()
{
	srand(time(NULL));

	Carta tmp;
	int x=0;
	int y=0;

	for(int i=0; i<80; i++){
		x=rand()%40;
		y=rand()%40;
		tmp=mazzo[y];
		mazzo[y]=mazzo[x];
		mazzo[x]=tmp;
	}

}


void Mazzo::inizializzaFigure()
{
	for(int i=0; i<40; i++)
        if(mazzo[i].isMatta()==false)
                if(mazzo[i].isFigura()==true)
			         mazzo[i].setValore(0.5);
}

void Mazzo::inizializzaMatta()
{
	for(int i=0; i<40; i++)
		if(mazzo[i].getSeme()=="Oro" && mazzo[i].getValore()==10){
			mazzo[i].setMatta(true);
			mazzo[i].setValore(0);
        }
}

//Fine del file Mazzo.cpp

//main.cpp

#include <iostream>
#include <string>
#include <stdlib.h>
#include <time.h>
#include <fstream>
#include "Carta.h"
#include "Mazzo.h"

using namespace std;

bool giocataPlayer(Mazzo napoletane, Carta& player, int& it, float& punteggiop1,bool& mattaImpostata,
			bool& impostaMatta,bool& mischiare);
void gestisciMatta(Carta& matta, float& punteggiop1, bool& mattaImpostata);
bool giocataComputer(Mazzo napoletane, Carta& computer, int& it, float& punteggiopc,float punteggiop1,
			bool& mattaImpostata,bool& impostaMatta,bool& mischiare);

void impostaFile(); //Funzione da utilizzare solo 1 volta e solo quando si apre il programma per la prima volta
void caricaFile(int& euro);
void salvaFile(int& euro);

void primaLaMatta(Mazzo& napoletane); //Funzione di utilità per testare il funzionamento del programma
void terzaLaMatta(Mazzo& napoletane); //Funzione di utilità per testare il funzionamento del programma

void wait ( float seconds )  //Funzione tempo, utilizzata per rallentare il turno del computer
{
  clock_t endwait;
  endwait = clock () + seconds * CLOCKS_PER_SEC ;
  while (clock() < endwait) {}
}


int main()
{
	Mazzo napoletane;
	napoletane.inizializzaMazzo();
	napoletane.inizializzaMatta();
	napoletane.inizializzaFigure();
	napoletane.mischiaMazzo();

	//primaLaMatta(napoletane);
	//terzaLaMatta(napoletane);
	
	char scelta;
	bool mattaImpostata=false;
	bool impostaMatta=false;
	bool mischiare=false;
	int it=-1;
	float punteggiop1=0;
	float punteggiopc=0;
	int euro;
	int puntata=0;

	Carta player;
	Carta computer;

	//impostaFile(); //Leggi sopra

	caricaFile(euro);

	do{
		bool mattaImpostata=false;
		bool impostaMatta=false;

		if(it>=32 || mischiare)
		{
			napoletane.mischiaMazzo();
			it=-1;
			mischiare=false;
		}

		player=napoletane[++it];
		punteggiop1=napoletane[it].getValore();
		if(napoletane[it].isMatta())
			cout<<"Hai la matta!"<<endl;
		else
			cout<<"La tua carta è un "<<napoletane[it].getValore();


		computer=napoletane[++it];
		punteggiopc=napoletane[it].getValore();

		cout<<"\nHai "<<euro<<" euro."<<endl;
		cout<<"\nQuanto vuoi puntare? ";
		do{
			cin>>puntata;
		}while(puntata<1 || puntata>euro);

		
		
		if(!giocataPlayer(napoletane,player,it,punteggiop1,
mattaImpostata,impostaMatta,mischiare))
		{
			cout<<"\nHai sballato!"<<endl;
			cout<<"\nIl computer vince!"<<endl;
			euro-=puntata;
		}
		

		//punteggiop1=7.5; //Trucco usato per verificare la funzionalità del metodo giocataComputer	

		else if(!giocataComputer(napoletane,computer,it,punteggiopc,
punteggiop1,mattaImpostata,impostaMatta,mischiare))
		{
			cout<<"\nIl computer ha sballato!"<<endl;
			cout<<"\nHai vinto!"<<endl;
			euro+=puntata;
		}
		

				

		else if(punteggiopc>punteggiop1)
		{
			cout<<"\nIl computer vince!"<<endl;
			euro-=puntata;
		}

		else if(punteggiopc==punteggiop1)
		{
			cout<<"\nIl computer vince!"<<endl;
			euro-=puntata;
		}
			
		else
		{
			cout<<"\nHai vinto!"<<endl;
			euro+=puntata;
		}
				
		if(euro==0)
		{
			cout<<"\nHai perso tutto! Riazzero il contatore ^^"<<endl;
			euro=100;
		}

	
		cout<<"\nVuoi continuare a giocare? (s/n) ";
	
		do{
			cin>>scelta;
		}while(scelta!='s' && scelta!='n');


	}while(scelta=='s');

	salvaFile(euro);
	

	return 0;
}

bool giocataPlayer(Mazzo napoletane, Carta& player, int& it, float& punteggiop1,bool& mattaImpostata,
			bool& impostaMatta,bool& mischiare)
{
	char scelta;
	Carta matta;

	//cout<<"\nIl tuo punteggio è: "<<punteggiop1<<endl;
	cout<<"\nVuoi chiamare un'altra carta?";
		
	do{
		cin>>scelta;
	}while(scelta!='n' && scelta!='s');

	if(scelta=='s')
	{
		cout<<"\nIl valore della carta chiamata e' "<<napoletane[++it].getValore();
	
		if(napoletane[it].isMatta())
		{
			cout<<"\nE' uscita la matta!"<<endl;
			mischiare=true;
		}

		if( (napoletane[it].isMatta() || impostaMatta) && !mattaImpostata && punteggiop1<7.5)
		{
			matta=napoletane[it];
			impostaMatta=true;
			gestisciMatta(matta,punteggiop1,mattaImpostata);

		}
		
		punteggiop1+=napoletane[it].getValore();
	}

	else 
		return true;

	cout<<"\nIl tuo punteggio e': "<<punteggiop1<<endl;

	if(player.isMatta() && !mattaImpostata && punteggiop1<7.5)
	{
		mischiare=true;
		matta=player;
		gestisciMatta(matta,punteggiop1,mattaImpostata);
		
	}

	if(punteggiop1>7.5)
		return false;
	
	else if(punteggiop1==7.5){
		cout<<"Hai fatto 7 e mezzo!"<<endl;
		return true;
	}

	else
		return giocataPlayer(napoletane,player,it,punteggiop1,
mattaImpostata,impostaMatta,mischiare);

	

}

void gestisciMatta(Carta& matta, float& punteggiop1, bool& mattaImpostata)
{
	char scelta;

	cout<<"\nVuoi impostare ora il valore della matta?";
	do{
		cin>>scelta;
	}while(scelta!='s' && scelta!='n');


	if(scelta=='s')
	{
		float valore;
		cout<<"\nInserisci il valore da impostare alla matta: ";
		do{
			cin>>valore;
		}while(valore<0.5 && valore>7);

		matta.setValore(valore);

		punteggiop1+=matta.getValore();

		mattaImpostata=true;

		return;
	}
	
	else
		return;

}

bool giocataComputer(Mazzo napoletane, Carta& computer, int& it, float& punteggiopc,float punteggiop1, 
			bool& mattaImpostata,bool& impostaMatta,bool& mischiare)
{
	Carta matta;
	int valoreMatta=0;

	cout<<"\nIl punteggio del computer e': "<<punteggiopc<<endl;

	if(computer.isMatta() && !impostaMatta)
	{
		mischiare=true;
		matta=computer;
		cout<<"\nIl computer ha la matta!"<<endl;
		impostaMatta=true;
	}
	
	if(punteggiopc<5.5 || (punteggiop1==7.5 && punteggiopc<7.5) )
	{
		cout<<"\nIl computer chiama una carta ed il suo valore e': "
                cout<<napoletane[++it].getValore()<<endl;

		wait(1.5); // Riferito alla funzione tempo, modificando il valore si stabiliscono i secondi di attesa

		if(napoletane[it].isMatta())
		{
			mischiare=true;
			cout<<"\nE' uscita la matta!"<<endl;
			matta=napoletane[it];
			impostaMatta=true;
		}

		punteggiopc+=napoletane[it].getValore();
		cout<<"\nIl punteggio del computer e' ora : "<<punteggiopc<<endl;
		if(punteggiopc > 7.5)
			return false;

		if(impostaMatta && !mattaImpostata && punteggiopc<7.5)
		{
			if(punteggiopc==7.0)
			{
				cout<<"\nIl computer imposta la matta a 0.5"<<endl;
				matta.setValore(0.5);
				punteggiopc+=matta.getValore();
				cout<<"\nIl computer ha fatto 7 e mezzo!"<<endl;
				return true;
			}	
			//Se il valore della matta + il punteggio del computer attuale non superano quello 
                        //del giocatore se ha 7.5
			// allora chiama un'altra carta e imposta la matta dopo.
			else
				valoreMatta=7.5 - punteggiopc;
				
			if( punteggiop1==7.5 && ( (punteggiopc +  valoreMatta)!=7.5 ) )
			{
				return giocataComputer(napoletane,computer,it,punteggiopc,  punteggiop1,mattaImpostata,impostaMatta,mischiare);
				
			}
	
			else
			{
				cout<<"\nIl computer imposta la matta a: "<<valoreMatta<<endl;
				matta.setValore(valoreMatta);
				punteggiopc+=matta.getValore();
				cout<<"\nIl punteggio del computer e' ora: "<<punteggiopc<<endl;
				
			}

		}
				
				
	}	

	if(punteggiopc==7.5)
	{
		cout<<"\nIl computer ha fatto 7 e mezzo!"<<endl;
		return true;
	}
	
	if(punteggiopc>7.5)
		return false;

	if(punteggiopc>=5.5 && punteggiop1!=7.5)
	{
		cout<<"\nIl computer si ferma qui."<<endl;
		return true;
	}

	if(punteggiopc<5.5)
		return giocataComputer(napoletane,computer,it,punteggiopc,
punteggiop1,mattaImpostata,impostaMatta,mischiare);	


}

void impostaFile()
{
	ofstream fout;
	fout.open("SaveFile.txt");
	fout<<100;
	fout.close();
}

void caricaFile(int& euro)
{
	ifstream fin;
	fin.open("SaveFile.txt");
	if(fin.fail())
	{
		cerr<<"Errore nell'apertura del file."<<endl;
	}
	fin>>euro;
	fin.close();
}
void salvaFile(int& euro)
{
	ofstream fout;
	fout.open("SaveFile.txt");
	if(fout.fail())
	{
		cerr<<"Errore nell'apertura del file."<<endl;
	}
	fout<<euro;
	fout.close();
}

void primaLaMatta(Mazzo& napoletane) 
{
	Carta x;

	for(int i=0; i<40; i++)
		if(napoletane[i].isMatta())
		{
			x=napoletane[0];
			napoletane[0]=napoletane[i];
			napoletane[i]=x;
		}
}

void terzaLaMatta(Mazzo& napoletane)
{
	Carta x;

	for(int i=0; i<40; i++)
		if(napoletane[i].isMatta())
		{
			x=napoletane[2];
			napoletane[2]=napoletane[i];
			napoletane[i]=x;
		}
}

Il gioco in questione è l’attesissimo 0 a.d (in fase di sviluppo da 8 anni) un gioco di strategia in tempo reale simile ad Age of Empire II, ma ambientato in periodi storici differenti. Tutte le informazioni possono essere trovato sul sito.

Dopo una non lunga compilazione sul mio computer fisso con Debian, ho potuto avere una prima impressione del gioco(come potete vedere dal video). Per quanto riguarda i sorgenti essi sono poco chiari in alcuni punti, ma completi per capire lo sviluppo e il funzionamento del gioco, c’è da aggiungere che essi in alcuni punti sono incompleti e necessitano di forti riscritture o aggiornamente (l’AI non è ancora molto sviluppata).

La grafica non è ancora ai livelli di eccellenza desiderati, ma è comunque buona per qualsiasi tipo di scheda video vecchia (non eccessivamente minimo GF 4) e nuova. La giocabilità non è ancora del tutto completata, in alcuni tratti e lenta e fastidiosa.

Qualsiasi altro tipo di descrizione può essere preso dal video (spero di rilasciarne altri). Al più presto sarà disponibile su questo blog un pacchetto .deb con il gioco pre-compilato… Grazie !!

La prima parte consiste in un’introduzione generale: i caratteri, le stringhe, la rappresentazione e i sistemi di codifica e l’uso delle stringhe in C++.

Scarica l’articolo

Come sempre commenti e critiche sono i benvenuti! A breve la seconda parte!
Buon weekend!