/* 
 * Solitaire (source codes)
 * written by: Arthur Gapusan
 *            
 *
 * ICS-20 B
 * Xavier University Ateneo de Cagayan
 *
 * 
 * Q & A to
 * http://www.planet-java.biz.ly
 */

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.util.*;

/*
<applet code = "Solitaire" width = 700 height = 480>
</applet>
*/

class SuperQueue {

  int num[];
  int readyOut[];
  int size;

  SuperQueue(int s) {
    num = new int[s];
    readyOut = new int[s];
    size = -1;
  }

  void enQueue(int item) {
    if (size==num.length-1)
      System.out.println("Queue is full");
    else
      num[++size] = item;    
  }

  int deQueue() {
    if (size<0) 
      System.out.println("--> Queue is empty");
    else {
      for(int i=size, j=0;i>=0;i--, j++)       
        readyOut[j] = num[i];
      for(int i=size-1, j=0;i>=0;i--, j++) 
        num[j] = readyOut[i];
      return readyOut[size--];
    }
    return 0;
  }
}


class StackOfCards {
  int stck[];
  int tos;

  StackOfCards(int size) {
    stck = new int[size];
    tos = - 1;
  }

  void push(int item) {
    if (tos==stck.length-1);
    else 
      stck[++tos] = item;
  }

  int pop() {
    if (tos < 0) 
      return 53;
    else
      return stck[tos--];
  }
}


class Card {
  int cardNumber; 
  int cardType; 
  int cardOrder;

  Card(int i, int k, int c) {
    cardNumber = i;
    cardType = k;
    cardOrder = c;
  }
}


class Generate {

