import java.util.Random;
import java.util.Vector;

public class DinoStone extends Thread{
    public int totalx = 8;
    public int totaly = 10;
    public boolean isCheckingAI = false;
    public boolean isComputer = false;
    public int[][] layout = null;
    public int[][] c_layout = null;
    public int colortotal = 3;
    public final int BLACKBLOCK = 99;       //for test
    public final int BLACKBLOCK2 = 98;
    public final int UPBLACKSTONEH = 2;
    public int leastclearBlock = 3;        //for test
    public final int DOWN = 0;
    public final int LEFT = 1;
    public final int RIGHT = 2;
    public static Random randomobj = new Random();
    public int[] nextcolors = new int[colortotal];
    public int nextposition = 0;
    public int[] currentcolors = new int[colortotal];
    public int currentposition = 0;
    public int currentx = 0;
    public int currenty = 0;
    public DinoStone opponent = null;
    public int STEP_TIME = 500;//DSpuzzleDis.RUN_STEP_TIME;
    public static boolean pause = false;
    public int clearnumber = 0;
    public int clearcombo = 0;
    public Vector combocolor = new Vector();
    public int couplenumber = 0;
    public boolean enemydrop = true;
    protected boolean enemyinited = false;
    public boolean enemyturn = false;
    public int[][] blackstone = null;
	public long roundstarttime = 0;

    public DinoStone(int totalx, int totaly, int color, DinoStone opponent) {
        this.totalx = totalx;
        this.totaly = totaly+2;
        layout = new int[this.totalx][this.totaly];
        c_layout = new int[this.totalx][this.totaly];
        //t_layout = new int[this.totalx][this.totaly];
        this.opponent = opponent;
        //this.isComputer = false;
        this.colortotal = color;
        gameover = false;

    }

    //CLEAR THE BACKGROUND
//    public void initLayout(boolean ispuzzle) {
//
//        for (int i=0; i<totalx; i++) {
//            for (int j=0; j<totaly; j++) {
//
//                layout[i][j] = 0;
//				if(ispuzzle)
//				{
//					for (int m=0; m<blackstone.length; m++) {
//		                if(blackstone[m][0] == i && blackstone[m][1] == j)
//		                {
//		                    layout[i][j] = BLACKBLOCK2;
//		                }
//					}
//				}
//           }
//       }
//    }

    public void initLayout(boolean ispuzzle) {
	    layout = new int[totalx][totaly];
        for (int i=0; i<totalx; i++) {
            for (int j=0; j<totaly; j++) {
                  layout[i][j] = 0;
            }
        }
		try {
		if (ispuzzle) {
			for (int m=0; m<blackstone.length; m++) {
				layout[blackstone[m][0]][blackstone[m][1]] = BLACKBLOCK2;
//				layout[5][10] = BLACKBLOCK2;
//				layout[3][10] = BLACKBLOCK2;
//				layout[6][10] = BLACKBLOCK2;
			}

		}
//			for (int x = 0; x < totalx; x++) {
//				for (int y = 0; y < totaly; y++) {
//					System.out.print(layout[x][y] + " ");
//				}
//				System.out.println();
//			}
		}catch(Exception e) {
			e.printStackTrace();
		}

    }

    public void clearBlock() {
        if (!enemyinited) {
            switch(currentposition) {
                case 0:
                    layout[currentx+1][currenty+1] = 0;
                    //layout[currentx][currenty+1] = 0;
                    layout[currentx+1][currenty] = 0;
                    layout[currentx][currenty] = 0;
                break;
                case 1:
                    layout[currentx+1][currenty+1] = 0;
                    layout[currentx][currenty+1] = 0;
                    layout[currentx+1][currenty] = 0;
                    //layout[currentx][currenty] = 0;
                break;
                case 2:
                    layout[currentx+1][currenty+1] = 0;
                    layout[currentx][currenty+1] = 0;
                    //layout[currentx+1][currenty] = 0;
                    layout[currentx][currenty] = 0;
                break;
                case 3:
                    //layout[currentx+1][currenty+1] = 0;
                    layout[currentx][currenty+1] = 0;
                    layout[currentx+1][currenty] = 0;
                    layout[currentx][currenty] = 0;
                break;

            }
//            layout[currentx+1][currenty+1] = 0;
//            layout[currentx][currenty+1] = 0;
//            layout[currentx+1][currenty] = 0;
//            layout[currentx][currenty] = 0;
        }
        else {
//            for (int i=0; i<enemyw; i++) {
//                for (int j=0; j<enemyh; j++) {
//                    layout[enemyx+i][enemyy+j] = 0;
//                }
//            }
            for (int i=0; i<blackstone.length; i++) {
              //  if (blackstone[i][1]<totaly-UPBLACKSTONEH) {
                   layout[blackstone[i][0]][blackstone[i][1]] = 0;
              //  }
            }
        }
    }

