home *** CD-ROM | disk | FTP | other *** search
/ All for Cell Phones: Sony Ericsson / Sony-Ericsson 2004.iso / Java / LockEmUp / LockemUp.jar / LockemUp / GameBoard.class (.txt) < prev    next >
Encoding:
Java Class File  |  2002-03-05  |  10.1 KB  |  579 lines

  1. package LockemUp;
  2.  
  3. import com.siemens.mp.game.GraphicObjectManager;
  4. import com.siemens.mp.game.Melody;
  5. import com.siemens.mp.game.MelodyComposer;
  6. import com.siemens.mp.game.Sprite;
  7. import com.siemens.mp.game.Vibrator;
  8.  
  9. public class GameBoard {
  10.    private static final int GAME_MAP_WIDTH = 11;
  11.    private static final int GAME_MAP_HEIGHT = 11;
  12.    private static final int GAME_TILE_WIDTH = 8;
  13.    private static final int GAME_TILE_HEIGHT = 7;
  14.    private static final int LINE_LEN = 77;
  15.    private GraphicObjectManager gfxManager;
  16.    private byte[] back;
  17.    private byte[] map;
  18.    private byte[] state;
  19.    private byte[] info;
  20.    private byte goodExit;
  21.    private int numOfSwitches;
  22.    private byte[] numOfActors = new byte[]{0, 0, 0};
  23.    private Switch[] switches;
  24.    private Animal[] animals;
  25.    private Sprite[][] actors = new Sprite[3][];
  26.    private byte[] arrowLocs;
  27.    private Melody melody;
  28.    private byte[] mapData;
  29.    private boolean onSound;
  30.    private boolean onVibrate;
  31.  
  32.    public GameBoard(GraphicObjectManager var1, byte[] var2, byte[] var3, byte[] var4, int var5) {
  33.       this.gfxManager = var1;
  34.       this.back = new byte[847];
  35.       this.map = new byte[121];
  36.       this.state = new byte[121];
  37.       this.info = new byte[121];
  38.       this.animals = new Animal[4];
  39.       this.mapData = var2;
  40.       this.dealWithMap(var2, var3, var4, true, var5);
  41.    }
  42.  
  43.    public void reInit(int var1) {
  44.       this.dealWithMap(this.mapData, (byte[])null, (byte[])null, false, var1);
  45.    }
  46.  
  47.    public void Dispose() {
  48.       this.back = null;
  49.       this.map = null;
  50.       this.state = null;
  51.       this.info = null;
  52.       this.gfxManager = null;
  53.       this.switches = null;
  54.       this.mapData = null;
  55.    }
  56.  
  57.    public byte[] getBackground() {
  58.       return this.back;
  59.    }
  60.  
  61.    public void setOnSound(boolean var1) {
  62.       this.onSound = var1;
  63.    }
  64.  
  65.    public void setOnVibrate(boolean var1) {
  66.       this.onVibrate = var1;
  67.    }
  68.  
  69.    public void turnArrow(int var1) {
  70.       if (var1 < this.numOfActors[2] && var1 >= 0) {
  71.          byte var2 = this.arrowLocs[var1];
  72.          int var4 = var2 % 11;
  73.          int var5 = var2 / 11;
  74.          byte var3 = this.state[var2];
  75.  
  76.          do {
  77.             var3 = (byte)((var3 + 1) % 4);
  78.          } while(!this.isTurnable(var4, var5, var3));
  79.  
  80.          this.state[var2] = var3;
  81.          this.actors[2][var1].setFrame(var3);
  82.          if (this.onSound) {
  83.             Melody.stop();
  84.             this.melody = null;
  85.             this.melody = this.createMelody(1);
  86.             this.melody.play();
  87.          }
  88.       }
  89.  
  90.    }
  91.  
  92.    public int manageMoves() {
  93.       boolean var3 = true;
  94.       boolean var4 = false;
  95.  
  96.       for(int var1 = 0; var1 < 4; ++var1) {
  97.          var3 &= this.animals[var1].bDestroyed;
  98.          if (!this.animals[var1].bDestroyed) {
  99.             this.moveAnimal(var1);
  100.          }
  101.  
  102.          if (!this.animals[var1].bImmune) {
  103.             int var2 = this.animals[var1].gridy * 11 + this.animals[var1].gridx;
  104.             if (this.map[var2] == 7 && this.state[var2] > 0) {
  105.                var4 = true;
  106.                break;
  107.             }
  108.          }
  109.       }
  110.  
  111.       for(int var5 = 0; var5 < 3; ++var5) {
  112.          if (!this.animals[var5].bDestroyed && !var4) {
  113.             for(int var6 = var5 + 1; var6 < 4; ++var6) {
  114.                if (!this.animals[var6].bDestroyed && !var4) {
  115.                   var4 = this.animals[var5].sprite.isCollidingWith(this.animals[var6].sprite);
  116.                }
  117.             }
  118.          }
  119.       }
  120.  
  121.       if (var3) {
  122.          return 3;
  123.       } else if (var4) {
  124.          if (this.onVibrate) {
  125.             Vibrator.triggerVibrator(500);
  126.          }
  127.  
  128.          return 4;
  129.       } else {
  130.          return 0;
  131.       }
  132.    }
  133.  
  134.    private void moveAnimal(int var1) {
  135.       Animal var2 = this.animals[var1];
  136.       int var14 = -1;
  137.       int var3 = var2.x + var2.vx;
  138.       int var4 = var2.y + var2.vy;
  139.       byte var6;
  140.       if (var2.vx > 0) {
  141.          var6 = 7;
  142.       } else {
  143.          var6 = 0;
  144.       }
  145.  
  146.       byte var7;
  147.       if (var2.vy > 0) {
  148.          var7 = 6;
  149.       } else {
  150.          var7 = 0;
  151.       }
  152.  
  153.       if (var3 >= 0) {
  154.          var6 = ((var3 >> 8) + var6) / 8;
  155.       } else {
  156.          var6 = -1;
  157.       }
  158.  
  159.       if (var4 >= 0) {
  160.          var7 = ((var4 >> 8) + var7) / 7;
  161.       } else {
  162.          var7 = -1;
  163.       }
  164.  
  165.       int var8 = var2.vx > 0 ? 1 : (var2.vx < 0 ? -1 : 0);
  166.       int var9 = var2.vy > 0 ? 1 : (var2.vy < 0 ? -1 : 0);
  167.       int var10 = ((var6 - var8) * 8 << 8) - var3;
  168.       int var11 = ((var7 - var9) * 7 << 8) - var4;
  169.       int var13 = var2.gridy * 11 + var2.gridx;
  170.       if (var2.gridx != var6 || var2.gridy != var7) {
  171.          if (var2.map == 6 && !var2.bImmune) {
  172.             this.state[var13] = (byte)((this.state[var13] + 1) % 2);
  173.             this.switches[this.info[var13]].sprite.setFrame(this.state[var13]);
  174.  
  175.             for(int var12 = 0; var12 < this.switches[this.info[var13]].nblinks; ++var12) {
  176.                byte var5 = this.switches[this.info[var13]].links[var12];
  177.                this.state[var5] = (byte)((this.state[var5] + 1) % 2);
  178.                switch (this.map[var5]) {
  179.                   case 4:
  180.                      this.actors[1][this.info[var5]].setFrame(this.state[var5]);
  181.                      break;
  182.                   case 7:
  183.                      this.actors[0][this.info[var5]].setFrame(this.state[var5]);
  184.                }
  185.             }
  186.          }
  187.  
  188.          if (var2.bImmune) {
  189.             var2.bImmune = false;
  190.          }
  191.  
  192.          if (var2.map == 5 && var2.state == var1) {
  193.             ++this.goodExit;
  194.             var2.setPosition(var2.gridx * 8 << 8, var2.gridy * 7 << 8);
  195.             if (this.onSound && this.goodExit < 4) {
  196.                Melody.stop();
  197.                this.melody = null;
  198.                this.melody = this.createMelody(0);
  199.                this.melody.play();
  200.             }
  201.  
  202.             var2.setDestroyed();
  203.             return;
  204.          }
  205.  
  206.          if (var2.map == 8) {
  207.             if (this.onSound) {
  208.                Melody.stop();
  209.                this.melody = null;
  210.                this.melody = this.createMelody(2);
  211.                this.melody.play();
  212.             }
  213.  
  214.             var2.bImmune = true;
  215.          }
  216.  
  217.          boolean var15 = false;
  218.          if (var2.map == 2) {
  219.             var15 = true;
  220.             switch (var2.state) {
  221.                case 0:
  222.                   if (this.isBlocked(var2.gridx - 1, var2.gridy, var1)) {
  223.                      var15 = false;
  224.                   }
  225.                   break;
  226.                case 1:
  227.                   if (this.isBlocked(var2.gridx, var2.gridy - 1, var1)) {
  228.                      var15 = false;
  229.                   }
  230.                   break;
  231.                case 2:
  232.                   if (this.isBlocked(var2.gridx + 1, var2.gridy, var1)) {
  233.                      var15 = false;
  234.                   }
  235.                   break;
  236.                case 3:
  237.                   if (this.isBlocked(var2.gridx, var2.gridy + 1, var1)) {
  238.                      var15 = false;
  239.                   }
  240.             }
  241.  
  242.             byte var16 = -1;
  243.             if (var15) {
  244.                if (var2.vx < 0) {
  245.                   var16 = 0;
  246.                } else if (var2.vx > 0) {
  247.                   var16 = 2;
  248.                } else if (var2.vy < 0) {
  249.                   var16 = 1;
  250.                } else {
  251.                   var16 = 3;
  252.                }
  253.  
  254.                var14 = (5 - var16 + var2.state) % 4;
  255.             }
  256.          }
  257.  
  258.          if (!var15 && (this.isBlocked(var6, var7, var1) && !var2.bImmune || this.isOutScreen(var6, var7))) {
  259.             if (!this.isBlocked(var2.gridx - var9, var2.gridy + var8, var1)) {
  260.                var14 = 2;
  261.             } else if (!this.isBlocked(var2.gridx + var9, var2.gridy - var8, var1)) {
  262.                var14 = 0;
  263.             } else {
  264.                var14 = 3;
  265.             }
  266.          }
  267.  
  268.          switch (var14) {
  269.             case 0:
  270.                int var19 = var2.vx;
  271.                var2.vx = var2.vy;
  272.                var2.vy = -var19;
  273.                var3 += var10 - var11;
  274.                var4 += var11 + var10;
  275.             case 1:
  276.             default:
  277.                break;
  278.             case 2:
  279.                int var18 = var2.vx;
  280.                var2.vx = -var2.vy;
  281.                var2.vy = var18;
  282.                var3 += var10 + var11;
  283.                var4 += var11 - var10;
  284.                break;
  285.             case 3:
  286.                var2.vx = -var2.vx;
  287.                var2.vy = -var2.vy;
  288.                var3 += 2 * var10;
  289.                var4 += 2 * var11;
  290.          }
  291.       }
  292.  
  293.       var2.setPosition(var3, var4);
  294.       if (var2.vx > 0) {
  295.          var6 = 7;
  296.       } else {
  297.          var6 = 0;
  298.       }
  299.  
  300.       if (var2.vy > 0) {
  301.          var7 = 6;
  302.       } else {
  303.          var7 = 0;
  304.       }
  305.  
  306.       var2.gridx = ((var3 >> 8) + var6) / 8;
  307.       var2.gridy = ((var4 >> 8) + var7) / 7;
  308.       if (var14 < 0) {
  309.          int var24 = var2.gridy * 11 + var2.gridx;
  310.          var2.map = this.map[var24];
  311.          var2.state = this.state[var24];
  312.          var2.info = this.info[var24];
  313.       } else {
  314.          var2.map = 0;
  315.          var2.state = 0;
  316.          var2.info = 0;
  317.       }
  318.  
  319.    }
  320.  
  321.    private boolean isOutScreen(int var1, int var2) {
  322.       return var1 < 0 || var1 >= 11 || var2 < 0 || var2 >= 11;
  323.    }
  324.  
  325.    private boolean isBlocked(int var1, int var2, int var3) {
  326.       if (this.isOutScreen(var1, var2)) {
  327.          return true;
  328.       } else {
  329.          int var4 = var2 * 11 + var1;
  330.          if (this.map[var4] == 1) {
  331.             return true;
  332.          } else if (this.map[var4] == 4 && this.state[var4] == 0) {
  333.             return true;
  334.          } else {
  335.             return this.map[var4] == 5 && this.state[var4] != var3;
  336.          }
  337.       }
  338.    }
  339.  
  340.    private boolean isTurnable(int var1, int var2, int var3) {
  341.       if (var3 % 2 == 0) {
  342.          if (this.isOutScreen(var1 + var3 - 1, var2)) {
  343.             return false;
  344.          } else {
  345.             return this.map[var2 * 11 + (var1 + var3 - 1)] != 1;
  346.          }
  347.       } else if (this.isOutScreen(var1, var2 + var3 - 2)) {
  348.          return false;
  349.       } else {
  350.          return this.map[(var2 + var3 - 2) * 11 + var1] != 1;
  351.       }
  352.    }
  353.  
  354.    private void dealWithMap(byte[] var1, byte[] var2, byte[] var3, boolean var4, int var5) {
  355.       int var11 = 0;
  356.       byte[] var15 = new byte[]{0, 0, 0};
  357.       this.goodExit = (byte)(3 - var5);
  358.       this.numOfSwitches = var1[var11];
  359.       ++var11;
  360.       if (var4) {
  361.          this.switches = new Switch[this.numOfSwitches];
  362.       }
  363.  
  364.       for(int var6 = 0; var6 < this.numOfSwitches; ++var6) {
  365.          if (var4) {
  366.             this.switches[var6] = new Switch();
  367.             this.switches[var6].nblinks = var1[var11];
  368.          }
  369.  
  370.          ++var11;
  371.          if (var4) {
  372.             this.switches[var6].links = new byte[this.switches[var6].nblinks];
  373.          }
  374.  
  375.          for(int var7 = 0; var7 < this.switches[var6].nblinks; ++var7) {
  376.             if (var4) {
  377.                this.switches[var6].links[var7] = var1[var11];
  378.             }
  379.  
  380.             ++var11;
  381.          }
  382.  
  383.          if (var4) {
  384.             byte[] var13 = new byte[16];
  385.             System.arraycopy(var3, 128, var13, 0, 16);
  386.             Sprite var12 = new Sprite(var13, 0, 8, 8, (byte[])null, 0, 2);
  387.             this.switches[var6].sprite = var12;
  388.             this.gfxManager.addObject(var12);
  389.          }
  390.       }
  391.  
  392.       for(int var16 = 0; var16 < 4; ++var16) {
  393.          byte var10 = var1[var11];
  394.          ++var11;
  395.          if (var4) {
  396.             byte[] var37 = new byte[16];
  397.             System.arraycopy(var3, var16 * 32, var37, 0, 16);
  398.             byte[] var14 = new byte[16];
  399.             System.arraycopy(var3, var16 * 32 + 16, var14, 0, 16);
  400.             Sprite var34 = new Sprite(var37, 0, 8, 8, var14, 0, 2);
  401.             this.animals[var16] = new Animal(var34);
  402.          }
  403.  
  404.          this.animals[var16].initAnimal((byte)var10, var1[var11], var16);
  405.          if (var16 > var5) {
  406.             this.animals[var16].bDestroyed = true;
  407.             this.animals[var16].sprite.setVisible(false);
  408.          }
  409.  
  410.          ++var11;
  411.       }
  412.  
  413.       if (var4) {
  414.          int var27 = var11;
  415.  
  416.          for(int var17 = 0; var17 < 121; ++var17) {
  417.             if (var1[var27] < 100) {
  418.                if (var1[var27] >= 65) {
  419.                   ++this.numOfActors[0];
  420.                } else if (var1[var27] < 60) {
  421.                   if (var1[var27] >= 55) {
  422.                      ++this.numOfActors[1];
  423.                   } else if (var1[var27] >= 10) {
  424.                      ++this.numOfActors[2];
  425.                   }
  426.                }
  427.             }
  428.  
  429.             ++var27;
  430.          }
  431.  
  432.          for(int var18 = 0; var18 < 2; ++var18) {
  433.             this.actors[var18] = new Sprite[this.numOfActors[var18]];
  434.  
  435.             for(int var22 = 0; var22 < this.numOfActors[var18]; ++var22) {
  436.                byte[] var38 = new byte[16];
  437.                System.arraycopy(var3, 144 + var18 * 16, var38, 0, 16);
  438.                Sprite var35 = new Sprite(var38, 0, 8, 8, var38, 0, 2);
  439.                this.actors[var18][var22] = var35;
  440.                this.gfxManager.addObject(var35);
  441.             }
  442.          }
  443.  
  444.          this.actors[2] = new Sprite[this.numOfActors[2]];
  445.          this.arrowLocs = new byte[this.numOfActors[2]];
  446.  
  447.          for(int var19 = 0; var19 < this.numOfActors[2]; ++var19) {
  448.             byte[] var39 = new byte[32];
  449.             System.arraycopy(var3, 176 + var19 * 32, var39, 0, 32);
  450.             Sprite var36 = new Sprite(var39, 0, 8, 8, var39, 0, 4);
  451.             this.actors[2][var19] = var36;
  452.             this.gfxManager.addObject(var36);
  453.          }
  454.       }
  455.  
  456.       for(int var20 = 0; var20 < 11; ++var20) {
  457.          for(int var23 = 0; var23 < 11; ++var23) {
  458.             if (var1[var11] >= 100) {
  459.                int var30 = var1[var11] - 100;
  460.                this.map[var20 * 11 + var23] = 6;
  461.                this.state[var20 * 11 + var23] = (byte)(var30 % 2);
  462.                this.info[var20 * 11 + var23] = (byte)(var30 / 2);
  463.                var30 /= 2;
  464.                this.switches[var30].sprite.setPosition(8 * var23, 7 * var20);
  465.                this.switches[var30].sprite.setFrame(this.state[var20 * 11 + var23]);
  466.             } else if (var1[var11] >= 65) {
  467.                this.map[var20 * 11 + var23] = 7;
  468.                this.state[var20 * 11 + var23] = (byte)((var1[var11] - 65) % 2);
  469.                this.info[var20 * 11 + var23] = var15[0];
  470.                this.actors[0][var15[0]].setPosition(8 * var23, 7 * var20);
  471.                this.actors[0][var15[0]].setFrame(this.state[var20 * 11 + var23]);
  472.                ++var15[0];
  473.             } else if (var1[var11] >= 60) {
  474.                byte var29 = (byte)((var1[var11] - 60) % 4);
  475.                this.state[var20 * 11 + var23] = (byte)var29;
  476.                this.map[var20 * 11 + var23] = 5;
  477.                if (var4) {
  478.                   for(int var26 = 0; var26 < 7; ++var26) {
  479.                      this.back[77 * var20 + var23 + var26 * 11] = var2[var26 + (var29 + 1) * 7];
  480.                   }
  481.                }
  482.             } else if (var1[var11] >= 55) {
  483.                this.map[var20 * 11 + var23] = 4;
  484.                this.state[var20 * 11 + var23] = (byte)((var1[var11] - 55) % 2);
  485.                this.info[var20 * 11 + var23] = var15[1];
  486.                this.actors[1][var15[1]].setPosition(8 * var23, 7 * var20);
  487.                this.actors[1][var15[1]].setFrame(this.state[var20 * 11 + var23]);
  488.                ++var15[1];
  489.             } else if (var1[var11] >= 10) {
  490.                int var28 = var1[var11] - 10;
  491.                int var25 = var28 / 10;
  492.                byte var9 = var15[2]++;
  493.                this.arrowLocs[var9] = (byte)(var20 * 11 + var23);
  494.                this.state[var20 * 11 + var23] = (byte)var25;
  495.                this.actors[2][var9].setPosition(8 * var23, 7 * var20);
  496.                this.info[var20 * 11 + var23] = (byte)var9;
  497.                this.actors[2][var9].setFrame(var25);
  498.                this.map[var20 * 11 + var23] = 2;
  499.             } else if (var1[var11] >= 2) {
  500.                if (var4) {
  501.                   for(int var24 = 0; var24 < 7; ++var24) {
  502.                      this.back[77 * var20 + var23 + var24 * 11] = var2[var24 + 35];
  503.                   }
  504.                }
  505.  
  506.                this.map[var20 * 11 + var23] = 8;
  507.             } else if (var1[var11] != 1) {
  508.                this.map[var20 * 11 + var23] = 0;
  509.             } else {
  510.                if (var4) {
  511.                   for(int var8 = 0; var8 < 7; ++var8) {
  512.                      this.back[77 * var20 + var23 + var8 * 11] = var2[var8];
  513.                   }
  514.                }
  515.  
  516.                this.map[var20 * 11 + var23] = 1;
  517.             }
  518.  
  519.             ++var11;
  520.          }
  521.       }
  522.  
  523.       if (var4) {
  524.          for(int var21 = 0; var21 < 4; ++var21) {
  525.             this.gfxManager.addObject(this.animals[var21].sprite);
  526.          }
  527.       }
  528.  
  529.    }
  530.  
  531.    private Melody createMelody(int var1) {
  532.       try {
  533.          MelodyComposer var2 = new MelodyComposer();
  534.          var2.setBPM(132);
  535.          switch (var1) {
  536.             case 0:
  537.                var2.appendNote(19, 6);
  538.                var2.appendNote(18, 6);
  539.                var2.appendNote(17, 6);
  540.                var2.appendNote(16, 6);
  541.                var2.appendNote(15, 6);
  542.                var2.appendNote(28, 6);
  543.                var2.appendNote(29, 6);
  544.                var2.appendNote(30, 6);
  545.                var2.appendNote(31, 6);
  546.                var2.appendNote(32, 6);
  547.                var2.appendNote(33, 6);
  548.                var2.appendNote(34, 6);
  549.                var2.appendNote(24, 6);
  550.                var2.appendNote(36, 6);
  551.                break;
  552.             case 1:
  553.                var2.appendNote(49, 6);
  554.                var2.appendNote(37, 6);
  555.                break;
  556.             case 2:
  557.                var2.appendNote(24, 6);
  558.                var2.appendNote(28, 6);
  559.                var2.appendNote(31, 6);
  560.                var2.appendNote(33, 6);
  561.                var2.appendNote(24, 6);
  562.                var2.appendNote(36, 6);
  563.                var2.appendNote(58, 3);
  564.                var2.appendNote(58, 5);
  565.                var2.appendNote(41, 6);
  566.                var2.appendNote(43, 6);
  567.                var2.appendNote(45, 6);
  568.                var2.appendNote(36, 6);
  569.                var2.appendNote(48, 6);
  570.          }
  571.  
  572.          return var2.getMelody();
  573.       } catch (Exception var3) {
  574.          System.out.println("Exception: " + var3);
  575.          return null;
  576.       }
  577.    }
  578. }
  579.