//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////[WARNING] NEW_CLASS [WARNING]///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////

////////////**                                                          **////////////
//      --------------------- START SHOTS MANEGING CLASS ---------------------      //
////////////**                                                          **////////////

public class shots_mng
{
  float refX, refY, refDir;
  
  float dir;       //-- sMan[0][0][0]
  float velo;      //-- sMan[0][0][1]
  int behavior;    //-- sMan[0][0][2]
  int sNum;        //-- sMan[0][0][3]
  float sizer;     //-- sMan[0][0][4]
  int drawType;    //-- sMan[0][0][5]
  color clr;       //-- sMan[0][0][6]
  
  float dirR;       //-- sMan[0][0][0]
  float veloR;      //-- sMan[0][0][1]
  int behaviorR;    //-- sMan[0][0][2]
  int sNumR;        //-- sMan[0][0][3]
  float sizerR;     //-- sMan[0][0][4]
  int drawTypeR;    //-- sMan[0][0][5]
  color clrR;       //-- sMan[0][0][6]
  
  int repeat;      //-- sMan[0][1][0]
  int rFrames;     //-- sMan[0][1][1]
  float reDevider;
  
  int angMod;      //-- sMan[0][1][2]
  float angInc;    //-- sMan[0][1][3]
  float angRang;   //-- sMan[0][1][4]
  float resDir;    //-- sMan[0][1][5]
  float tX, tY;    //-- sMan[0][1][6]
  
  int spdMod;      //-- sMan[0][2][0]
  float rSpd1;     //-- sMan[0][2][1]
  float rSpd2;     //-- sMan[0][2][2]
  float spdInc;    //-- sMan[0][2][3]
  float inLet1;    //-- sMan[0][2][4]
  float inLet2;    //-- sMan[0][2][5]
  
  int mltMod;      //-- sMan[0][3][0]
  float mTempAng;  //-- sMan[0][3][1]
  float mTempSpd;  //-- sMan[0][3][2]
  float mTempX;    //-- sMan[0][3][3]
  float mTempY;    //-- sMan[0][3][4]
  float midRange;  //-- sMan[0][3][5]
  float mltRange;  //-- sMan[0][3][6]
  float par1;      //-- sMan[0][4][0]
  float par2;      //-- sMan[0][4][1]
  float mltSpd;    //-- sMan[0][4][2]
  
  float nBeh[][];  //-- sMan[0][4][3]
  int listCnt;     //-- sMan[0][4][4]
  int listChk;     //-- sMan[0][4][5]
  int momentList[];//-- sMan[0][4][6]
  
  
  
  shots_mng()
  {
    repeat = 0;
    rFrames = 0;
    angInc = 0;
    
  }
  
  ///////////////////////////////////////////////////////
  ///////////---------CLONER SEQUENCE---------///////////
  ///////////////////////////////////////////////////////
  
  public shots_mng cloner()
  {
    shots_mng clone = new shots_mng();
    
    clone.refX = refX;
    clone.refY = refY;
    clone.refDir = refDir;
    
    clone.dir = dir;
    clone.velo = velo;
    clone.behavior = behavior;
    clone.sNum = sNum;
    clone.sizer = sizer;
    clone.drawType = drawType;
    clone.clr = clr;
    
    clone.dirR = dirR;
    clone.veloR = veloR;
    clone.behaviorR = behaviorR;
    clone.sNumR = sNumR;
    clone.sizerR = sizerR;
    clone.drawTypeR = drawTypeR;
    clone.clrR = clrR;
    
    clone.repeat = repeat;
    clone.rFrames = rFrames;
    clone.reDevider = reDevider;
    
    clone.angMod = angMod;
    clone.angInc = angInc;
    clone.angRang = angRang;
    clone.resDir = resDir;
    clone.tX = tX;
    clone.tY = tY;
    
    clone.spdMod = spdMod;
    clone.rSpd1 = rSpd1;
    clone.rSpd2 = rSpd2;
    clone.spdInc = spdInc;
    clone.inLet1 = inLet1;
    clone.inLet2 = inLet2;
    
    clone.mltMod = mltMod;
    clone.mTempAng = mTempAng;
    clone.mTempSpd = mTempSpd;
    clone.mTempX = mTempX;
    clone.midRange = midRange;
    clone.mltRange = mltRange;
    clone.par1 = par1;
    clone.par2 = par2;
    clone.mltSpd = mltSpd;
    
    clone.nBeh = karkov(nBeh);
    clone.listCnt = listCnt;
    clone.listChk = listChk;
    clone.momentList = karkov(momentList);
    
    return clone;
  }
  