    public boolean checkCollision(int x, int y) {
            //System.out.println("this is check collision");
			if (y==totaly-1) {
               return true;

            }
            else if (layout[x][y]==0) {
             //  System.out.println("collide1"+x+" "+y);
               return true;
            }
            else if (layout[x][y+1]!=0) {

               return true;
            }

            return false;

    }

    public boolean checkBlockCollision(int direction) {
           //System.out.println("this is check Block collision");
		   switch(direction) {
                case DOWN:
                   //  System.out.print(currentx+" "+currenty);
                     switch(currentposition) {
                        case 0:
                             if (checkCollision(currentx, currenty) || checkCollision(currentx+1, currenty+1)){
                               // System.out.println("check0");
                                return true;
                             }
                             break;
                        case 1:
                        case 2:
                             if (checkCollision(currentx, currenty+1) || checkCollision(currentx+1, currenty+1)){
                               // System.out.println("check1");
                                return true;
                             }
                             break;
                        case 3:
                             if (checkCollision(currentx, currenty+1) || checkCollision(currentx+1, currenty)){
                               // System.out.println("check2");
                                return true;
                             }
                             break;
                     }
                     break;
                case LEFT:
                     if (currentx==0) {
                        return true;
                     }

                     switch(currentposition) {
                        case 0:
                             if (layout[currentx-1][currenty]!=0 || layout[currentx][currenty+1]!=0) {
                                return true;
                             }
                             break;
                        case 1:
                             if (layout[currentx][currenty]!=0 || layout[currentx-1][currenty+1]!=0) {
                                return true;
                             }
                             break;
                        case 2:
                        case 3:
                             if (layout[currentx-1][currenty]!=0 || layout[currentx-1][currenty+1]!=0) {
                                return true;
                             }
                             break;
                     }
                     break;
                case RIGHT:
                     if (currentx==totalx-2) {
                        return true;
                     }
                     switch(currentposition) {
                        case 0:
                        case 1:
                             if (layout[currentx+2][currenty]!=0 || layout[currentx+2][currenty+1]!=0) {
                                return true;
                             }
                             break;
                        case 2:
                             if (layout[currentx+1][currenty]!=0 || layout[currentx+2][currenty+1]!=0) {
                                return true;
                             }
                             break;
                        case 3:
                             if (layout[currentx+2][currenty]!=0 || layout[currentx+1][currenty+1]!=0) {
                                return true;
                             }
                             break;
                     }
                     break;
           }
           return false;
    }

    public void domatch() {
           if (!isCheckingAI) {
              resetc_layout();
           }
           matchfinished = true;
           for (int i=totalx; i>0; i--) {
               for (int j=totaly; j>0; j--) {
                   if (!checkCollision(i-1, j-1)&& layout[i-1][j-1]!=BLACKBLOCK2) {
                      // System.out.println((i-1)+" "+(j-1));
                       layout[i-1][j]=layout[i-1][j-1];
                       layout[i-1][j-1] = 0;
                       if (!isCheckingAI) {
                           c_layout[i-1][j]=-c_layout[i-1][j-1];
                           c_layout[i-1][j-1] = 0;
                       }
                       matchfinished = false;

                   }
               }
           }

    }

    public void resetc_layout() {
        for (int i=0; i<totalx; i++) {
            for (int j=0; j<totaly; j++) {
                c_layout[i][j] = layout[i][j];
            }
        }
    }

