Skip to content
Snippets Groups Projects
Commit a6c4fd04 authored by Administrator's avatar Administrator
Browse files

initial commit

parent 06a2b6df
Branches
Tags
No related merge requests found
package application;
import javafx.application.Application;
import javafx.concurrent.Worker;
import javafx.event.EventHandler;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.image.Image;
import javafx.stage.Stage;
import javafx.stage.WindowEvent;
public class Main extends Application
{
@Override
public void start(Stage stage)
{
try
{
FXMLLoader loader = new FXMLLoader(getClass().getResource("MainGUI.fxml"));
Parent root = (Parent)loader.load();
Scene scene = new Scene(root, 800, 600);
stage.setResizable(true);
stage.setTitle("PlayCount");
stage.setScene(scene);
stage.setMinHeight(400);
stage.setMinWidth(750);
Controller controller = (Controller)loader.getController();
controller.setStage(stage);
controller.init();
stage.getIcons().add(new Image("application/icon.png"));
stage.show();
}
catch(Exception e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
launch(args);
}
}
\ No newline at end of file
app.name=PlayCount
version.code=2
version.name=1.1.0
version.date=23.03.16
\ No newline at end of file
/* JavaFX CSS - Leave this comment until you have at least create one rule which uses -fx-Property */
\ No newline at end of file
src/application/icon.png

43.1 KiB

package logic;
import java.util.ArrayList;
import java.util.Random;
public class AI
{
private String name;
private ArrayList<Card> deck;
private int wins;
private Game game;
public AI(String name, Game game)
{
this.name = name;
deck = new ArrayList<Card>();
wins = 0;
this.game = game;
}
public void initialize()
{
deck = new ArrayList<Card>();
}
public void win()
{
wins++;
}
public int getWins()
{
return wins;
}
public void drawCard(Card card)
{
deck.add(card);
}
public void drawCards(ArrayList<Card> cards)
{
deck.addAll(cards);
}
public Card playCard(Card card)
{
deck.remove(card);
return card;
}
public ArrayList<Card> getValidCards(Card lastCard, Color wishColor, boolean challenge)
{
ArrayList<Card> validCards = new ArrayList<Card>();
if(challenge)
{
for(Card currentCard : deck)
{
if(wishColor == null)
{
if(currentCard.getType().equals(CardType.DRAW_TWO) || currentCard.getType().equals(CardType.DRAW_FOUR))
{
validCards.add(currentCard);
}
}
else
{
if(currentCard.getColor().equals(wishColor) && currentCard.getType().equals(CardType.DRAW_TWO) || currentCard.getType().equals(CardType.DRAW_FOUR))
{
validCards.add(currentCard);
}
}
}
}
else
{
if(wishColor == null)
{
for(Card currentCard : deck)
{
if(currentCard.getColor().equals(lastCard.getColor()) || currentCard.getType().equals(lastCard.getType()) || currentCard.getType().equals(CardType.WILD)
|| currentCard.getType().equals(CardType.DRAW_FOUR))
{
validCards.add(currentCard);
}
}
}
else
{
for(Card currentCard : deck)
{
if(currentCard.getColor().equals(wishColor))
{
validCards.add(currentCard);
}
}
}
}
return validCards;
}
public int getDeckSize()
{
return deck.size();
}
public String getName()
{
return name;
}
public void turn(Card lastCard, Color wishColor, boolean challenge)
{
System.out.println("All cards on hand: \n" + deck);
ArrayList<Card> validDeck = getValidCards(lastCard, wishColor, challenge);
System.out.println("validCards: \n" + validDeck);
if(validDeck.size() == 0)
{
if(challenge)
{
drawCards(game.getDeck().drawCards(game.getChallengeCounter(), game.getDeadDeck()));
System.out.println("draw " + game.getChallengeCounter() + " cards");
System.out.println("deack after draw: " + deck);
}
else
{
drawCard(game.getDeck().drawCard(game.getDeadDeck()));
System.out.println("draw one card");
System.out.println("deack after draw: " + deck);
}
}
else
{
System.out.println("choose");
System.out.println("AI chooses: " + getHighestValuedCard(validDeck));
Card playedCard = getHighestValuedCard(validDeck);
Color newWishColor = null;
if(playedCard.getType().equals(CardType.WILD) || playedCard.getType().equals(CardType.DRAW_TWO))
{
Random random = new Random();
int colorInt = random.nextInt(4) + 1;
switch(colorInt)
{
case 1: newWishColor = Color.YELLOW;
break;
case 2: newWishColor = Color.RED;
break;
case 3: newWishColor = Color.BLUE;
break;
case 4: newWishColor = Color.GREEN;
break;
}
}
game.playCard(playCard(playedCard), newWishColor);
}
}
private Card getHighestValuedCard(ArrayList<Card> validDeck)
{
Card highestValuedCard = validDeck.get(0);
for(Card currentCard : validDeck)
{
if(currentCard.getValue() > highestValuedCard.getValue())
{
highestValuedCard = currentCard;
}
}
return highestValuedCard;
}
}
\ No newline at end of file
package logic;
public class Card
{
private CardType type;
private Color color;
private int value;
public Card(CardType type, Color color, int value)
{
this.type = type;
this.color = color;
this.value = value;
}
public CardType getType()
{
return type;
}
public Color getColor()
{
return color;
}
public int getValue()
{
return value;
}
public boolean equals(Card other)
{
return type.equals(other.getType()) && color.equals(other.getColor());
}
@Override
public String toString()
{
return "(" + type + ", " + color + ", value=" + value + ")\n";
}
}
\ No newline at end of file
package logic;
public enum CardType
{
ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, SKIP, REVERSE, DRAW_TWO, DRAW_FOUR, WILD
}
\ No newline at end of file
package logic;
public enum Color
{
YELLOW, RED, BLUE, GREEN, BLACK
}
package logic;
import java.util.ArrayList;
public class DeadDeck
{
private ArrayList<Card> cards;
public DeadDeck()
{
cards = new ArrayList<Card>();
}
public void add(Card card)
{
cards.add(card);
}
public ArrayList<Card> getCards()
{
return cards;
}
}
\ No newline at end of file
package logic;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Stack;
public class Deck
{
private Stack<Card> cards;
public Deck()
{
cards = new Stack<Card>();
for(Color currentColor : Color.values())
{
if(currentColor != Color.BLACK)
{
cards.add(new Card(CardType.ZERO, currentColor, 0));
for(int i = 0; i < 2; i++)
{
cards.add(new Card(CardType.ONE, currentColor, 0));
cards.add(new Card(CardType.TWO, currentColor, 0));
cards.add(new Card(CardType.THREE, currentColor, 0));
cards.add(new Card(CardType.FOUR, currentColor, 0));
cards.add(new Card(CardType.FIVE, currentColor, 0));
cards.add(new Card(CardType.SIX , currentColor, 0));
cards.add(new Card(CardType.SEVEN, currentColor, 0));
cards.add(new Card(CardType.EIGHT, currentColor, 0));
cards.add(new Card(CardType.NINE, currentColor, 0));
cards.add(new Card(CardType.REVERSE, currentColor, 1));
cards.add(new Card(CardType.SKIP, currentColor, 1));
cards.add(new Card(CardType.DRAW_TWO, currentColor, 2));
}
}
}
cards.add(new Card(CardType.DRAW_FOUR, Color.BLACK, 10));
cards.add(new Card(CardType.DRAW_FOUR, Color.BLACK, 10));
cards.add(new Card(CardType.DRAW_FOUR, Color.BLACK, 10));
cards.add(new Card(CardType.DRAW_FOUR, Color.BLACK, 10));
cards.add(new Card(CardType.WILD, Color.BLACK, 5));
cards.add(new Card(CardType.WILD, Color.BLACK, 5));
cards.add(new Card(CardType.WILD, Color.BLACK, 5));
cards.add(new Card(CardType.WILD, Color.BLACK, 5));
}
public void shuffle()
{
Collections.shuffle(cards);
}
public Card drawCard(DeadDeck deadDeck)
{
if(cards.size() > 0)
{
return cards.pop();
}
else
{
refill(deadDeck);
return cards.pop();
}
}
public ArrayList<Card> drawCards(int numberOfCards, DeadDeck deadDeck)
{
ArrayList<Card> drawedCards = new ArrayList<Card>();
for(int i = 0; i < numberOfCards; i++)
{
drawedCards.add(drawCard(deadDeck));
}
return drawedCards;
}
public void refill(DeadDeck deadDeck)
{
for(Card currentCard : deadDeck.getCards())
{
cards.add(currentCard);
}
shuffle();
}
public Stack<Card> getCards()
{
return cards;
}
//TODO --> refill should let newest card of deadDeck in deadDeck
public static void main(String[] args)
{
Deck deck = new Deck();
System.out.println(deck.getCards());
// deck.shuffle();
System.out.println(deck.getCards());
System.out.println();
DeadDeck deadDeck = new DeadDeck();
for(int i = 0; i < 107; i++)
{
System.out.println(i);
Card newCard = deck.drawCard(deadDeck);
deadDeck.add(newCard);
System.out.println(newCard);
System.out.println(newCard.equals(new Card(CardType.DRAW_TWO, Color.RED, 0)));
}
}
}
\ No newline at end of file
package logic;
public enum Direction
{
RIGHT, LEFT
}
package logic;
import java.util.ArrayList;
import java.util.Random;
public class Game
{
private Deck deck;
private DeadDeck deadDeck;
private Player player;
private ArrayList<AI> ais;
private int gameCount;
private int challengeCounter;
private int currentPlayer;
private Card lastCard;
private Color wishColor;
private boolean challenge;
private Direction direction;
public Game(int numberOfAIs)
{
deck = new Deck();
deadDeck = new DeadDeck();
player = new Player("Spieler", this);
ais = new ArrayList<AI>();
for(int i = 0; i < numberOfAIs; i++)
{
ais.add(new AI("AI " + i, this));
}
gameCount = 0;
challengeCounter = 0;
}
public void newGame(int numberOfStartingCards)
{
deck = new Deck();
deck.shuffle();
deadDeck = new DeadDeck();
gameCount++;
challengeCounter = 0;
lastCard = null;
wishColor = null;
challenge = false;
direction = Direction.RIGHT;
player.initialize();
player.drawCards(deck.drawCards(numberOfStartingCards, deadDeck));
for(AI currentAI : ais)
{
currentAI.initialize();
currentAI.drawCards(deck.drawCards(numberOfStartingCards, deadDeck));
}
deadDeck.add(deck.drawCard(deadDeck));
lastCard = deadDeck.getCards().get(deadDeck.getCards().size()-1);
System.out.println("lastCard: " + lastCard);
}
public int getGameCount()
{
return gameCount;
}
private void start()
{
Random random = new Random();
currentPlayer = random.nextInt(ais.size() + 1) + 1;
// DEBUG
currentPlayer = 1;
while(true)
{
if(!lastCard.getType().equals(CardType.SKIP))
{
if(lastCard.getType().equals(CardType.REVERSE))
{
if(direction.equals(Direction.RIGHT))
{
direction = Direction.LEFT;
}
else
{
direction = Direction.RIGHT;
}
}
determineNextPlayer();
if(currentPlayer == 1)
{
player.turn(lastCard, wishColor, challenge);
if(player.getDeckSize() == 0)
{
end(player.getName());
break;
}
}
else
{
ais.get(currentPlayer - 2).turn(lastCard, wishColor, challenge);
if(ais.get(currentPlayer - 2).getDeckSize() == 0)
{
end(ais.get(currentPlayer - 2).getName());
break;
}
}
}
}
}
private void determineNextPlayer()
{
if(direction.equals(Direction.RIGHT))
{
if(currentPlayer == ais.size() + 1)
{
currentPlayer = 1;
}
else
{
currentPlayer++;
}
}
else
{
if(currentPlayer == 1)
{
currentPlayer = ais.size() + 1;
}
else
{
currentPlayer--;
}
}
}
private void end(String name)
{
System.out.println("Player " + name + " wins!");
}
public Deck getDeck()
{
return deck;
}
public DeadDeck getDeadDeck()
{
return deadDeck;
}
public int getChallengeCounter()
{
return challengeCounter;
}
public void playCard(Card card, Color wishColor)
{
deadDeck.add(card);
lastCard = card;
this.wishColor = wishColor;
if(card.getType().equals(CardType.DRAW_TWO))
{
challenge = true;
challengeCounter += 2;
}
else if(card.getType().equals(CardType.DRAW_FOUR))
{
challenge = true;
challengeCounter += 4;
}
System.out.println("new lastCard: " + lastCard);
System.out.println("new wishColor: " + this.wishColor);
System.out.println("new challenge: " + challenge);
System.out.println("new challengeCounter: " + challengeCounter);
}
public static void main(String[] args)
{
Game game = new Game(3);
game.newGame(5);
game.start();
}
}
\ No newline at end of file
package logic;
import java.util.ArrayList;
public class Player
{
private String name;
private ArrayList<Card> deck;
private int wins;
private Game game;
public Player(String name, Game game)
{
this.name = name;
deck = new ArrayList<Card>();
wins = 0;
this.game = game;
}
public void initialize()
{
deck = new ArrayList<Card>();
}
public void win()
{
wins++;
}
public int getWins()
{
return wins;
}
public void drawCard(Card card)
{
deck.add(card);
}
public void drawCards(ArrayList<Card> cards)
{
deck.addAll(cards);
}
public Card playCard(Card card)
{
deck.remove(card);
return card;
}
public ArrayList<Card> getValidCards(Card lastCard, Color wishColor, boolean challenge)
{
ArrayList<Card> validCards = new ArrayList<Card>();
if(challenge)
{
for(Card currentCard : deck)
{
if(wishColor == null)
{
if(currentCard.getType().equals(CardType.DRAW_TWO) || currentCard.getType().equals(CardType.DRAW_FOUR))
{
validCards.add(currentCard);
}
}
else
{
if(currentCard.getColor().equals(wishColor) && currentCard.getType().equals(CardType.DRAW_TWO) || currentCard.getType().equals(CardType.DRAW_FOUR))
{
validCards.add(currentCard);
}
}
}
}
else
{
if(wishColor == null)
{
for(Card currentCard : deck)
{
if(currentCard.getColor().equals(lastCard.getColor()) || currentCard.getType().equals(lastCard.getType()) || currentCard.getType().equals(CardType.WILD) || currentCard.getType().equals(CardType.DRAW_FOUR))
{
validCards.add(currentCard);
}
}
}
else
{
for(Card currentCard : deck)
{
if(currentCard.getColor().equals(wishColor))
{
validCards.add(currentCard);
}
}
}
}
return validCards;
}
public int getDeckSize()
{
return deck.size();
}
public String getName()
{
return name;
}
public void turn(Card lastCard, Color wishColor, boolean challenge)
{
System.out.println("All cards on hand: \n" + deck);
ArrayList<Card> validDeck = getValidCards(lastCard, wishColor, challenge);
System.out.println("validCards: \n" + validDeck);
if(validDeck.size() == 0)
{
if(challenge)
{
drawCards(game.getDeck().drawCards(game.getChallengeCounter(), game.getDeadDeck()));
System.err.println("draw " + game.getChallengeCounter() + " cards");
System.out.println("deack after draw: " + deck);
}
else
{
drawCard(game.getDeck().drawCard(game.getDeadDeck()));
System.err.println("draw one card");
System.out.println("deack after draw: " + deck);
}
}
else
{
System.out.println("choose");
//playerInput (draw or turnCard)
//DEBUG
Card playedCard = null;
Color newWishColor = null;
if(playedCard.getType().equals(CardType.WILD) || playedCard.getType().equals(CardType.DRAW_TWO))
{
//TODO choose color
//DEBUG
newWishColor = Color.BLUE;
}
game.playCard(playCard(playedCard), newWishColor);
}
}
}
\ No newline at end of file
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment