/**
* Retorna uma carta aleatoria do baralho.
*
* @return Carta
* @throws IndexOutOfBoundsException
*/
public Carta get() throws IndexOutOfBoundsException {
int index = randomizer.nextInt(baralho.size());
Carta c = baralho.get(index);
baralho.remove(index);
return c;
}
/**
* Obtem um conjunto de cartas de uma pilha especifica. As cartas não são removidas.
*
* @param indexCarta
* @param index
* @return DoubleLinkedList<Carta>
*/
public DoubleLinkedList<Carta> getListSnapshot(int indexCarta, int index) throws GameException {
try {
DoubleLinkedList<Carta> list = new DoubleLinkedList<Carta>();
for (int j = indexCarta; j < pilhas[index].size(); j++) {
list.add(pilhas[index].get(j));
}
return list;
} catch (Exception e) {
throw new GameException(GameException.GAME_EXCEPTION_CANT_GET_SNAPSHOT);
}
}
/**
* Retorna uma pilha de n cartas.
*
* @param num
* @return StackArray<Carta>
* @throws GameException
*/
public StackArray<Carta> getPilhaCartas(int num) throws GameException {
try {
StackArray<Carta> lista = new StackArray<Carta>(num);
for (int i = 0; i < num; i++) {
// lista.push(get());
lista.push(baralho.get(0));
baralho.remove(0);
}
return lista;
} catch (Exception e) {
throw new GameException(GameException.GAME_EXCEPTION_WITHOUT_ENOUGH_CARDS);
}
}
/**
* Retira um conjunto de cartas de uma pilha especifica.
*
* @param indexCarta
* @param index
* @return DoubleLinkedList<Carta>
* @throws GameException
*/
public DoubleLinkedList<Carta> retira(int indexCarta, int index) throws GameException {
try {
DoubleLinkedList<Carta> list = new DoubleLinkedList<Carta>();
// while akki
int j = indexCarta;
while (j < pilhas[index].size()) {
list.add(pilhas[index].remove(j));
}
virar(index);
return list;
} catch (Exception e) {
throw new GameException(GameException.GAME_EXCEPTION_WITHOUT_ENOUGH_CARDS);
}
}
/** Preenche o baralho com 52 cartas. */
private void criarBaralho() {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 13; j++) {
Carta c = new Carta(Carta.Valor.values()[j], Carta.Naipe.values()[i]);
baralho.add(c);
}
}
}
/**
* Verifica se pode adicionar uma sequencia de cartas a uma pilha.
*
* @param s
* @param index
* @return True/False
* @throws GameException
*/
public boolean canPut(DoubleLinkedList<Carta> s, int index) throws GameException {
try {
boolean verificar = false;
if (s.size() == 0) return false;
// verificar a primeira carta antes de verificar as restantes
if (pilhas[index].size() != 0
&& s.getFirst().valor().ordinal() == pilhas[index].getLast().valor().ordinal() - 1
&& s.getFirst().naipe().ordinal() % 2 != pilhas[index].getLast().naipe().ordinal() % 2
|| pilhas[index].size() == 0 && s.getFirst().valor() == Carta.Valor.REI) {
verificar = true;
}
if (verificar) {
// verificar as seguintes
int valInicial = s.getFirst().valor().ordinal();
int naipeInicial = s.getFirst().naipe().ordinal() % 2;
for (Carta c : s) {
// naipe e valor estao de acordo com os valores actuais requeridos
if (!c.isVoltadaParaCima()) {
return false;
}
if (c.valor().ordinal() == valInicial && c.naipe().ordinal() % 2 == naipeInicial) {
// actualizar a cor do naipe requerida na seguinte carta
// decrementar o valor da carta seguinte visto que é em
// ordem decrescente, K até AS
valInicial = valInicial - 1;
naipeInicial = (naipeInicial + 1) % 2;
} else {
return false;
}
}
// cartas estão na ordem correcta.
return true;
}
return false;
} catch (Exception e) {
throw new GameException(GameException.GAME_EXCEPTION_CANT_PUT_CARD_IN_ZONEC);
}
}
/**
* verifica se o baralho contem a carta c.
*
* @param c
* @return True/False
*/
public boolean verifica(Carta c) {
return baralho.contains(c);
}