    public boolean roundfinish = false;
    Vector clearVlist = null;
    Vector clearHlist = null;
    public void doclear() {

        roundfinish = true;


        couplenumber = 0;
        clearVlist = checkverticalclear(0);

        clearHlist = checkhorizontalclear(0);


       // System.out.println("test111");
        while (clearVlist.size()>leastclearBlock-1) {
              roundfinish = false;
              int[] tmp = null;
              boolean checkcolor = true;
              for (int i=0; i<clearVlist.size(); i++) {

                    tmp = (int[])clearVlist.elementAt(i);
                    if (checkcolor) {
                       combocolor.addElement(String.valueOf(layout[tmp[0]][tmp[1]]));
                       checkcolor = false;
                    }

                    if (!isCheckingAI) {
                       c_layout[tmp[0]][tmp[1]] = 101*layout[tmp[0]][tmp[1]];

                    }
                   // System.out.println("clearing: "+c_layout[tmp[0]][tmp[1]]);
                    layout[tmp[0]][tmp[1]] = 0;
                    clearnumber++;

              }
              clearVlist = checkverticalclear(tmp[0]+1);
              clearcombo++;
        }


        while (clearHlist.size()>leastclearBlock-1) {
              roundfinish = false;
              int[] tmp = null;
              boolean checkcolor = true;
              for (int i=0; i<clearHlist.size(); i++) {
                    tmp = (int[])clearHlist.elementAt(i);
                    if (checkcolor) {
                       combocolor.addElement(String.valueOf(layout[tmp[0]][tmp[1]]));
                       checkcolor = false;
                    }

                    if (!isCheckingAI) {
                       c_layout[tmp[0]][tmp[1]] = 101*layout[tmp[0]][tmp[1]];

                    }
                    layout[tmp[0]][tmp[1]] = 0;
                    clearnumber++;

              }
              clearHlist = checkhorizontalclear(tmp[1]+1);
              clearcombo++;
        }

        if (clearcombo<0)
            clearcombo = 0;
        matchfinished = false;
    }

    public Vector checkhorizontalclear(int startline) {

        Vector clearlist = new Vector();
       // boolean clearenemyReady = true;

        for (int i=startline; i<totaly; i++) {
            for (int j=0; j<totalx; j++) {
                if (layout[j][i]!=0 && layout[j][i]!=BLACKBLOCK && layout[j][i]!=BLACKBLOCK2) {
                    if (clearlist.isEmpty()) {
                            clearlist.addElement(new int[]{j, i});
                       //     System.out.println("newadd: "+j+" "+ i);
                    }
                    else {
                       if ((layout[j-1][i]!=layout[j][i])) {

                          if (clearlist.size()>=leastclearBlock) {
                               int length = clearlist.size();
                               for (int t=0; t<length; t++) {
                                   clearlist = checkenemyclear(clearlist, t);
                                //   System.out.println("test332");
                               }
                             //  System.out.println("test333");
                               return clearlist;
                          }else {
                                couplenumber = couplenumber+clearlist.size()-1;
//                                System.out.println("couple: "+couplenumber);
                               //  System.out.println("size: "+clearlist.size());
                          }
                          clearlist = new Vector();

                       }

                       clearlist.addElement(new int[]{j, i});
                       //System.out.println("add: "+j+" "+ i);

                    }
                }
            }
           if ((clearlist.size()>=leastclearBlock)) {
                int length = clearlist.size();
                for (int t=0; t<length; t++) {
                    clearlist = checkenemyclear(clearlist, t);
                    //System.out.println("test331");
                }
              //  System.out.println("test334");
                return clearlist;
           }else if (clearlist.size()>0){
                                couplenumber = couplenumber+clearlist.size()-1;
//                                System.out.println("couple: "+couplenumber);
                               //  System.out.println("size: "+clearlist.size());
           }

           clearlist = new Vector();

        }
        return clearlist;
    }

    public Vector checkenemyclear(Vector list, int index) {
           int[] temp = (int[])list.elementAt(index);
           if (temp[0]>0) {
            //  System.out.println("test1");
              if (layout[temp[0]-1][temp[1]] == BLACKBLOCK || layout[temp[0]-1][temp[1]] == BLACKBLOCK2) {
             //    System.out.println("test1-1");
                 list.addElement(new int[]{temp[0]-1, temp[1]});
              }
           }
           if (temp[0]<totalx-1) {
             // System.out.println("test2");
              if (layout[temp[0]+1][temp[1]] == BLACKBLOCK || layout[temp[0]+1][temp[1]] == BLACKBLOCK2) {
              //   System.out.println("test2-1");
                 list.addElement(new int[]{temp[0]+1, temp[1]});
              }
           }
           if (temp[1]>2) {
             // System.out.println("test3");
              if (layout[temp[0]][temp[1]-1] == BLACKBLOCK || layout[temp[0]][temp[1]-1] == BLACKBLOCK2) {
              //   System.out.println("test3-1");
                 list.addElement(new int[]{temp[0], temp[1]-1});
              }
           }
           if (temp[1]<totaly-1) {
             // System.out.println("test4");
              if (layout[temp[0]][temp[1]+1] == BLACKBLOCK || layout[temp[0]][temp[1]+1] == BLACKBLOCK2) {
              //   System.out.println("test4-1");
                 list.addElement(new int[]{temp[0], temp[1]+1});
              }
           }
           return list;
    }

