Jump to content

Jogo de Cartas - Problema a distribuir as cartas


zecapistolas
 Share

Recommended Posts

zecapistolas

Bom, é o seguinte tou a tentar desenvolver um jogo de cartas, ainda n sei s vai ser pa sueca ou po "burro" ou po peixinho....mas tou já com um problema, consigo distribuir as cartas mas algumas são iguais, ou seja exitem cartas repetidas pelos jogadores....

Tou a experimentar escolher 16 cartas de um baralho de 52, e depois no futuro dividi-las pelos jogadores....mas isso inda ñ é pra já....

Como resolver esse problema?!  ?

Isto foi o que já fiz...

#include <iostream>
#include <vector>
#include <string>
#include <ctime>

using std::cin; using std::cout; using std::endl;
using std::vector;
using std::string;

int main ()
{
vector<string> numero, naipe, cartas_para_jogo;
string numero_aleatorio, naipe_aleatorio;
srand(time(0));

numero.push_back("1"); numero.push_back("2"); numero.push_back("3"); numero.push_back("4"); numero.push_back("5");
numero.push_back("6"); numero.push_back("7"); numero.push_back("8"); numero.push_back("9"); numero.push_back("10");
numero.push_back("A"); numero.push_back("V"); numero.push_back("R"); numero.push_back("D");

naipe.push_back("O"); naipe.push_back("C"); naipe.push_back("P"); naipe.push_back("E");

for (int i=0; i<16; i++) {
	numero_aleatorio = numero.at(rand() % 14);
	naipe_aleatorio = naipe.at(rand() % 4);
	cartas_para_jogo.push_back(numero_aleatorio + naipe_aleatorio);	
}
}

cumps  😛

Link to comment
Share on other sites

Acho que devia definir as estruturas de dados. Como classes.

Carta/Baralho/Jogador/Mesa

Se estas a programar em C++ pensa como um programador de C++, não uses só o compilador porque tem um nome bonito.

Aqui há coisa de 2 anos fazia umas malhas de croché, depois fartei-me e fui para informática!

Link to comment
Share on other sites

Defines:

Carta:

  Naipe

  Numero

Baralho:

  Tem um conjunto de cartas

Mesa:

  //contem o estado do jogo

  Tem um baralho

  Cartas na mesa/eventualmente associadas a um jogador

  De quem é a vez de jogar?

Jogador:

  Tem um conjunto de cartas (mão)

  Vazadas ganhas.

 

Dentro destas classes podes ter operadores:

Baralho:

  Baralhar(...)

  TirarCartaDeCima(...)

Jogador:

  AdicionarCartaNaMao(...)

  OrdenarMao()

  Jogar(...) //para a mesa claro

Mesa:

  Jogada(...) //eventualmente terá a carta e a sua origem (de que jogador) como parametros.

  VezDe(...)

  GuardarVazada(...)

//eventualmente poderá expor o objecto da classe baralho, para que seus metodos sejam publicos.

Colocas restrições no teu programa:

As cartas têm a sua origem no baralho, logo as cartas dos jogadores e de tudo o resto têm de sair do baralho.

O que quer dizer que o código que fizeste para tentar construir o baralho devia estar dentro do construtor da classe Baralho. Mas código um pouco diferente.

Adicionar regras de jogo.

Vai fazendo código. Mas acompanha o código com a análise.

Bota massa nisso...

Aqui há coisa de 2 anos fazia umas malhas de croché, depois fartei-me e fui para informática!

Link to comment
Share on other sites

Quanto a saírem cartas repetidas, isso deve-se ao facto de tu não removeres as cartas que saíram do baralho.

Nada te garante que todas as chamadas ao rand() sejam diferentes...

Link to comment
Share on other sites

zecapistolas

Já fiz a Class das Cartas

Carta.h

#ifndef CARTA_H_
#define CARTA_H_

enum Naipe {E, P, C, O};
enum Valor {AS, DOIS, TRES, QUATRO, CINCO, SEIS, 
SETE, OITO, NOVE, DEZ, DAMA, VALETE, REI, JOKER};

class Carta
{
private:
Naipe naipe;
Valor valor;
/public:
Carta();
Carta(Naipe,Valor);
void setNaipe(Naipe);
void setValor(Valor);
void imprime_carta();
Naipe getNaipe() const;
Valor getValor() const;
bool epar(Carta outra);
};
#endif /*CARTA_H_*/

Carta.cpp

#include <iostream>
#include <vector>
#include <string>

using std::string;
using std::cout;
using std::endl;
using std::vector;

#include "Carta.h"

Carta::Carta() {
naipe = E;
valor = AS;
}

Carta::Carta(Naipe np,Valor vl) {
setNaipe(np);
setValor(vl);

}

Naipe Carta::getNaipe()const {
return naipe;
}

Valor Carta::getValor()const {
return valor;
}

void Carta::setNaipe(Naipe n) {
naipe=n;
}

