package paopao;

import javax.microedition.lcdui.*;
import java.util.Hashtable;
import java.io.InputStream;
import com.nokia.mid.ui.*;

public class GameWorld extends FullCanvas implements Runnable{
final int screenW = getWidth();
final int screenH = getHeight();
final int paintW = 128;
final int paintH = 208 - 3;
final int orgX = 7;
final int orgY = 3;
final int midX = paintW / 2;
final int midY = paintH / 2;
//score
int score;
//Thread
boolean killThread  = false;
boolean pauseThread = false;
boolean overThread  = false;
int overCount;
Thread thread = null;
int interval = 50;
//hardlevel setting
int hardLevel;
final int EASY   = 9;
final int MIDDLE = 8;
final int HARD   = 6;
int shakeAt;                    //when ball shooted number equals or more then it shakes
boolean shaking = false;
int shakeOffX[];
// top press
int pressCount;                //round intervals per top down count
int shakeCount;
int nowTop;
//angle
int angle  = 90;
int _angle = 6;
int angleSinValue;
int angleCosValue;
//paopao
int nextOneColor;
int toBeShootColor;
int isMovingColor;
boolean isMoving = false;    //擊出的球是否處于運動過程中
int shootAngle;
int v = 10;
int timeCount;
final int effectiveR = 8;
final int localStand = 6;
int startX;
int startY;
int nowX;
int nowY;
boolean hitted = false;
int hittedI;
int hittedJ;
//falling
int fallingNum ;
int[][] fallingPara;
int fallingV = 8;
//time

//round
int[][] roundPara;
int roundCount;                  //read roundPara from map.txt & count
boolean roundStart = true;
int roundStartCount;
int round = 1;

//
int disappearCount;
  /** Constructor */
  public GameWorld(int hardLevel) {
    this.hardLevel = hardLevel;
    try {
      jbInit();
    }
    catch(Exception e) {
      e.printStackTrace();
    }
  }

  protected void show()
  {
  if(thread == null)
    thread = new Thread(this);
    thread.start();
  }
  /**Component initialization*/
  private void jbInit() throws Exception {
  roundPara = new int[11][8];
  this.readroundPara();
  switch(hardLevel)
  {
  case EASY:
  shakeAt = 6;
  break;
  case MIDDLE:
  shakeAt = 5;
  break;
  case HARD:
  shakeAt = 4;
  break;
  default:
  break;
  }
  toBeShootColor =  1 + Math.abs(Resource.random.nextInt() % 8);
  nextOneColor   = 1 + Math.abs(Resource.random.nextInt() % 8);
  fallingPara = new int[50][3];
  shakeOffX = new int[]{1,1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1};
// Set up this Displayable to listen to command events
    // add the Exit command
  }
  private  void readroundPara()
    {
      InputStream is = null;
     try{
        is = getClass().getResourceAsStream("/round.txt");
        }
      catch(Exception e)
        {}
      int symbol;
      try{
  while((symbol = is.read()) != -1)
   {
          if(symbol == '&')
              {
            roundCount ++;
            if(roundCount == round)
                   {
               for(int i = 0;i < 5;i ++)
               is.read();
               int symbol2;
               int rowCount  = 0;
               int lineCount = 0;
               while((symbol2 = is.read()) != '&')
                      {
                   if(symbol2 == '\r')
                           {
                     rowCount ++;
                     lineCount = 0;
                     is.read();
                           }
                    else roundPara[rowCount][lineCount ++] = (int)symbol2 - 48;
                      }
                  break;
                   }
                }
   }

         }
      catch(Exception ex)
      {
      }

    }
private void nextPaoPao()
  {
  isMovingColor = toBeShootColor;
  toBeShootColor = nextOneColor;
  nextOneColor = 1 + Math.abs(Resource.random.nextInt() % 8);
  }
protected void keyPressed(int keyCode)
  {
if(!pauseThread)
    {
if(keyCode == -6)
PaoPao.quitApp();
else if((keyCode == -5 || keyCode == 53) && isMoving  == false)
  shoot();
else if(keyCode == -3)
    {
      if(angle < 174)
      angle += 6;
    }
else if(keyCode == -4)
    {
      if(angle > 6)
      angle -= 6;
    }
else if(keyCode == -1)
           {
           if(angle == 90)
             return;
           angle = (angle > 90 ? angle - 6 : angle + 6);
           }

    }      //if(!pauseThread)
  }
  /**Handle command events*/
synchronized private void shoot()
  {
//pressCount ++;
//pressCount %= hardLevel;
//if(pressCount >= shakeAt)
//shaking = true;
//if(pressCount == 0)
//topDown();
startX = 71 - orgX;
startY = 170 - orgY;
nowX = startX;
nowY = startY;
shootAngle = angle;
angleSinValue = Resource.getSinAngleValue(shootAngle);
angleCosValue = Resource.getCosAngleValue(shootAngle);
isMoving = true;
timeCount = 0;
nextPaoPao();
  }
private void topDown()
  {
nowTop ++;
shaking = false;
  }
 public void run()
 {
 while(!killThread)
     {
     if(!pauseThread)
        {
      if(!overThread)
            {
     if(roundStart)
              {
                 roundStartCount ++;
                if(roundStartCount >= 48)
                 {
                roundStartCount = 0;
                roundStart = false;
                 }
              }
              if(isMoving)    //被擊出的球處于運動狀態中
                {
                  paoPaoMoving();
                }
               Falling();
               if(disappearCount > 0)
               {
                 disappearCount --;
                 if(disappearCount == 0)
                   for(int i = 0;i < 10;i ++)
                     for(int j = 0;j < (i % 2 == 0 ? 8 : 7);j ++)
                     {
                     if(roundPara[i][j] > 8 && roundPara[i][j] < 17)
                       roundPara[i][j] = 0;
                     }
               }
               if(shaking)
               {
              shakeCount ++;
              shakeCount %= 16;
               }
                try
                {
                repaint();
                thread.sleep(interval);
                }
                catch(Exception ex){}
            }          //if(!overThread)
      //overCount ++;
     // if(overCount >= paintH - nowTop * 14)
      //  killThread = true;
        }
     }               //while(!killThread)
//System.out.println("killThread = "+ killThread);
         this.serviceRepaints();
         System.gc();
         PaoPao.shiftCanvas(PaoPao.MENU_ID,0);

 }
private void Falling()
 {
 if(fallingNum > 0)
  {
 for(int i = 0;i < fallingNum;i ++)
    {
    fallingPara[i][2] += fallingV;
    }
  }

for(int i = 0;i < fallingNum;i ++)
  {
 if(fallingPara[i][2] > paintH + 8)
   {
    for(int j = i;j < fallingNum - 1;j ++)
    {
    fallingPara[j][0] = fallingPara[j + 1][0];
    fallingPara[j][1] = fallingPara[j + 1][1];
    fallingPara[j][2] = fallingPara[j + 1][2];
    }
    fallingNum--;
   }
  }

 }

