applet1.java

Bomberman + source code. This Bomberman has many, many more features then regular Bomberman-games d

	                    bombs[bC].setBomb(false);
	                    bombs[bC].setBombTimer(0);
	                    bombs[bC].setCenter(X-i*tileS, Y);
	                }
	            }
	        }
	        catch (ArrayIndexOutOfBoundsException e) { }
	            checkHit(explosions[ID].toAbsX(X-i*tileS), explosions[ID].toAbsY(Y)); 
	    }
	    for (i = 1; i <= bombs[ID].getMaxUp(); i++) {
	        //Draw the correct fire
	        if (X == bombs[ID].getCenterX() && Y-i*tileS == bombs[ID].getCenterY())
	            b.drawImage(explosion[0],X,Y-i*tileS,tileS,tileS,this);
	        else if (i == bombs[ID].getMaxUp())
	            b.drawImage(explosion[5],(X),(Y-i*tileS),tileS,tileS,this);
	        else
	            b.drawImage(explosion[2],(X),(Y-i*tileS),tileS,tileS,this);
	        //Check if there is another bomb in the line of fire, and make it explode
	        try {
	            if (pMap[aX][aY-(i*tileS)/tileS] >= 30 && i > 0) {
	                bC = pMap[aX][aY-(i*tileS)/tileS]-30;
	                if (bC >= 0) {    
	                    explosions[bC] = new Explosion();
                        explosions[bC].setExplosionTimer((explosionDuration*1000)/cycleTime);
                        explodeBomb(bC);
	                    bombs[bC].setBomb(false);
	                    bombs[bC].setBombTimer(0);
	                    bombs[bC].setCenter(X,Y-i*tileS);
	                }
	            }
	        }
	        catch (ArrayIndexOutOfBoundsException e) { }
	        checkHit(explosions[ID].toAbsX(X), explosions[ID].toAbsY(Y-i*tileS)); 
	    }
	    for (i = 1; i <= bombs[ID].getMaxDown(); i++) {
	        //Draw the correct fire
	        if (X == bombs[ID].getCenterX() && Y+i*tileS == bombs[ID].getCenterY())
	            b.drawImage(explosion[0],X,Y+i*tileS,tileS,tileS,this);
	        else if (i == bombs[ID].getMaxDown())
	            b.drawImage(explosion[6],(X),(Y+i*tileS),tileS,tileS,this);
	        else
    	        b.drawImage(explosion[2],(X),(Y+i*tileS),tileS,tileS,this);
	        //Check if there is another bomb in the line of fire, and make it explode    
	        try {
	            if (pMap[aX][aY+(i*tileS)/tileS] >= 30 && i > 0) {
	                bC = pMap[aX][aY+(i*tileS)/tileS]-30;
	                if (bC >= 0) {    
	                    explosions[bC] = new Explosion();
                        explosions[bC].setExplosionTimer((explosionDuration*1000)/cycleTime);
                        explodeBomb(bC);
	                    bombs[bC].setBomb(false);
	                    bombs[bC].setBombTimer(0);
	                    bombs[bC].setCenter(X,Y+i*tileS);
	                }
	            }
	        }
	        catch (ArrayIndexOutOfBoundsException e) { }
	        checkHit(explosions[ID].toAbsX(X), explosions[ID].toAbsY(Y+i*tileS));
	    }
	    requestedPaint = true;
	}
	
	public void checkHit(int eAX, int eAY) {
	    int pAX;
	    int pAY;
	    for (int i = 0; i < player.length; i++) {
	        for (int Y = 0; Y < mapSize; Y++) {
	            pAY = player[i].toAbsY(player[i].getY()+pH/2);
	            if (eAY == pAY) {
	                for (int X = 0; X < mapSize; X++) {
        	            pAX = player[i].toAbsX(player[i].getX()+pW/2);
        	            if (pAX == eAX) {
        	                //player[i].setCanMove(false);
        	                gotHit(i);
        	            }
	                }
	            }
	        }
	    }
	}
	
	public void checkItemHit(int eAX, int eAY) {
	    if (destroyItemsOnHit) {
	        int iAX;
	        int iAY;
	        for (int i = 0; i < itemCounter; i++) {
	            if (item[i].isItem()) {
	                for (int Y = 0; Y < mapSize; Y++) {
	                    iAY = item[i].getAbsY();
	                    if (eAY == iAY) {
	                        for (int X = 0; X < mapSize; X++) {
	                            iAX = item[i].getAbsX();
        	                    if (iAX == eAX) {
        	                        itemGotHit(i);
        	                    }
	                        }
	                    }
	                }
	            }
	        }
	    }
	}
	
	public void gotHit(int playerID) {
	    if (!player[playerID].isImmortal()) {
	        player[playerID].setAnimation(1);
	        player[playerID].setImmortal(true);
	        player[playerID].setImmortalTimer((immortalTime*1000)/cycleTime);
	        died(playerID);
	    }
	}
	
	public void itemGotHit(int itemID) {
	    //destroy();
	    item[itemID].setItem(false);
	    item[itemID].setPos(getWidth(), getHeight());
	    
	}
	
	public void newBomb(int playerID) {
	    if (player[playerID].isImmortal())
	        return;
	    int bAX;
	    int bAY;
        for (int i = 0; i < player.length; i++) {
            if (playerID == i) {
                bAX = player[i].toAbsX(player[i].getX()+pW/2);
                bAY = player[i].toAbsY(player[i].getY()+pH/2);
                player[i].addBombPlaced();
                bombs[bombCounter] = new Bomb();
                bombs[bombCounter].setPlayerID(playerID);
                newBomb2(bAX,bAY);
            }
        }
       
	}
	public void newBomb2(int bAX, int bAY) {
	    bombs[bombCounter].setX(bombs[bombCounter].toX(bAX));
		bombs[bombCounter].setY(bombs[bombCounter].toY(bAY));
		bombs[bombCounter].setAbsPos(bAX, bAY);
        bombs[bombCounter].setBomb(true);
        bombs[bombCounter].setDestroyedBlockD(false);
        bombs[bombCounter].setDestroyedBlockU(false);
        bombs[bombCounter].setDestroyedBlockR(false);
        bombs[bombCounter].setDestroyedBlockL(false);
		bombs[bombCounter].setBombTimer((bombDuration*1000)/cycleTime);
		oldPMap[bAX][bAY] = pMap[bAX][bAY];        			
		pMap[bAX][bAY] = bombCounter+30; //30 or higher means there's a bomb at that place
		bombCounter++;
	}
	
	public void moveBomb(int bAX, int bAY, int direction) {
	    int bombID;
	    for (int i = 0; i < bombs.length; i++) {
	        try {
	            if (bombs[i].isBomb() && bombs[i].getAbsX() == bAX && bombs[i].getAbsY() == bAY) {
	                bombID = i;
	                //pMap[bAX][bAY] = oldPMap[bAX][bAY];
	                bombs[i].setMoving(true);
	                bombs[i].setDirection(direction);
	                bombs[i].move();
	                break;
	            }
	        }
	        catch (NullPointerException e) {
	            break;
	        }
	    }
	}
		
	public void makeItem(int bAX, int bAY) {
	    if (Misc.rand(0,100) < itemChance) {
	        item[itemCounter] = new Item(); //Create new item
	        item[itemCounter].setAbsPos(bAX,bAY); //Set the abs position
	        if (gameMode != 5)
	            item[itemCounter].setItemID(Misc.rand(1,items.length)); //Pick a random item
	        else {
	            switch (Misc.rand(1,5)) {
	                case 1: item[itemCounter].setItemID(1); break;
	                case 2: item[itemCounter].setItemID(3); break;
	                case 3: item[itemCounter].setItemID(7); break;
	                case 4: item[itemCounter].setItemID(8); break;
	            }
	        }
	        item[itemCounter].setItem(true); 
	        //item[itemCounter].setDestroyed(false);
	        int itemID = item[itemCounter].getItemID();
	        if (gameMode == 4)
	            itemID = 5;
	        if (itemID == 5 || itemID == 6) {       //Since the 'mine' has
                if ((bAX%2 == 0 && bAY%2 == 0) ||   //not one, but
                    (bAX%2 != 0 && bAY%2 != 0))     //two versions, with 
                    itemID = 6;                     //light and dark green 
                else                                //background, this is
                    itemID = 5;                     //needed to make the right
	        item[itemCounter].setItemID(itemID);    //one appear.
	        }                                   
	        itemCounter++;
	        //updateItems = true;
	    }
	}
	
	public void checkItem(int playerID) {
	    int iAX;
	    int iAY;
	    int pAX;
	    int pAY;
	    for (int i = 0; i < itemCounter; i++) {
	        try {
	            iAX = item[i].getAbsX();
	            iAY = item[i].getAbsY();
	            pAX = player[playerID].toAbsX(player[playerID].getX()+pW/2);
	            pAY = player[playerID].toAbsY(player[playerID].getY()+pH/2);
	            if (item[i].isItem() && pAX == iAX && pAY == iAY) {
	                takeItem(i,playerID);
	                break;
	            }
	        }
	        catch (NullPointerException e) { break; } 
	    }
	}
	/*
	    items[1]  //Image for extra bomb	
		items[2]  //Image for a bomb less
		items[3]  //Image for speed++
		items[4]  //Image for speed--
		items[5]  //Mine, light green field
		items[6]  //Mine, dark green field
		items[7]  //Make explosion longer
		items[8]  //Ability to kick a bomb
    */
	
	public void takeItem(int itemCount, int playerID) {
	    if (effectsAreOn)
	        soundEffect[2].play();
	    int itemID = item[itemCount].getItemID();
	    switch (itemID) {
	        case 1: player[playerID].addMaxBombs(); break;
	        case 2: player[playerID].delMaxBombs(); break;
	        case 3: player[playerID].addMoveSpeed(.5); break;
	        case 4: player[playerID].delMoveSpeed(.5); break;
	        case 5: explodeMine(itemCount); break;
	        case 6: explodeMine(itemCount); break;
	        case 7: player[playerID].addExplosionLength(); break;
	        case 8: player[playerID].setKickBombs(true); break;
	    }
	    item[itemCount].setItem(false);    
	}
	
	public void explodeMine(int itemCount) {
	    if (effectsAreOn)
	        soundEffect[1].play();
        bombs[bombCounter] = new Bomb();
	    bombs[bombCounter].setAbsPos(item[itemCount].getAbsX(),item[itemCount].getAbsY());
	    explosions[bombCounter] = new Explosion();
	    explosions[bombCounter].setExplosionTimer((explosionDuration*1000)/cycleTime);
	    item[itemCount].setItem(false);
	    isMine[bombCounter] = true;
	    bombCounter++;
	}
	
	public void drawItems() {
	    int itemID;
	    int x;
	    int y;
	    for (int i = 0; i < item.length; i++) {
	        try {
	            itemID = item[i].getItemID();
	            if (item[i].isItem()) {
	                x = item[i].getX();
	                y = item[i].getY();
	                b.drawImage(items[itemID],x,y,tileS,tileS,this);
	            }
	        }
	        catch (NullPointerException e) {
	            break; //With nullpointer, there has never been a 'new Item()' so after that there's no reason to look further
	        }
	    }
	    //updateItems = false;
	}	
	
	public void checkFields() { //Makes sure fields don't end empty
	    if (lifesField.getText().length() <= 0)
	        lifesField.setText("3");
	    if (timeField.getText().length() <= 0)
	        timeField.setText("10");
	    if (minBombField.getText().length() <= 0)
	        minBombField.setText("1");
	    if (maxBombField.getText().length() <= 0)
	        maxBombField.setText("10");
	    if (explosionTimeField.getText().length() <= 0)
	        explosionTimeField.setText("1");
	    if (bombTimeField.getText().length() <= 0)
	        bombTimeField.setText("3");
	    if (immortalTimeField.getText().length() <= 0)
	        immortalTimeField.setText("5");	    
	}

    public void died(int p) { //R.I.P.
        if (effectsAreOn)
	        soundEffect[0].play();
        player[p].delLives();
        player[p].setMoving(false);
        if ((res