• Revista PROGRAMAR: Já está disponível a edição #53 da revista programar. Faz já o download aqui!

zecapistolas

Jogo de Cartas - Problema a distribuir as cartas

7 mensagens neste tópico

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?!  :hmm:

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  :P

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros 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.

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

:bye2: Mas nessa parte de classes ñ tou mt à vontade!...  :-[  Podes ajudar-m?!...

cumps  ;)

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros 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...

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros 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...

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

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  ;)

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

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;

    }

}

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!


Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.


Entrar Agora