Thread: Racko maddness

So my teacher gave us code that plays out the old Racko game. All we need to do is think of some kind of strategy of playing the game. So what I have done is just make the player takes card from the discarded deck and if it is in 1-6, then it goes into the first slot, 7-12 into the 2nd, 13-18 into the 3rd, and so on until 54-60 into the 10th slot. However, it isn't the most beneficial to the player. Does anyone think of a better code. This is my code:

import java.util.Random;

public class PlayerRyan implements Player
{
Random random = new Random();

public void beginGame(Rack rack)
{ }

public int acceptCard(Rack rack, Card card)
{
int k = 0;
return k;
}

public int placeCard(Rack rack, Card card)
{
int x = card.value();
if(x <= 6)
{
return 1;
}

if(x >= 7 && x <= 12)
{
return 2;
}

if(x >= 13 && x <= 18)
{
return 3;
}

if(x >= 19 && x <= 24)
{
return 4;
}

if(x >= 25 && x <= 30)
{
return 5;
}

if(x >= 31 && x <= 36)
{
return 6;
}

if(x >= 37 && x <= 41)
{
return 7;
}

if(x >= 42 && x <= 47)
{
return 8;
}

if(x >= 48 && x <= 53)
{
return 9;
}

if(x >= 54 && x <= 60)
{
return 10;
}
return 0;
}
}

I have other code that plays the rest of the game so I only need a better strategy for my player. my player inherits from a couple of other programs.

Player:
public interface Player
{
// beginGame is invoked at the start of each game
// rack is the initial randomly dealt rack
// you may initialize any variables here
public void beginGame(Rack rack);

// acceptCard is invoked at the start of each turn
// rack is the current state of the rack
// card is the last discard from the previous player's turn
// you may return a slot number, or 0 to be dealt another card
public int acceptCard(Rack rack, Card card);

// placeCard is invoked if zero is returned by acceptCard
// rack is the current state of the rack
// card is the newly drawn card
// you may return a slot number, or 0 to discard the new card
public int placeCard(Rack rack, Card card);
}

Rack:
public class Rack extends Deck
{
public static final int LEN = 10;

public Rack()
{ }

public Rack(Rack that)
{
for (int i = 0; i < LEN; i++)
{
add(new Card(that.get(i)));
}
}

public String toString()
{
String s = "";
for (int i = 0; i < LEN; i++)
{
if (i > 0) s += ",";
if (s.length() > 60)
{
s += "+";
break;
}
s += get(i).value();
}
return "[" + s + "]";
}

public boolean isSorted()
{
boolean b = true;
int i = 1;
while (i < LEN)
{
if (get(i).compareTo(get(i-1)) < 0)
{
b = false;
break;
}
i++;
}
return b;
}

public boolean isBetween(int i)
{
boolean b = false;
if (i >= 1 && i <= LEN - 2)
{
int v1 = get(i-1).value();
int v2 = get(i).value();
int v3 = get(i+1).value();
b = (v1 < v2 && v2 < v3);
}
return b;
}

public void show()
{
String line = " -------------------------------------------------------------";
System.out.println(line);
for (int i = LEN-1; i >=0 ; i--)
{
int v = get(i).value();
String format = "%2d %" + v + "d\n%s\n";
System.out.printf(format, i+1, v, line);
}
}

public int gap(int i)
{
return gap(i, i+1);
}

public int gap(int i, int j)
{
int g = 0;
if (i >= 0 && j < LEN)
{
g = get(j).value() - get(i).value();
}
return g;
}
}

Card:
public class Card implements Comparable<Card>
{
public static final int MIN = 1;
public static final int MAX = 60;
private static final int bad = 0;
private int val= bad;

public Card()
{
val = bad;
}

public Card(int num)
{
if (num >= MIN && num <= MAX) val = num;
}
public Card(Card that)
{
this.val = that.val;
}

public String toString()
{
return "[" + val + "]";
}

public boolean equals(Card that)
{
return this.val == that.val;
}

public int compareTo(Card that)
{
if (this.val < that.val) return -1;
if (this.val > that.val) return 1;

return 0;
}

public int value()
{
return val;
}
}

Deck:
import java.util.List;
import java.util.LinkedList;
import java.util.Collections;

public class Deck extends LinkedList<Card>
{
public Deck()
{ }

public Deck(boolean fill)
{
if (fill)
{
fill();
}
}

public void fill()
{
clear();
int min = Card.MIN;
int max = Card.MAX;
for (int k = min; k <= max; k++)
{
add(new Card(k));
}
}

public void shuffle()
{
Collections.shuffle(this);
}

public void deal(Rack rack)
{
if (Rack.LEN < size())
{
rack.clear();

for (int i = 0; i < Rack.LEN; i++)
{
rack.add(pop());
}
}
}

public void deal(List<Rack> racks)
{
if (racks.size() * Rack.LEN < size())
{
for (Rack rack : racks)
{
rack.clear();
}
for (int i = 0; i < Rack.LEN; i++)
{
for (Rack rack : racks)
{
rack.add(pop());
}
}
}
}

// public void print()
// {
// for (Card card : this)
// {
// System.out.println(card);
// }
// }

public void print()
{
for (int i = 0; i < size(); i++)
{
System.out.printf("%5d) %3s\n", i, get(i));
}
}

public Deck complement()
{
Deck deck = new Deck(true);
Deck comp = new Deck(false);
for (Card card : deck)
{
if (!contains(card))
{
comp.add(card);
}
}
return comp;
}

public double average()
{
double a = 0;
double t = 0;
int n = 0;
for (Card card : this)
{
t += card.value();
n += 1;
}
if (n > 0)
{
a = t/n;
}
return a;
}

// public static Deck complement(Rack rack)
// {
// Deck deck = new Deck(true);
// Deck comp = new Deck(false);
// for (Card card : deck)
// {
// if (!rack.contains(card))
// {
// comp.add(card);
// }
// }
// return comp;
// }
}

Program:
import java.util.Collections;
import java.util.List;
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;

class Program
{
public static void main(String[] args)
{
test2();
}

public static void test1()
{
Deck deck = new Deck(true);
Collections.shuffle(deck);
deck.print();

Rack rack1 = new Rack();
Rack rack2 = new Rack();
List<Rack> racks = new LinkedList<Rack>();
racks.add(rack1);
racks.add(rack2);
deck.deal(racks);
rack1.print();
rack2.show();
}

public static void test2()
{
Deck deck = new Deck(true);
Collections.shuffle(deck);
deck.print();

Rack rack = new Rack();
deck.deal(rack);

Scanner scanner = new Scanner(System.in);

int c = 0;

while (deck.size() > 0)
{
rack.show();

if (rack.isSorted())
{
System.out.printf("You Win!!!\n");
System.out.printf("It only took %d moves.\n", c);
break;
}

c++;

Card card = deck.pop();
System.out.printf("%3d) %s Slot or Discard: ", c, card);

String s = scanner.next();

int k = 0;
try
{
k = Integer.parseInt(s);
if (k < 1 || k > 10) k = 0;
}
catch (Exception ex)
{ }

if (k > 0)
{
rack.set(k-1, card);
}
}
}

public static boolean delay(int milliseconds)
{
boolean success = true;
try
{
Thread.sleep(milliseconds);
}
catch (InterruptedException ex)
{
Thread.currentThread().interrupt();
success = false;
}
return success;
}
}

Welcome to the forum!

Please read this topic to learn how to post code correctly along with other useful hints/tips for newcomers. Then fix your post so the code is readable.