    public Vector checkverticalclear(int startcolumn) {

        Vector clearlist = new Vector();
        for (int i=startcolumn; i<totalx; i++) {
            for (int j=0; j<totaly; j++) {
                if (layout[i][j]!=0 && layout[i][j]!=BLACKBLOCK && layout[i][j]!=BLACKBLOCK2) {
                    if (clearlist.isEmpty()) {
                       clearlist.addElement(new int[]{i, j});
                   //    System.out.println("newadd: "+j+" "+ i);
                    }
                    else {

                       if ((layout[i][j-1]!=layout[i][j])) {
                          //System.out.println("check1");

                          if (clearlist.size()>=leastclearBlock) {
                               int length = clearlist.size();
                               for (int t=0; t<length; t++) {
                                   clearlist = checkenemyclear(clearlist, t);
                                 //  System.out.println("test221");
                               }
                             //  System.out.println("test222");
                               return clearlist;
                          }else {
                                couplenumber = couplenumber+clearlist.size()-1;
//                                System.out.println("couple: "+couplenumber);
                                 //System.out.println("size: "+clearlist.size());
                          }
                          clearlist = new Vector();

                       }

                       clearlist.addElement(new int[]{i, j});
                      // System.out.println("add: "+j+" "+ i);

                    }
                }
            }
           if ((clearlist.size()>=leastclearBlock)) {
                int length = clearlist.size();
                for (int t=0; t<length; t++) {
                    clearlist = checkenemyclear(clearlist, t);
                   // System.out.println("test220");
                }
               // System.out.println("test223");
                return clearlist;
           }else if (clearlist.size()>0){
                                couplenumber = couplenumber+clearlist.size()-1;
//                                System.out.println("couple: "+couplenumber);
                                 //System.out.println("size: "+clearlist.size());
           }

           clearlist = new Vector();

        }
        return clearlist;
    }

    public void enemydropDown() {

        dropfinished = false;
        boolean col = false;

        for (int i=0; i<blackstone.length; i++) {
            //System.out.println("no: "+i);
            if (checkCollision(blackstone[i][0], blackstone[i][1])) {
                 //System.out.println("collide: "+blackstone[i][0]+" "+ blackstone[i][1]);
                 col = true;
                  break;
            }
        }
        if (!col) {

           clearBlock();
           for (int i=0; i<blackstone.length; i++) {
                blackstone[i][1]++;
            }
           //enemyy++;
           loadlayout();

        }
        else {
            dropfinished = true;
            enemyinited = false;
            //enemyturn = false;
        }
    }

    boolean dropfinished = false;
    boolean matchfinished = false;
    public void dropDown() {
          //int collide = 0;
      if (!onclick) {
        dropfinished = false;
        onclick = true;
		if (!checkBlockCollision(DOWN)) {
                 //    System.out.println("down");
           clearBlock();
           currenty++;
           loadlayout();

        }
        else {
           dropfinished=true;
        }
        onclick = false;
      }
    }

    public void genNextBlock() {
         //System.out.println("checkcheck");
        nextcolors = new int[colortotal];
        for (int i=0; i<colortotal; i++) {
            nextcolors[i] = (random(colortotal))+1;
        }
        nextposition = random(4);
        //System.out.println("checkcheck2");

    }

    public void initblackstone() {
       // enemyinited = true;
       // enemyturn = true;
        //if (drop) {
            matchfinished = false;
            dropfinished = false;


        //}
        //if (!drop){

            int enemyh = 0;
            for (int i=0; i<blackstone.length; i++) {
                //System.out.println(blackstone[i][0]+ " "+blackstone[i][1]);
                //System.out.println("top:"+(totaly-3-UPBLACKSTONEH));
                if (blackstone[i][1]>totaly-3-UPBLACKSTONEH) {
                     blackstone[i][1] = blackstone[i][1] + 2;
                    // System.out.println("check: "+(totaly - blackstone[i][1]));
                     if((totaly - blackstone[i][1])>enemyh) {
                          enemyh=totaly - blackstone[i][1];
                     }

                }
            }
            System.out.println("enemyh: "+enemyh);
            //int enemyh = blackstone.length/totalx +1;
            for (int i=0; i<totaly; i++) {
                 for (int j=0; j<totalx; j++) {

                     if (i>=totaly-enemyh) {
                        layout[j][i] = BLACKBLOCK;
                     }else {
                        layout[j][i] = layout[j][i+enemyh];
                     }
                 }
            }
    //    }
        loadlayout();

    }