 private void paoPaoMoving()
 {
int posX = 0;
int posY = 0;
int preX;
int preY;
int pre_x;
int pre_y;
preX = nowX;
preY = nowY;
pre_x = nowX;
pre_y = nowY;
if(hitted)
   {
   hitted = !hitted;
   dealWithHit(hittedI,hittedJ);
   return;
   }
   timeCount ++;
   posX = startX + (timeCount * v) * angleCosValue / 100000;
   posY = startY - (timeCount * v) * angleSinValue / 100000;
   while(true)
   {
   if(posX  - 8 < 0)
      {
     startX = 8;
     startY = nowY;
     nowX   = 8;
     timeCount = 0;
     angleCosValue = 0 - angleCosValue;
     //timeCount ++;
     break;
      }
   else if(posX + 8 > paintW)
      {
     startX = paintW - 8;
     startY = nowY;
     nowX   = paintW - 8;
     timeCount = 0;
     angleCosValue = 0 - angleCosValue;
     //timeCount ++;
     break;
      }
   else if(posY - 8 <= 0)                      //reach the top
      {
     this.roundPara[0][posX / 16] = isMovingColor;
     nowX = posX;
     nowY = 8;
     checkConnect(0,nowX / 16,isMovingColor);
     if(checkDisappear())
       checkFall();
     isMoving = false;
     return;
      }
   else
      {
      nowX = posX;
      nowY = posY;
      break;
      }
   }

   if(nowY == 8)
     return;

   for(int i = 0;i < 10; i ++)
      {
   if(i % 2 == 0)
        {
      for(int j = 0;j < 8;j ++)
         {
     if(isCollided(nowX,nowY,j * 16 + 8,i * 14 + 8) && roundPara[i][j] > 0 && roundPara[i][j] < 9)
          {
            for(int m = 1;m <= v;m ++)
                       {

             preX = startX + ((timeCount - 1) * v + m) * angleCosValue / 100000;
             preY = startY - ((timeCount - 1) * v + m) * angleSinValue / 100000;
              if(isCollided(preX,preY,j * 16 + 8,i * 14 + 8))
                         {
                hitted = true;
                nowX = preX;
                nowY = preY;
                hittedI = i;
                hittedJ = j;
                break;
                         }
                       }
            return;
          }
         }
        }
   else if(i % 2 == 1)
        {
          for(int j = 0;j < 7; j ++)
          {
     if(isCollided(nowX,nowY,8 + j * 16 + 8,i * 14 + 8) && roundPara[i][j] > 0 && roundPara[i][j] < 9)
            {

              for(int m = 1;m <= v;m ++)
                                   {

              preX = startX + ((timeCount - 1) * v + m) * angleCosValue / 100000;
              preY = startY - ((timeCount - 1) * v + m) * angleSinValue / 100000;
              if(isCollided(preX,preY,8 + j * 16 + 8,i * 14 + 8))