  Card card[] = new Card[52];        
  Generate() {
    Random rand = new Random();
    int taken[] = new int[52];
    int taken2[] = new int[52];

    
    outer:
    for (int count=0;count<52; ) {
      int i = rand.nextInt(13);
      int k = rand.nextInt(4);

      if (count == 0) {  
        taken[count] = i;
        taken2[count] = k;
        card[count] = new Card(i, k, count);
        count++;
        continue outer;
      }
      for (int j=0;j<count;j++) {
        if (i == taken[j])
          if (k==taken2[j]) 
            continue outer;                      
      }
      taken[count] = i;
      taken2[count] = k;
      card[count] = new Card(i, k, count);
      count++;
    }

  }
}


         
public class Solitaire extends Applet 
  implements MouseListener, MouseMotionListener {

  Color col = new Color(200, 200, 200);
  int locationX[] = {10, 110, 210, 310, 410, 510, 610};
  int locationY[] = {160, 160, 160, 160, 160, 160, 160};
  int pileX[] = {310, 410, 510, 610};
  int pileY[] = {10, 10, 10, 10};
  int pileA[] = {0, 1, 2, 3};
  int pile[] = {-1, -1, -1, -1}; 
  int sizeOfPile[] = {0, 0, 0, 0};
  
  int sizeOfStack[] = {0, 1, 2, 3, 4, 5, 6};
  StackOfCards soc[] = new StackOfCards[6];
   
  int i;                         // this matters
  int j;
  int temp;
  int order;
  int coordinatedY;
  int initializedY;
  SuperQueue sq = new SuperQueue(13);
  int selectedSize;   
  
  StackOfCards dc = new StackOfCards(24);
  int sizeOfStackInDC = 0;
  int sizeOfCardsInDC = -1;
  int tempOrder;
  int increment = 0;
  boolean cardFromDeck = false;
  boolean cardSelected;
  boolean gone, coordinated;
  boolean changed = false;
  boolean done = false;
    
  Vector deckVector = new Vector(24);
  int cards[][] = new int[7][13];
  int sizeOfCards[] = new int[7];
  Card card[];
  Card tempCard[] = new Card[24];
  Generate gen = new Generate();
  
  StackOfCards s[] = new StackOfCards[4];
 

  public void init() {
    increment = 0;
    cardSelected = false;
    gone = false; 
    coordinated = false;
    for (int q=0;q<7;q++) {
      for (int w=0;w<13;w++) 
        cards[q][w] = 53;
    }
    for (int k=0;k<4;k++) {
      s[k] = new StackOfCards(13);
      sizeOfPile[k] = 0;
    }
    for (int k=0;k<7;k++)
      sizeOfCards[k] = 0;
    increment = 0;
    setBackground(new Color(240, 240, 240));
    addMouseListener(this);
    addMouseMotionListener(this);
    for (int k=0;k<24;k++) {
      deckVector.add(gen.card[28+k]);
    }

    Object obj[] = deckVector.toArray();  
    for (int q=0;q<24;q++) { 
      tempCard[q] = (Card) obj[q];
    }
  
    for (int k=0;k<7;k++) 
      cards[k][0] = gen.card[k].cardOrder;
    for (int k=0;k<6;k++)
      soc[k] = new StackOfCards(6);/*
    soc[0].push(gen.card[7].cardOrder);
    soc[1].push(gen.card[8].cardOrder);
    soc[1].push(gen.card[9].cardOrder);
    soc[2].push(gen.card[10].cardOrder);
    soc[2].push(gen.card[11].cardOrder);
    soc[2].push(gen.card[12].cardOrder);
    soc[3].push(gen.card[13].cardOrder);
    soc[3].push(gen.card[14].cardOrder);
    soc[3].push(gen.card[15].cardOrder);
    soc[3].push(gen.card[16].cardOrder);
    soc[4].push(gen.card[17].cardOrder);
    soc[4].push(gen.card[18].cardOrder);
    soc[4].push(gen.card[19].cardOrder);
    soc[4].push(gen.card[20].cardOrder);
    soc[4].push(gen.card[21].cardOrder);
    soc[5].push(gen.card[22].cardOrder);
    soc[5].push(gen.card[23].cardOrder);
    soc[5].push(gen.card[24].cardOrder);
    soc[5].push(gen.card[25].cardOrder);
    soc[5].push(gen.card[26].cardOrder);
    soc[5].push(gen.card[27].cardOrder);  */
    int nm = 7;
    for (int q=0;q<6;q++) {
      for (int w=0;w<q+1;w++) {
        soc[q].push(gen.card[nm++].cardOrder);
      }
    }
  }

  void drawCard(int x, int y, int num, int type, boolean open, boolean selected, boolean up) {
    Graphics g = getGraphics();
    num++;
    String n = String.valueOf(num);
    String typeName = "";
    type++;
    if (open == true) {
      if (selected)
        g.setColor(col);
      else
        g.setColor(Color.white);  
      g.fillRect(x, y, 80, 120);
      g.setColor(Color.gray); 
      g.drawRect(x, y, 80, 120);
    }
    else {
      if (selected)
        g.setColor(col);
      else
        g.setColor(Color.white);
      g.fillRect(x, y, 80, 12);
      g.setColor(Color.gray); 
      g.drawRect(x, y, 80, 12);
    }
    if (type == 1) {
      if (open == true)
        drawHeart(x+5, y+30, selected, g);
      g.setColor(Color.red);  
      typeName = "Heart";        
    }
    if (type == 2) {
      if (open == true)
        drawDiamond(x+40, y+35, selected, g);
      g.setColor(Color.red);
      typeName = "Diamond";
    }
    if (type == 3) {
      if (open == true)
        drawSpade(x+40, y+20, selected, g);
      g.setColor(Color.black);
      typeName = "Spades";
    }
    if (type == 4) {
      if (open == true)
        drawClub(x+25, y+25, selected, g);
      g.setColor(Color.black);
      typeName = "Club";
    }   
    if (n.equals("1"))
      n = "A";
    if (n.equals("11"))
      n = "J";
    if (n.equals("12")) 
      n = "Q";
    if (n.equals("13")) 
      n = "K";
    g.setFont(new Font("Verdana", Font.BOLD, 10));
    g.drawString(n, x+2, y+10);
    g.drawString(n, x+65, y+10);
    g.setFont(new Font("Verdana", Font.BOLD, 9));
    g.drawString(typeName, x+20, y+10);
    if (open == true) {
      g.drawString(n, x+2, y+117);
      g.drawString(n, x+65, y+117);
      g.drawString(typeName, x+20, y+117);
    }
  }

  public void drawSpade(int x, int y, boolean selected, Graphics g) {
    for (int i=0;i<48;i++) {
      int y1 = x - 24;
      g.setColor(Color.black);
      g.drawLine(x, y, (x-24)+i, y+48);
    } 

    for (int i=0;i<16;i++) {
      g.drawLine((x-8)+i, y+48, (x-8)+i, y+64);
    } 
  }

  public void drawClub(int x, int y, boolean selected, Graphics g) {
    g.setColor(Color.black);
    g.fillOval(x,y,32,32); 
    g.fillOval(x-12,y+24,32,32); 
    g.fillOval(x+12,y+24,32,32); 

    for (int i=0;i<16;i++) {
      g.drawLine(((x+16)-8)+i, y+48, ((x+16)-8)+i, y+64);
    } 
  }


  public void drawHeart(int x, int y, boolean selected, Graphics g) {
    g.setColor(Color.red);
    g.fillOval(x,y,40, 40);
    g.fillOval(x+30,y,40, 40);
    for (int i=0;i<64;i++) 
      g.drawLine(x+35,y+60,x+3+i,y+30);
  }

  public void drawDiamond(int x, int y, boolean selected, Graphics g) {
    g.setColor(Color.red);
    for (int i=0;i<24;i++) {
      g.drawLine(x+i,y+i,x-24,y+24);
      g.drawLine(x+24,y+24,x-i,y+i);
      g.drawLine(x-24,y+24,x+i,y+48-i);
      g.drawLine(x+24,y+24,x-i,y+48-i);
      g.drawLine(x,y+48,x-24+i,y+24);
      g.drawLine(x,y+48,x+24-i,y+24);
      g.drawLine(x,y,x-24+i,y+24);
      g.drawLine(x,y,x+24-i,y+24);

    }
  }

  public void drawCardInStack(int x, int y) {
    Graphics g = getGraphics();
    for (int i=0;i<12;i++) {
      for (int j=0, d=0;j<80;j++, d++) {
        g.setColor(new Color(255-(d*3), 255-(d*3), 255-(d*3)));
        g.drawLine(x + j,y + i,x + j, y + i);
      }
    }
    g.setColor(new Color(140, 140, 140)); 
    g.drawRect(x, y, 80, 12);
  }

  void drawDeck(int x, int y, Graphics g) {
    g.fillRect(x, y, 80, 120);
    for (int i=0;i<120;i++) {
      for (int j=0, d=0;j<80;j++, d++) {
        g.setColor(new Color(255-(d*3), 255-(d*3), 255-(d*3)));
        g.drawLine(x + j,y + i,x + j, y + i);
      }
    }
    g.setColor(new Color(140, 140, 140)); 
    g.drawRect(x, y, 80, 120);   
  }
  public void reset() {
    locationX[0] = 0;
    for (int i=0, increment=10;i<7;i++, increment+=100) {
      locationX[i] = increment;
      locationY[i] = 160;
      sizeOfStack[i] = i;
    }
  }

  public void stop() {
    init();
    repaint();
  }

  /*
  |----------------------------------------------------|
  |                                                    |
  |               P A I N T   M E T H O D              |
  |                                                    |      
  |----------------------------------------------------|
  */

  public void paint(Graphics g) {
    reset();
    checkSizeOfStack(g);     // put this in the mouseClicked method
    checkCoordinates(); 
    drawDeck(10, 10, g);
    for (int i=0;i<7;i++) {
      drawCard(locationX[i], locationY[i], gen.card[i].cardNumber, gen.card[i].cardType, true, false, true);
    }  
    g.setColor(Color.gray);
    g.setFont(new Font("SansSerif", Font.BOLD | Font.ITALIC, 16));
    g.drawRect(310, 10, 80, 120);
    g.drawString("Heart", 315, 30);
    g.drawRect(410, 10, 80, 120);
    g.drawString("Diamond", 415, 30);
    g.drawRect(510, 10, 80, 120);
    g.drawString("Spades", 515, 30);
    g.drawRect(610, 10, 80, 120);
    g.drawString("Club", 615, 30);  
    g.setFont(new Font("SansSerif", Font.BOLD | Font.ITALIC, 13));
    g.setColor(new Color(40, 40, 40));
    g.drawString("If you want to play again, select reload in the appletviewer menu or you may run the application again!...", 10, 475);
  }
  

  public void mouseClicked(MouseEvent me) {
    int x = me.getX();
    int y = me.getY();
    if (increment == 24) {
      drawEmptyDeck();
    }
      
    if (((x>10) && (x<90)) && ((y>10) && (y<130))) {
      if (increment == 23) {
        drawEmptyDeck();
      }
      else {
        if (sizeOfCardsInDC == (-1)) {
          tempOrder = tempCard[increment].cardOrder;
          drawCard(110, 10, gen.card[tempOrder].cardNumber, gen.card[tempOrder].cardType, true, false, true);
          sizeOfCardsInDC++;
        }
        else {
          dc.push(tempOrder);
          sizeOfStackInDC++;
          increment++;
          tempOrder = tempCard[increment].cardOrder;
          deleteCard(110, 10);
          drawCard(110, 10, gen.card[tempOrder].cardNumber, gen.card[tempOrder].cardType, true, false, true);
          sizeOfCardsInDC++;
        }
      }
    }
    
    if (((x>110) && (x<190)) && ((y>10) && (y<130))) {
      if (cardSelected) {
        drawCard(110, 10, gen.card[tempOrder].cardNumber, gen.card[tempOrder].cardType, true, false, true);
        cardSelected = false;
        cardFromDeck = false;
        coordinated = false;
      }
      else {
        drawCard(110, 10, gen.card[tempOrder].cardNumber, gen.card[tempOrder].cardType, true, true, true);
        cardSelected = true;
        cardFromDeck = true;
        coordinated = false;
      }
    }

    for (i=0;i<7;i++) {
      if (((x>locationX[i]) && (x<(locationX[i]+80))) && ((y>locationY[i]) && (y<(locationY[i]+120)))) {
        if (cardSelected) { 
          if ((temp == i) && (coordinated==false)) {
            cardSelected = false;
            drawCard(locationX[i], locationY[i], gen.card[cards[i][sizeOfCards[i]]].cardNumber, gen.card[cards[i][sizeOfCards[i]]].cardType, true, false, true);                        
            checkPreviousStack();
          }
        
          if ((temp == i) && (coordinated)) {
            for (int l=coordinatedY;l<sizeOfCards[i];l++)
              drawCard(locationX[i], (initializedY + (l*12)), gen.card[cards[i][l]].cardNumber, gen.card[cards[i][l]].cardType, false, false, true);
            drawCard(locationX[i], (initializedY + (sizeOfCards[i]*12)), gen.card[cards[i][sizeOfCards[i]]].cardNumber, gen.card[cards[i][sizeOfCards[i]]].cardType, true, false, true);

            coordinated = false;
            cardSelected = false;
            
          }
          else {
            if (sizeOfCards[i] == (-1)) {
              if (cardFromDeck) {
                if (gen.card[tempOrder].cardNumber==12) { 
                  sizeOfCards[i]++;
                  locationY[i] = 160;
                  cards[i][sizeOfCards[i]] = tempOrder;
                  drawCard(locationX[i], locationY[i], gen.card[tempOrder].cardNumber, gen.card[tempOrder].cardType, true, false, true);
                  deleteCard(110, 10);
                  tempOrder = dc.pop();
                  drawCard(110, 10, gen.card[tempOrder].cardNumber, gen.card[tempOrder].cardType, true, false, true);
                  cardFromDeck = false;
                  cardSelected = false;
                }
              }
              if (coordinated) {       
                if (gen.card[sq.num[0]].cardNumber==12) { 
                  sizeOfCards[i] += (selectedSize+1);
                  locationY[i] = 160;
                 
                  for (int s=0;s<selectedSize;s++) {
                    int some = sq.deQueue();
                    cards[i][s] = some;
                    drawCard(locationX[i], locationY[i], gen.card[some].cardNumber, gen.card[some].cardType, false, false, true);
                    locationY[i] += 12; 
                  }
                  int value = sq.deQueue();
                  cards[i][sizeOfCards[i]] = value;
                  drawCard(locationX[i], locationY[i], gen.card[value].cardNumber, gen.card[value].cardType, true, false, true);      
                  sizeOfCards[temp] -= (selectedSize+1);  
                  locationY[i] = 160;
                  locationY[i] = locationY[i] + (sizeOfCards[i]*12);
                  locationY[i] = locationY[i] + (sizeOfStack[i]*12);
                  cardSelected = false;
                  coordinated = false;
                  checkPreviousStack();
                }                
              }
              if (gen.card[order].cardNumber==12) {
                drawCard(locationX[i], locationY[i], gen.card[order].cardNumber, gen.card[order].cardType, true, false, true);
                sizeOfCards[i]++;
                cards[i][sizeOfCards[i]] = order;                          
                locationY[i] = 160;
                locationY[i] = locationY[i] + (sizeOfCards[i]*12);
                locationY[i] = locationY[i] + (sizeOfStack[i]*12);
                drawCard(locationX[i], locationY[i], gen.card[order].cardNumber, gen.card[order].cardType, true, false, true);
                sizeOfCards[temp]--;             
                checkPreviousStack();
              }                  
            }
          try {
            if (gen.card[cards[i][sizeOfCards[i]]].cardNumber==(gen.card[sq.num[0]].cardNumber+1)) {
              if (coordinated) {
                int typeA = gen.card[cards[i][sizeOfCards[i]]].cardType;
                int typeB = gen.card[sq.num[0]].cardType;
                if ((typeA==0 && typeB==2) || (typeA==0 && typeB==3) || (typeA==1 && typeB==2) || (typeA==1 && typeB==3) || (typeA==2 && typeB==0) || (typeA==2 && typeB==1) || (typeA==3 && typeB==0) || (typeA==3 && typeB==1)) {
                  for (int s=sizeOfCards[i]+1;s<=sizeOfCards[i]+(selectedSize+1);s++) 
                    cards[i][s] = sq.deQueue();             
                  sizeOfCards[i] += (selectedSize+1);
                  sizeOfCards[temp] -= (selectedSize+1);
                  locationY[i] = 160;
                  for (int s=0;s<sizeOfStack[i];s++) {
                    drawCardInStack(locationX[i], locationY[i]);
                    locationY[i]+=12;
                  }
                  for (int s=0;s<sizeOfCards[i];s++) {
                    drawCard(locationX[i], locationY[i], gen.card[cards[i][s]].cardNumber, gen.card[cards[i][s]].cardType, false, false, true);
                    locationY[i] += 12;
                  }
                  drawCard(locationX[i], locationY[i], gen.card[cards[i][sizeOfCards[i]]].cardNumber, gen.card[cards[i][sizeOfCards[i]]].cardType, true, false, true); 

                  checkPreviousStack();
                  cardSelected = false; 
                  coordinated = false;
                }
              }
            }
          } catch (ArrayIndexOutOfBoundsException e) {
              System.out.println("Exception Caught!");
            }

            if (cardFromDeck) {
              if (gen.card[cards[i][sizeOfCards[i]]].cardNumber==(gen.card[tempOrder].cardNumber+1)) {
                int typeA = gen.card[cards[i][sizeOfCards[i]]].cardType;
                int typeB = gen.card[tempOrder].cardType;
                if ((typeA==0 && typeB==2) || (typeA==0 && typeB==3) || (typeA==1 && typeB==2) || (typeA==1 && typeB==3) || (typeA==2 && typeB==0) || (typeA==2 && typeB==1) || (typeA==3 && typeB==0) || (typeA==3 && typeB==1)) {
            
                  locationY[i] = 160;
                  for (int q=0;q<sizeOfStack[i];q++) {
                    drawCardInStack(locationX[i], locationY[i]);
                    locationY[i] += 12;
                  }
                  for (int q=0;q<=sizeOfCards[i];q++) {
                    drawCard(locationX[i], locationY[i], gen.card[cards[i][q]].cardNumber, gen.card[cards[i][q]].cardType, false, false, true);
                    locationY[i] += 12;
                  }
                  drawCard(locationX[i], locationY[i], gen.card[tempOrder].cardNumber, gen.card[tempOrder].cardType, true, false, true);
                  sizeOfCards[i]++;
                  cards[i][sizeOfCards[i]] = tempOrder;
                  tempOrder = dc.pop();
                  deleteCard(110, 10);
                  drawCard(110, 10, gen.card[tempOrder].cardNumber, gen.card[tempOrder].cardType, true, false, true);
                  cardFromDeck = false;
     	 	  cardSelected = false;
                }
              }
            } 
            if (gen.card[cards[i][sizeOfCards[i]]].cardNumber==(gen.card[order].cardNumber+1)) {
              int typeA = gen.card[cards[i][sizeOfCards[i]]].cardType;
              int typeB = gen.card[order].cardType;
              if ((typeA==0 && typeB==2) || (typeA==0 && typeB==3) || (typeA==1 && typeB==2) || (typeA==1 && typeB==3) || (typeA==2 && typeB==0) || (typeA==2 && typeB==1) || (typeA==3 && typeB==0) || (typeA==3 && typeB==1)) {
                      
                drawCard(locationX[i], locationY[i], gen.card[cards[i][sizeOfCards[i]]].cardNumber, gen.card[cards[i][sizeOfCards[i]]].cardType, false, false, true);
                sizeOfCards[i]++;
                cards[i][sizeOfCards[i]] = order;
                locationY[i] = 160;
                locationY[i] = locationY[i] + (sizeOfCards[i]*12);
                locationY[i] = locationY[i] + (sizeOfStack[i]*12);
                drawCard(locationX[i], locationY[i], gen.card[order].cardNumber, gen.card[order].cardType, true, false, true);
                sizeOfCards[temp]--; 
                cardSelected = false;            
                checkPreviousStack();
              }
            }
          }    
        }
        else {
          try {
            if (sizeOfCards[i]!=-1) {
              cardSelected = true;
              drawCard(locationX[i], locationY[i], gen.card[cards[i][sizeOfCards[i]]].cardNumber, gen.card[cards[i][sizeOfCards[i]]].cardType, true, true, true);
              temp = i;
              order = cards[i][sizeOfCards[i]];
            }
          } catch(ArrayIndexOutOfBoundsException e) { }
        }
      }
    }

    for (int p=0;p<4;p++) {
      if (((x>pileX[p]) && (x<(pileX[p]+80))) && ((y>pileY[p]) && (y<(pileY[p]+120)))) {
        if (cardSelected) {
          if (cardFromDeck) {
            if (gen.card[tempOrder].cardNumber==sizeOfPile[p]) {
              if (gen.card[tempOrder].cardType==pileA[p]) {
                drawCard(pileX[p], pileY[p], gen.card[tempOrder].cardNumber, gen.card[tempOrder].cardType, true, false, true);
                deleteCard(110, 10);
                int value = dc.pop();
                drawCard(110, 10, gen.card[value].cardNumber, gen.card[value].cardType, true, false, true);
                tempOrder = value;
                sizeOfPile[p]++;
                cardSelected = false;
                cardFromDeck = false;
              }
            }
          }
          if (gen.card[order].cardNumber==sizeOfPile[p]) {
            if (gen.card[order].cardType==pileA[p]) {
              drawCard(pileX[p], pileY[p], gen.card[order].cardNumber, gen.card[order].cardType, true, false, true);
              sizeOfCards[temp]--;
              sizeOfPile[p]++;
              cardSelected = false;
              checkPreviousStack();
            }
          }
        }
      }
    }            

    for (int k=0;k<7;k++) {
      if (((x>locationX[k]) && (x<locationX[k]+80)) && ((y>160) && (y<locationY[k]))) {
        if (cardSelected) {
          if ((temp == k) && (coordinated)) {
            for (int l=coordinatedY;l<sizeOfCards[k];l++)
              drawCard(locationX[k], (initializedY + (l*12)), gen.card[cards[k][l]].cardNumber, gen.card[cards[k][l]].cardType, false, false, true);
            drawCard(locationX[k], (initializedY + (sizeOfCards[k]*12)), gen.card[cards[k][sizeOfCards[k]]].cardNumber, gen.card[cards[k][sizeOfCards[k]]].cardType, true, false, true);
            selectedSize = ((sizeOfCards[k]) - coordinatedY);
            coordinated = false;
            cardSelected = false;
            int some = 53;
            for (int s=0;s<=sq.size;s++) 
              some = sq.deQueue();
            some = sq.deQueue();
          } 
        }
        else {
          int computedY = 160;
          if (y>(computedY+(sizeOfStack[k]*12))) {
            initializedY = computedY + (sizeOfStack[k]*12);
            int finalizedY = y - initializedY;
            coordinatedY = finalizedY / 12;
            cardSelected = true;
            for (int l=coordinatedY;l<sizeOfCards[k];l++) {
              drawCard(locationX[k], (initializedY + (l*12)), gen.card[cards[k][l]].cardNumber, gen.card[cards[k][l]].cardType, false, true, true);
              sq.enQueue(cards[k][l]);
            }
            drawCard(locationX[k], (initializedY + (sizeOfCards[k]*12)), gen.card[cards[k][sizeOfCards[k]]].cardNumber, gen.card[cards[k][sizeOfCards[k]]].cardType, true, true, true);
            sq.enQueue(cards[k][sizeOfCards[k]]);
           
            selectedSize = ((sizeOfCards[k]) - coordinatedY);
           
            temp = k;
            coordinated = true;
          }     
        }
      }
    }
    checkStacks();
    drawScore();
  }

  void drawScore() {
    deleteCard(209,10);
    Graphics g = getGraphics();
    int score = 0;
    for (int q=0;q<4;q++)
      score += sizeOfPile[q];
    g.setColor(new Color(100, 255, 100));
    g.setFont(new Font("SansSerif", Font.BOLD, 15));
    score = (score * 5) - 52;
    g.drawString("Score: " + score, 210, 30);  
  }

  void checkStacks() {
  Graphics g = getGraphics();
    for (int k=0;k<7;k++) {
      if (sizeOfCards[k]<=(-1)) {   
      
        if (sizeOfStack[k] == 0)
          sizeOfCards[k] = -1;
        else { 
          sizeOfStack[k]--;
          sizeOfCards[k] = 0;
        }
        int inc = 0;
        int orderInStack = 53;
        locationY[k] = 160;
        deletePile(locationX[k], locationY[k]);
        if (k != 0) {
          if (soc[k-1].tos==-1);
          else
            orderInStack = soc[k-1].pop();
        }

        for (int j=0;j<sizeOfStack[k];j++) {       
          drawCardInStack(locationX[k], locationY[k] + inc);
          inc+=12;
        }
       
        if (orderInStack !=53) {
          drawCard(locationX[k], locationY[k] + inc, gen.card[orderInStack].cardNumber, gen.card[orderInStack].cardType, true, false, true);
          locationY[k] = locationY[k] + inc;
          cards[k][0] = orderInStack;       
        }
        else {
          locationY[k] = 160; 
          cards[k][0] = -1;
        }
      }
    }
  }

  void deleteCard(int x, int y) {
    Graphics g = getGraphics();
    g.setColor(new Color(240, 240, 240));
    g.fillRect(x, y, 81, 121);
  }
  void deletePile(int x, int y) {
    Graphics g = getGraphics();
    g.setColor(new Color(240, 240, 240));
    g.fillRect(x, y, 81, 300);
  }
  void drawEmptyDeck() {
    Graphics g = getGraphics();
    deleteCard(10, 10);
    g.setColor(new Color(100, 100, 100));
    g.fillRect(10, 10, 80, 120);
    g.setColor(Color.white);
    g.drawRect(10, 10, 80, 120);
    g.drawRect(11, 11, 78, 118);
    g.drawLine(10, 10, 90, 130);
    g.drawLine(11, 10, 90, 129);
    g.drawLine(10, 11, 89, 130);
    g.drawLine(90, 10, 10, 130);
    g.drawLine(89, 10, 10, 129);
    g.drawLine(90, 11, 11, 130);
  }

  public void checkCoordinates() {
    for (int i=0;i<7;i++) {
      locationY[i] = locationY[i] + (sizeOfStack[i] * 12);
    }
  }

  public void checkPreviousStack() {
    Graphics g = getGraphics();
    int inc = 0;
    locationY[temp] = 160;
    deletePile(locationX[temp], locationY[temp]);
    for (int k=0;k<sizeOfStack[temp];k++) {
      drawCardInStack(locationX[temp], locationY[temp]);
      locationY[temp]+=12;
    }
    int k = 0;
    for (k=0;k<sizeOfCards[temp];k++) {
      drawCard(locationX[temp], locationY[temp], gen.card[cards[temp][k]].cardNumber, gen.card[cards[temp][k]].cardType, false, false, true);
      locationY[temp]+=12;
    }
    drawCard(locationX[temp], locationY[temp], gen.card[cards[temp][k]].cardNumber, gen.card[cards[temp][k]].cardType, true, false, true);
    cardSelected = false;
  }

  public void checkSizeOfStack(Graphics g) {
    for (int i=0;i<7;i++) {
      int inc = 0;
      for (int j=0;j<sizeOfStack[i];j++) {       
        drawCardInStack(locationX[i], locationY[i] + inc);
        inc += 12;
      }
    }
  }
  
  public void mousePressed(MouseEvent me) { }
  public void mouseReleased(MouseEvent me) { }
  public void mouseEntered(MouseEvent me) { }
  public void mouseExited(MouseEvent me) { }
  public void mouseDragged(MouseEvent me) { }
  public void mouseMoved(MouseEvent me) { }
}