void Carta::setValor(Valor v) {
valor=v;
}
void Carta::imprime_carta() {
if((valor==0) || (valor >=10 && valor <= 13)) {
	switch(valor){
		case 0  :cout << "A" ;break;
		case 10 :cout << "D" ;break;
		case 11 :cout << "V" ;break;
		case 12 :cout << "R" ;break;
		case 13 :cout << "J" ;break;
		default: 1;
	}
}
else
	cout << valor+1;	

if(valor != 13) {
	switch(naipe) {
		case 0 :cout << "E" << endl;break;
		case 1 :cout << "P" << endl;break;
		case 2 :cout << "C" << endl;break;
		case 3 :cout << "O" << endl;break;
		default: 1;
	}
}
}

bool Carta::epar(Carta outra) {
bool par_bool;
Naipe par_n, par_nsup;
par_n = outra.Carta::getNaipe();
}

Agora alguém m pod ajudar a fazer a classe BARALHO....

cumps  😉

Link to comment
Share on other sites

afroman110

um construtor por copia:

Carta(const Carta &c)

{

Naipe=c.Naipe;

Valor=c.Valor;

}

e um destrutor

~carta()

{

}

sao capazes de dar jeito

ja agora..

fiz há pouco tempo uma coisa parecida em java..

o codigo é pareciddo..

em baixo esta a classe baralho e a classe carta em java..

/////////////////////////////////////////// classe baralho ///////////////////////////////////////////////////

package jogocartas;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

/**

*

* @author Nuno Malheiro

*/

public class Baralho extends ArrayList <Carta> {

   

    /** Tipo de Baralho (40 ou 52 cartas) */

   

    public static enum Tipo { BAR_40, BAR_52 };

   

    /** Creates a new instance of Baralho */

 

    public Baralho(Tipo tb) {

        for (Carta.Naipe n : Carta.Naipe.values()){

            for (Carta.Tipo t : Carta.Tipo.values()) {

                if ((tb==Tipo.BAR_40) && (t.compareTo(Carta.Tipo.Sena) > 0) &&(t.compareTo(Carta.Tipo.Dama) < 0)) continue;

                this.add(new Carta(t, n));

            }

        }

    }

   

    /** Baralhar as cartas */

    public void baralhar() {

        /** Uso do método de baralho de java.util.Collections */

        Collections.shuffle(this);

    }

    /** Partir as cartas */

    public void partir() {

        /** Guarda primeira metade */

        ArrayList <Carta> mbar = new ArrayList <Carta>(this.subList(0,this.size()/2));

        /** Remove primeira metade */

        this.removeAll(mbar);

        /** Coloca no final a primeira metade */

        this.addAll(mbar);

    }

    /** Retira e devolve as primeiras n cartas do baralho */

    public ArrayList <Carta> primeirasCartas(int n) {

        /** Guarda as n primeiras */

        ArrayList <Carta> mbar = new ArrayList <Carta>(

        this.subList(0, ( n < this.size() ? n : this.size() ) ) );

        /** Remove as n primeiras */

        this.removeAll(mbar);

        return mbar;

    }

    /** Retira e devolve as ultimas n cartas do baralho */

    public ArrayList <Carta> ultimasCartas(int n) {

        /** Guarda as n ultimas */

        ArrayList <Carta> mbar = new ArrayList <Carta>(this.subList( (n > this.size() ? 0 : this.size()-n ), this.size() ) );

        /** Remove as n ultimas */

        this.removeAll(mbar);

        return mbar;

    }

    /** Converte um baralho numa string (uma carta por linha) */

    public String toString() {

        String s = "";

        for (Carta c : this) {

            s = s + c.toString() + "\n";

        }

        return s;

    }

   

   

}

////////////////////////////////////////////// classe carta ///////////////////////////////////////////////

package jogocartas;

/**

*

* @author Nuno Malheiro

*/

public class Carta {

   

// Tipos enumerados de possiveis cartas

   

    public static enum Tipo { Duque, Terno, Quadra, Quina, Sena,

    Oito, Nove, Dez, Dama, Valete, Rei, Manilha, As };

    // Tipos enumerados de possiveis naipes

   

    public static enum Naipe { Copas, Ouros, Espadas, Paus };

   

    /* Tipo da instância de carta */

   

    private Tipo t; private Naipe n;

   

    private int numero;

   

    /** Creates a new instance of Carta */

   

    public Carta(Tipo t, Naipe n) {

        this.t = t; this.n = n;

    }

   

    /** Cria uma nova carta baseada numa string. ex: "As de Ouros" */

   

    public Carta(String s) {

        String [] ls = s.split(" ");

        this.t = Tipo.valueOf(ls[0]);

        this.n = Naipe.valueOf(ls[2]);

    }

   

    /** Converte uma carta numa string. ex: "As de Ouros" */

   

    public String toString() {

        return t.toString() + " de " + n.toString();

    }

   

    /** Devolve o tipo da carta */

   

    public Tipo getTipo() {

        return t;

    }

   

   

    /** Devolve o naipe da carta */

   

    public Naipe getNaipe() {

        return n;

    }

   

    /** Devolve o numero da carta */

    public int getNumero() {

        return numero;

    }

   

      /** Altera o numero da carta */

    public void setNumero(int a) {

        numero=a;

    }

}

Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
 Share

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.