    public void initCurrentBlock() {
           matchfinished = false;
           dropfinished = false;

           currentx = totalx / 2 - 1;
           currenty = 0;
           currentcolors = nextcolors;
           currentposition = nextposition;
           loadlayout();
    }

    //ROTATE THE STONE FOR ONCE
    public void rotate() {
      if (!onclick) {
         onclick = true;
         if (!checkBlockCollision(DOWN)) {
             clearBlock();
             currentposition++;
             if (currentposition>3) {
                currentposition = 0;
             }

             loadlayout();
        }
//         if (checkBlockCollision(DOWN)) {
//         //}else {
//            currentposition--;
//            if (currentposition<0) {
//               currentposition = 3;
//            }
//            clearBlock();
//            loadlayout();
//         }
           onclick = false;
        }
    }
    public boolean onclick = false;
    public void move(int direction) {
      if (!onclick) {
         onclick = true;
         //if (!enemyinited) {
       //      if (!checkBlockCollision(DOWN)) {
                 switch(direction) {
                     case LEFT:
                          if (!checkBlockCollision(LEFT)) {
                             clearBlock();
                             currentx--;
                           //  loadlayout();
                          }
        //                  if (checkBlockCollision(DOWN)) {
        //
        //                     currentx++;
        //                     clearBlock();
        //                  }
                          break;
                     case RIGHT:
                          if (!checkBlockCollision(RIGHT)) {
                             clearBlock();
                             currentx++;
                            // loadlayout();
                          }
        //                  if (checkBlockCollision(DOWN)) {
        //
        //                     currentx--;
        //                     clearBlock();
        //                  }
                          break;
                     case DOWN:
                          if (!checkBlockCollision(DOWN)) {
                             clearBlock();

                                currenty++;
//                             while(!dropfinished) {
//                                dropDown();
//                             }
                           //  System.out.println("move down");
                          }

                          break;
                 }
        //    }
             loadlayout();
//         }else if (direction==DOWN){
//               enemydropDown();
//         }
         onclick = false;
       }
    }

    //boolean enemyturn = false;
    public void loadlayout() {
        //System.out.println("currenty: "+currenty);
        //System.out.println("currentp: "+currentposition);
        if (!isCheckingAI) {
           resetc_layout();
        }
        //System.out.println("abc");
        if (!enemyinited) {
            switch(currentposition)
            {
                case 0:
                     layout[currentx][currenty] = currentcolors[0];
                     layout[currentx+1][currenty] = currentcolors[1];
                     layout[currentx+1][currenty+1] = currentcolors[2];
                     if (!isCheckingAI) {
                         c_layout[currentx][currenty] = -currentcolors[0];
                         c_layout[currentx+1][currenty] = -currentcolors[1];
                         c_layout[currentx+1][currenty+1] = -currentcolors[2];
                     }
                     break;
                case 1:
                     layout[currentx+1][currenty] = currentcolors[0];
                     layout[currentx+1][currenty+1] = currentcolors[1];
                     layout[currentx][currenty+1] = currentcolors[2];
                     if (!isCheckingAI) {
                         c_layout[currentx+1][currenty] = -currentcolors[0];
                         c_layout[currentx+1][currenty+1] = -currentcolors[1];
                         c_layout[currentx][currenty+1] = -currentcolors[2];
                     }
                     break;
                case 2:
                     layout[currentx+1][currenty+1] = currentcolors[0];
                     layout[currentx][currenty+1] = currentcolors[1];
                     layout[currentx][currenty] = currentcolors[2];
                     if (!isCheckingAI) {
                         c_layout[currentx+1][currenty+1] = -currentcolors[0];
                         c_layout[currentx][currenty+1] = -currentcolors[1];
                         c_layout[currentx][currenty] = -currentcolors[2];
                     }
                     break;
                case 3:
                     layout[currentx][currenty+1] = currentcolors[0];
                     layout[currentx][currenty] = currentcolors[1];
                     layout[currentx+1][currenty] = currentcolors[2];
                     if (!isCheckingAI) {
                         c_layout[currentx][currenty+1] = -currentcolors[0];
                         c_layout[currentx][currenty] = -currentcolors[1];
                         c_layout[currentx+1][currenty] = -currentcolors[2];
                     }
                     break;
            }
           // System.out.println("layout "+layout[currentx][currenty]);
        }
          else {
        //       System.out.println("check3");
               for (int i=0; i<blackstone.length; i++) {
                    //for (int j=0; j<2; j++) {
          //                System.out.println(blackstone[i][0]+" "+blackstone[i][1]);
                     // if (blackstone[i][1]<totaly-2-UPBLACKSTONEH) {
                         // System.out.println(blackstone[i][0]+" "+blackstone[i][1]);
                          layout[blackstone[i][0]][blackstone[i][1]] = BLACKBLOCK;
                          c_layout[blackstone[i][0]][blackstone[i][1]] = -BLACKBLOCK;
                    //  }
                }

          }
         // onclick = false;
    }