  ///////////////////////////////////////////////////////////
  ///////////---------CLONER SEQUENCE END---------///////////
  ///////////////////////////////////////////////////////////

  void update(float pX, float pY, float shipDir)
  {
    refX = pX; 
    refY = pY; 
    refDir = shipDir;

    repeater();

    if (angMod == 5 || angMod == 7)
    {
      dir = resDir;
    }
    
    drawPoint();
  }
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //VERY TEMPORARY. JUST TO CHECK WERE THE SHOOTING POINTS ARE IN POSITION: relates 3 lines above//
  /////////////////////////////////////////////////////////////////////////////////////////////////
  
  void drawPoint()
  {
    stroke(#00FFFF);
    noFill();
    line(refX, refY, refX + cos(refDir)*10, refY + sin(refDir)*10);
    ellipseMode(CENTER);
    stroke(#FF0000);
    ellipse(refX, refY, 7, 7);
  }
  
  //////////////////////////////////////////////////////////////////////////
  //VERY TEMPORARY. JUST TO CHECK WERE THE SHOOTING POINTS ARE IN POSITION//
  //////////////////////////////////////////////////////////////////////////
  
  public void newShot(float par1, float par2, int par4, float par5, int par6, color par7)
  {
    dir = par1;
    velo = par2;
    behavior = par4;
    sNum = 1;
    sizer = par5;
    drawType = par6;
    clr = par7;
    
    dirR = par1;
    veloR = par2;
    behaviorR = par4;
    sNumR = 1;
    sizerR = par5;
    drawTypeR = par6;
    clrR = par7;
    
    angMod = 0;
    spdMod = 0;
    mltMod = 0;
    
    angInc = 0;
    rSpd1 = 0.5;
    rSpd2 = 80;
    mltSpd = 0;
    
    nBeh  = new float [5][5];
    momentList = new int [1];
    listCnt = 0;
  }
  
  public void newShot(float par1, float par2)
  {
    dir = par1;
    velo = par2;
    behavior = 101;
    sNum = 1;
    sizer = 1;
    drawType = 101;
    clr = s[0];
    
    dirR = par1;
    veloR = par2;
    behaviorR = 101;
    sNumR = 1;
    sizerR = 1;
    drawTypeR = 101;
    clrR = s[0];
    
    angMod = 0;
    spdMod = 0;
    mltMod = 0;
    
    angInc = 0;
    rSpd1 = 0.5;
    rSpd2 = 80;
    mltSpd = 0;
    
    nBeh  = new float [5][5];
    momentList = new int [1];
    listCnt = 0;
  }
  
  public shots getShot()
  {
    shots sTemp;
    switch(behavior)
    {
      case 00:
        sTemp = new shot00(refX, refY, dir, velo, sizer, drawType, clr);
        break;
        
      case 01:
        sTemp = new shot01(refX, refY, dir, velo, sizer, drawType, clr, nBeh, momentList);
        break;
        
      case 02:
        sTemp = new shot02(refX, refY, dir, velo, sizer, drawType, clr, nBeh, momentList);
        break;
        
      case 101:
        sTemp = new shot01(refX, refY, dir, velo, sizer, drawType, clr, nBeh, momentList);
        break;
        
      default:
        sTemp = new shot00(refX, refY, dir, velo, sizer, drawType, clr);
        break;
    }
    return sTemp;
    
  }
  
  //-----------SHOOTING_FUNCTIONS-----------//
  public void shoot()
  {
    if (refX >= 0 && refX <= 256 && refY >= 0 && refY <= 240){
      repeat = 1; 
      rFrames = 1;
      reDevider = 1;
      sNumR = sNum;
    }
  }

  public void shoot(int rep, int rFra)
  {
    if (refX >= 0 && refX <= 256 && refY >= 0 && refY <= 240){
      repeat = rep; 
      rFrames = rFra;
      reDevider = rep;
    }
  }

  void repeater()
  {
    if(repeat > 0 && (frameCount % rFrames) == 0)
    {
      angler();
      speeder();
      repeat -= 1;
      //newShot(dir, velo, shotType, behavior, shotNum, sizer, drawType, clr);
      doShot();
    }

    if (repeat <= 0)
    {
      sNum = sNumR;
    }
  }
  //-----ATTN ATTN ATTN: TEMPORARLY HERE _ONLY_-----//
  void doShot()
  {
    int j = sNum;
    preMulti();
    for (int i = 0; i < shot.length; i++)
    {

      if (shot[i] == null)
      {
        shot[i] = getShot();
        multipler();
        //shot[i].beh = nBeh;
        j--;
      }
      if (j == 0)
      {
        break;
      }
    }
    posMulti();
  }

  //-----------ENDOF:SHOOTING_FUNCTIONS-----------//

  //-------------------------------------------------------------------------------------------//

  //-----------ANGLEMOD_FUNCTIONS-----------//

  //--ANGLE_FUNC_1--//
  public void angle(float increment)
  {
    angInc = increment; 
    angMod = 1; 
    dir -= increment;
  }

  //--ANGLE_FUNC_2--//
  public void angle(String cccp)
  {
    if (cccp == "rand")
    {
      angMod = 2;
    }
    else
      if (cccp == "fllw")
      {
        angMod = 3;
      }
      else
        if (cccp == "targ")
        {
          angMod = 4;
        }
        else
        {
          println("error_WRONG_ANGLE_INPUT");
        }
  }

  //--ANGLE_FUNC_3--//
  public void angle(String cccp, float range)
  {
    angRang = range/2;
    if (cccp == "rand")
    {
      angMod = 5;
      resDir = dir;
    }
    else
      if (cccp == "fllw")
      {
        angMod = 6;
      }
      else
        if (cccp == "sin")
        {
          angMod = 7;
        }
        else
          if (cccp == "sinf")
          {
            angMod = 8;
          }
          else
          {
            println("error_WRONG_ANGLE_INPUT");
          }
  }

  //--ANGLE_FUNC_4--//
  public void angle(float TX, float TY)
  {
    tX = TX; 
    tY = TY;
    angMod = 9;
  }
  //--ANGLE_FUNC_4--//
  public void angleMod(float ang)
  {
    dir = ang;
  }

  //--UPDATER_ANGLEMOD_FUNC--//
  void angler()
  {
    float angX, angY;
    switch(angMod)
    {
    default:
      break;

    case 1:
      dir += calc.difIN(angInc);
      break;

    case 2:
      dir = random(0, TWO_PI);
      break;

    case 3:
      dir = refDir;
      break;

    case 4:
      angX = refX - pShip.pX;
      angY = refY - pShip.pY;
      dir = calc.difIN(PI + atan2(angY, angX));
      break;

    case 5:
      float ang5 = calc.difIN(angRang);
      dir = resDir + random(-ang5, ang5);
      break;

    case 6:
      float ang6 = calc.difIN(angRang);
      dir = refDir + (random(-ang6, ang6));
      break;

    case 7:
      resDir = dir;
      dir = (sin(((TWO_PI * 1.3) / reDevider) * repeat) * angRang) + dir; 
      break;

    case 8:
      dir = (sin(repeat*0.25) * angRang) + refDir;
      break;

    case 9:
      angX = refX - tX;
      angY = refY - tY;
      dir = PI + atan2(angY, angX);
      break;
    }
  }
  //-----------ENDOF:ANGLEMOD_FUNCTIONS-----------//

  //-------------------------------------------------------------------------------------------//

  //-----------SPEEDMOD_FUNCTIONS-----------//

  //--SPEED_FUNC_1--//
  public void speed(float increment)
  {
    spdInc = increment; 
    spdMod = 1;
  }

  //--SPEED_FUNC_2--//
  public void speed(String cccp, float in1, float in2)
  {
    if (cccp == "rand")
    {
      inLet1 = in1;
      inLet2 = in2;
      spdMod = 2;
    }
    else
    if (cccp == "sin")
    {
      inLet1 = in1;
      inLet2 = in2;
      spdMod = 3;
    }
    else
    if (cccp == "goto")
    {
      if (in1 < velo)
      {
        rSpd1 = in1;
        rSpd2 = velo;
      }
      else
      {
        rSpd1 = velo;
        rSpd2 = in1;
      }
      
      spdInc = (in1 - velo) / in2;
      spdMod = 1;
    }
    else
    {
      println("error_WRONG_SPEED_INPUT");
    }
  }

  //--SPEED_FUNC_3--//
  public void speedMod(float newVelo)
  {
    velo = newVelo;
    rSpd1 = 0.5;
    rSpd2 = 80;
  }

  //--UPDATER_SPEEDMOD_FUNC--//
  void speeder()
  {
    switch(spdMod)
    {
    case 1:
      velo += calc.difIN(spdInc);
      break;

    case 2:
      velo = random(inLet1, inLet2);
      break;

    case 3:
      float range = (inLet2 - inLet1)/2;
      velo = (sin(repeat*0.15) * range + range)+inLet1;
      break;
    }

    velo = constrain(velo, rSpd1, rSpd2);
    velo = abs(velo);
  }
  //-----------ENDOF:ANGLEMOD_FUNCTIONS-----------//

  //-------------------------------------------------------------------------------------------//

  //-----------MULTYSHOT_FUNCTIONS-----------//

  //--MULTI_FUNC_1--//
  public void multi(int nShots)
  {
    sNum = nShots;
    dir += angInc;
    midRange = dir;
    mltMod = 5;
  }

  //--MULTI_FUNC_2--//
  public void multi(int nShots, float range)
  {
    sNum = nShots;
    mltRange = range/nShots;
    midRange = range/2 + (mltRange/2);
    mltMod = 1;
  }

  //--MULTI_FUNC_3--//
  public void multi(String cccp, int nShots, float range)
  {
    sNum = nShots;

    if (cccp == "rand")
    {
      mltMod = 2;
      mltRange = range;
      midRange = range/2;
    }
    else
    if (cccp == "flat")
    {
      mltMod = 3;
      midRange = range/2;
      mltRange = range/nShots;
    }
    else
    if (cccp == "flatr")
    {
      mltMod = 4;
      midRange = -range/2;
      mltRange = range/2;
    }
    else
    {
      println("error_WRONG_MULTISHOT_INPUT");
    }
  }

  //--MULTI_FUNC_4--//
  public void multi(int incre, int nShots, float range)
  {
    mltMod = 6;
    par2 = range;
    sNum = nShots;
    par1 = incre;
  }

  //--MULTI_FUNC_5--//
  public void multiSpd(float incre)
  {
    mltSpd = incre;
  }

  //--UPDATER_MULTIMOD_FUNC--//
  void multipler()
  {
    velo += mltSpd;
    switch(mltMod)
    {
    default:
      break;

    case 1:
      dir += calc.difIN(mltRange);
      break;

    case 2:
      par1 = mTempAng + midRange;
      par2 = mTempAng - midRange;
      dir = random(calc.difIN(par2), calc.difIN(par1));
      break;

    case 3:
      refX -= cos(dir + (PI/2)) * calc.difIN(mltRange);
      refY -= sin(dir + (PI/2)) * calc.difIN(mltRange);
      break;

    case 4:
      float randomMultiplter = random(calc.difIN(midRange), calc.difIN(mltRange));
      refX = mTempX + cos(dir + (PI/2)) * randomMultiplter;
      refY = mTempY + sin(dir + (PI/2)) * randomMultiplter;
      break;

    case 5:
      dir += calc.difIN(mltRange);
      break;

    case 6:
      dir += calc.difIN(mltRange);
      break;
    }
  }

  //--PRE-UPDATER_MULTIMOD_FUNC--//
  void preMulti()
  {
    mTempAng = dir;
    mTempSpd = velo;
    mTempX = refX;
    mTempY = refY;
    switch(mltMod)
    {
    case 1:
      dir -= midRange-mltRange;
      break;

    case 2:
      par1 = mTempAng + midRange;
      par2 = mTempAng - midRange;
      dir = random(par2, par1);
      break;

    case 3:
      refX += cos(dir + (PI/2)) * midRange + (mltRange/2);
      refY += sin(dir + (PI/2)) * midRange + (mltRange/2);
      break;

    case 5:
      float xAng = (dir - midRange) * 2;
      mltRange = (-xAng) / (sNum -1);
      break;

    case 6:
      midRange = par2/2;
      mltRange = par2/(sNum+1);
      dir -= midRange-mltRange;
      break;

    default:
      break;
    }
  }

  //--POS-UPDATER_MULTIMOD_FUNC--//
  void posMulti()
  {
    dir = mTempAng;
    velo = mTempSpd;
    refX = mTempX;
    refY = mTempY;

    switch(mltMod)
    {
    case 6:
      if (sNum + par1 > 0)
      {
        sNum += par1;
      }
      else
      {
        sNum = 1;
      }
      break;

    default:
      break;
    }
  }
  //-----------ENDOF:MULTYSHOT_FUNCTIONS-----------//

  ///////////////////////////////////////////////////////////////////////////////////////
  //////////-----------HERE STARTS A NEW AND MAGICAL WORLD:--------------------//////////
  //////////---------------------------------THE BEHAVIOR GIVING FUNCTIONS-----//////////
  //////////-----------CODE REPEATING... SO GOOD. D=<--------------------------//////////
  ///////////////////////////////////////////////////////////////////////////////////////
  
  //-----------BEHAVIOR_ANGLEMOD_FUNCTIONS-----------//

  public void beAngle(String cccp, float range)
  {
    nBeh[listCnt + 0][1] = range;

    if (cccp == "add")
    {
      nBeh[listCnt + 0][0] = 1;
    }
    else
    if (cccp == "set")
    {
      nBeh[listCnt + 0][0] = 2;
    }
    else
    if (cccp == "rand")
    {
      nBeh[listCnt + 0][0] = 3;
      float half = range/2;
      nBeh[listCnt + 0][1] = -half;
      nBeh[listCnt + 0][2] = half;
    }
    else
    {
      println("error_WRONG_BEHAVIOR_ANGLE_INPUT");
    }
  }

  public void beAngle(String cccp, float para1, float para2)
  {
    nBeh[listCnt + 0][1] = para1;
    nBeh[listCnt + 0][2] = para2;

    if (cccp == "sin")
    {
      nBeh[listCnt + 0][0] = 4;
      nBeh[listCnt + 0][2] = para1/para2;
    }
    else
    if (cccp == "goto")
    {
      nBeh[listCnt + 0][0] = 5;
    }
    else
    if (cccp == "gotoS")
    {
      nBeh[listCnt + 0][0] = 7;
    }
    else
    {
      println("error_WRONG_BEHAVIOR_ANGLE_INPUT");
    }
  }
  
  public void beAngle(String cccp)
  {
    
    if (cccp == "targ")
    {
      nBeh[listCnt + 0][0] = 6;
    }
    else
    if (cccp == "targS")
    {
      nBeh[listCnt + 0][0] = 8 ;
    }
    else
    {
      println("error_WRONG_BEHAVIOR_ANGLE_INPUT");
    }
  }
  
  //-----------ENDOF:BEHAVIOR_ANGLEMOD_FUNCTIONS-----------//

  //-------------------------------------------------------------------------------------------//

  //-----------BEHAVIOR_SPEEDMOD_FUNCTION-----------//
  
  public void beSpeed(String cccp, float incre)
  {
    nBeh[listCnt + 1][1] = incre;
    
    if(cccp == "add")
    {
      nBeh[listCnt + 1][0] = 1;
    }
    else
    if(cccp == "set")
    {
      nBeh[listCnt + 1][0] = 2;
    }
    else
    if(cccp == "sin")
    {
      nBeh[listCnt + 1][0] = 3;
    }
    else
    if(cccp == "tan")
    {
      if (incre > 0)
      {
        nBeh[listCnt + 1][1] = (PI) / (incre*100);
      }
      else
      {
        nBeh[listCnt + 1][1] = -PI / (abs(incre)*100);
      }
      nBeh[listCnt + 1][2] = 0;
      nBeh[listCnt + 1][0] = 4;
    }
    else
    {
      println("error_WRONG_BEHAVIOR_SPEED_INPUT");
    }
  }
  
  public void beSpeed(String cccp, float incre, float frames)
  {
    nBeh[listCnt + 1][1] = incre;
    nBeh[listCnt + 1][2] = frames;
    
    if(cccp == "goto")
    {
      nBeh[listCnt + 1][0] = 5;
    }
    else
    {
      println("error_WRONG_BEHAVIOR_SPEED_INPUT");
    }
  }
  
  //-----------ENDOF:BEHAVIOR_SPEEDMOD_FUNCTION-----------//

  //-------------------------------------------------------------------------------------------//

  //-----------BEHAVIOR_SIZEMOD_FUNCTION-----------//
  
  public void beSize(String cccp, float incre)
  {
    nBeh[listCnt + 2][1] = incre;
    
    if(cccp == "add")
    {
      nBeh[listCnt + 2][0] = 1;
    }
    else
    if(cccp == "sin")
    {
      nBeh[listCnt + 2][0] = 2;
    }
    else
    if(cccp == "set")
    {
      nBeh[listCnt + 2][0] = 3;
    }
    else
    {
      println("error_WRONG_BEHAVIOR_SIZE_INPUT");
    }
  }
  
  //-----------ENDOF:BEHAVIOR_SIZEMOD_FUNCTION-----------//

  //-------------------------------------------------------------------------------------------//

  //-----------BEHAVIOR_COLORMOD_FUNCTION-----------//
  
  public void beColor(int par)
  {
    nBeh[listCnt + 3][0] = 1;
    nBeh[listCnt + 3][1] = float(par);
  }
  
  //-----------ENDOF:BEHAVIOR_COLORMOD_FUNCTION-----------//

  //-------------------------------------------------------------------------------------------//

  //-----------BEHAVIOR_DRAWMOD_FUNCTION-----------//
  
  public void beDraw(int par)
  {
    nBeh[listCnt + 3][2] = 1;
    nBeh[listCnt + 3][3] = par;
  }
  
  //-----------ENDOF:BEHAVIOR_DRAWMOD_FUNCTION-----------//

  //-------------------------------------------------------------------------------------------//

  //-----------BEHAVIOR_DIE_FUNCTION-----------//
  
  public void beDie(String cccp)
  {
    if(cccp == "expl")
    {
      nBeh[listCnt + 3][4] = 1;
    }
    else
    if(cccp == "now")
    {
      nBeh[listCnt + 3][4] = 2;
    }
    else
    if(cccp == "soft")
    {
      nBeh[listCnt + 3][4] = 3;
    }
    else
    {
      println("error_WRONG_BEHAVIOR_DIE_INPUT");
    }
  }
  
  public void beDieSoft()
  {
    nBeh[listCnt + 3][4] = 2;
  }
  
  //-----------ENDOF:BEHAVIOR_DIE_FUNCTION-----------//
  
  //-------------------------------------------------------------------------------------------//

  //-----------BEHAVIOR_ADD-MOMENT_FUNCTION-----------//
  
  public void beMoment(int frame)
  {
    momentList[momentList.length - 1] = frame;
    int mList[] = new int [momentList.length + 1];
    arraycopy(momentList, mList);
    momentList = mList;
    
    //--------------------//
    listCnt += 5;
    
    float bList[][] = new float[5+listCnt][5];
    
    for (int i = 0; i < nBeh.length; i++)
    {
      arraycopy(nBeh[i], bList[i]);
    }
    
    nBeh = bList;
  }
  
  //-----------ENDOF:BEHAVIOR_ADD-MOMENT_FUNCTION-----------//
}

////////////**                                                           **////////////
//      --------------------- END OF SHOTS MANEGING CLASS ---------------------      //
////////////**                                                           **////////////