    public boolean checkgameover() {
        boolean result = false;
        // System.out.println("checkstart ");
        for (int i=0; i<totalx; i++) {
            if (layout[i][2]!=0) {
               //System.out.println("hit: "+i);
               result = true;
               return result;
            }
        }
        // System.out.println("checkover ");
        return result;
    }

    public static int random(int maxvalue) {
        int a = -1;

          a = randomobj.nextInt();
          if (a < 0)
            a = -a;
          a = a % maxvalue;
        return a ;
    }
    public boolean gameover = false;
    public void run()
	{
		long starttime = 0;
        long sleeptime = 0;
        roundstarttime = System.currentTimeMillis();
        genNextBlock();
		while (!checkgameover()) {
		    //initCurrentBlock();
		    //System.out.println("check1");

//            if (random(2)==0)          //for test
//                enemyturn = true;
//            else
//                enemyturn = false;
            if (enemyturn) {
                   enemyinited = true;
                   enemyturn = false;
                   initblackstone();
//                 blackstone = new int[][]{{0, 0}, {2, 0}, {4, 0}, {6, 0}};
//                 initblackstone();

            }
            else {
                initCurrentBlock();
                genNextBlock();

            }
            roundfinish = false;

            System.out.println("clearcombo: "+clearcombo);
            System.out.println("clearnumber: "+clearnumber);
		    while (!roundfinish) {

        		starttime = System.currentTimeMillis();
        		if (!pause) {
        		   doAction();
        		   roundstarttime = System.currentTimeMillis();
        		}
        		for (int i=0; i<combocolor.size(); i++) {
        		    System.out.println("combo "+Integer.parseInt((String)combocolor.elementAt(i)));
        		}
//        		for (int j=0; j<totaly; j++) {
//                              for (int i=0; i<totalx; i++) {
//                                  if (layout[i][j] == 0) {
//                                     System.out.print(". ");
//                                  } else {
//                                     System.out.print(layout[i][j]+" ");
//                                  }
//                              }
//                              System.out.print("     ");
//                              for (int i=0; i<totalx; i++) {
//                                  if (c_layout[i][j] == 0) {
//                                     System.out.print(". ");
//                                  } else {
//                                     System.out.print(c_layout[i][j]+" ");
//                                  }
//                              }
//                              System.out.println();
//                          }
        		sleeptime = STEP_TIME - (System.currentTimeMillis() - starttime);

    			if (sleeptime > 0)
    			{
    				try
    				{
    					DinoStone.sleep(sleeptime);
    				} catch (Exception e)
    				{
    				}
    			}
    		}
		}
		gameover = true;
	}

    public void doAction() {

                    if (!dropfinished) {
                         clearcombo = -1;
                         clearnumber = 0;
                         combocolor = new Vector();
                        // System.out.println("onclick: "+onclick);
                         if (enemyinited) {
                            for (int i=0; i<3; i++) {
                              enemydropDown();
                              if (dropfinished)
                                 break;
                            }
                         }
                         else {
                             // if (!onclick)
                                 dropDown();

                         }

                      }
                      else if (!matchfinished){
                         //System.out.println("matching");

                         domatch();
                      }
                      if (matchfinished) {
                          doclear();



                      }

    }
}