bomb.java

很不错的泡泡堂手机游戏

/*
 * 创建日期 2007-3-22 @author caipiz
 * 由源码爱好者_www.codefans.net整理下载
 */
package com.cpiz.poptang;

import javax.microedition.lcdui.game.TiledLayer;

/**
 * 炸弹类
 * @author caipiz
 */
public class Bomb
{
    public boolean isVisible = true;
    private Map map = null;
    private TiledLayer itemsLayer = null;
    private Character parent = null;
    private int power = 1;// 炸弹能量
    private int clock = 0;// 计时器
    private int explodeClock = 0;// 爆炸计时器
    public int col = 0;
    public int row = 0;
    private int status = Bomb.STATUS_NORMAL;

    public Bomb(Character parent)
    {
        this.parent = parent;
        power = parent.power;
        map = Game.map;
        itemsLayer = map.getBombsAndToolsLayer();
        col = parent.getCol();
        row = parent.getRow();
        itemsLayer.setCell(col, row, 1);// 显示炸弹

        // 地面设为不可通过
        map.removeFeature(row, col, Map.CAN_PASS);
        
        // 地面加注炸弹属性
        map.addFeature(row, col, Map.BOMB);
    }

    /**
     * 更新炸弹
     */
    public void update()
    {
        clock++;
        
        // 检测是否要开始爆炸
        if (clock > Bomb.EXP_DELAY)
        {
            status = Bomb.STATE_EXPLODE;
        }

        if (status == Bomb.STATUS_NORMAL)
        {
            // 炸弹稳定态动画
            if (Game.clock % 10 == 0)
            {
                itemsLayer.setCell(col, row, itemsLayer.getCell(col, row) % 4 + 1);
            }
            return;
        }
        
        // 是否完成爆炸, 清空爆炸效果
        if (explodeClock >= 4)
        {
            clearExplode();
            return;
        }
        
        if(status == Bomb.STATE_EXPLODE)
        {
            // 爆炸效果
            explode();
        }
    }
    
    /**
     * 爆炸
     */
    private void explode()
    {
        status = Bomb.STATE_EXPLODE;
        explodeClock++;
        itemsLayer.setCell(col, row, 4 + explodeClock);
        map.addFeature(row, col, Map.DEADLY);
        
        // 右方冲击波
        for (int i = 1; i <= power; i++)
        {
            // 是否超出边界，超出则不检测
            if (col + i < PopTang.MAP_COLS)
            {
                // 引爆该单元格
                detonate(row, col + i);
    
                // 单元格是否可通过
                if (map.hasFeature(row, col + i, Map.CAN_PASS))
                {
                    // 设置单元格为致命
                    map.addFeature(row, col + i, Map.DEADLY);
    
                    if (i != power)// 普通冲击波
                        itemsLayer.setCell(col + i, row, 8 + 3);// 绘制冲击波
                    else
                        // 最后一波
                        itemsLayer.setCell(col + i, row, 20 + explodeClock);
                }
                else
                {
                    map.destroy(row, col + i);
                    break;
                }
            }
        }
         
        // 左方冲击波
        for (int i = 1; i <= power; i++)
        {
            if (col - i >= 0)
            {
                detonate(row, col - i);
                
                // 单元格是否可通过
                if (map.hasFeature(row, col - i, Map.CAN_PASS))
                {
                    // 设置单元格为致命
                    map.addFeature(row, col - i, Map.DEADLY);
                    
                    if (i != power)
                        itemsLayer.setCell(col - i, row, 8 + 1);
                    else
                        itemsLayer.setCell(col - i, row, 12 + explodeClock);
                }
                else
                {
                    map.destroy(row, col - i);
                    break;
                 }
            }
        }

        // 下方冲击波
        for (int i = 1; i <= power; i++)
        {
            if (row + i < PopTang.MAP_ROWS)
            {
                detonate(row + i, col);
                
                // 单元格是否可通过
                if (map.hasFeature(row + i, col, Map.CAN_PASS))
                {
                    // 设置单元格为致命
                    map.addFeature(row + i, col, Map.DEADLY);
                    
                    if (i != power)
                        itemsLayer.setCell(col, row + i, 8 + 4);
                    else
                        itemsLayer.setCell(col, row + i, 24 + explodeClock);
                }
                else
                {
                    map.destroy(row + i, col);
                    break;
                }
            }
        }

        // 上方冲击波
        for (int i = 1; i <= power; i++)
        {
            if (row - i >= 0)
            {
                detonate(row - i, col);
                
                // 单元格是否可通过
                if (map.hasFeature(row - i, col, Map.CAN_PASS))
                {
                    // 设置单元格为致命
                    map.addFeature(row - i, col, Map.DEADLY);
                    
                    if (i != power)
                        itemsLayer.setCell(col, row - i, 8 + 2);
                    else
                        itemsLayer.setCell(col, row - i, 16 + explodeClock);
                }
                else
                {
                    map.destroy(row - i, col);
                    break;
                }
            }
        }
    }
    
    /**
     * 引爆单元格炸弹<br>
     * 如果指定单元格内不存在炸弹，则退出；
     * 如果指定单元格内存在炸弹，则引爆
     * 
     * @param row 要引爆的行
     * @param col 要引爆的列
     * @return 是否引爆成功
     */
    private boolean detonate(int row, int col)
    {
        // 是否触发其它炸弹
        if (map.hasFeature(row, col, Map.BOMB))
        {
            String key = "" + (col * 10 + row);
            Bomb bomb =(Bomb)Game.bombs.get(key);
            if (bomb != null)
                bomb.status = Bomb.STATE_EXPLODE;
            return true;
        }
        else
        {
            return false;
        }
    }
    
    /**
     * 清除爆炸
     */
    private void clearExplode()
    {
        isVisible = false;
        parent.bombsNum ++;
        
        itemsLayer.setCell(col, row, 0);
    
        // 去除炸弹
        map.removeFeature(row, col, Map.BOMB);
        
        // 去除致命
        map.removeFeature(row, col, Map.DEADLY);
        
        // 恢复通行
        map.addFeature(row, col, Map.CAN_PASS);
        
        for (int i = 1; i <= power; i++)
        {
            // 检测右方
            if (col + i < PopTang.MAP_COLS)
            {
                clearShockwave(row, col + i);
                map.removeFeature(row, col + i, Map.DEADLY);
            }
        }
         
        for (int i = 1; i <= power; i++)
        {
            // 检测左方
            if (col - i >= 0)
            {
                clearShockwave(row, col - i);
                map.removeFeature(row, col - i, Map.DEADLY);
            }
        }
            
        for (int i = 1; i <= power; i++)
        {
            // 检测下方
            if (row + i < PopTang.MAP_ROWS)
            {
                clearShockwave(row + i, col);
                map.removeFeature(row + i, col, Map.DEADLY);
            }
        }
            
        for (int i = 1; i <= power; i++)
        {
            // 检测上方
            if (row - i >= 0)
            {
                clearShockwave(row - i, col);
                map.removeFeature(row - i, col, Map.DEADLY);
            }
        }// 中间冲击波
    }
    
    /**
     * 清除指定单元格冲动波<br>
     * 由于炸弹层与道具层共享，所以当单元格为道具时，不予处理，否则清零
     * 
     * @param row 单元格所在行
     * @param col 单元格所在列
     */
    private void clearShockwave(int row, int col)
    {
        if (itemsLayer.getCell(col, row) > 4
                && itemsLayer.getCell(col, row) < Map.TOOL_BOMB)
        {
            itemsLayer.setCell(col, row, 0);
        }
    }

    /**
     * 正常状态
     */
    public static final int STATUS_NORMAL = 0;

    /**
     * 爆炸状态
     */
    public static final int STATE_EXPLODE = 1;

    /**
     * 爆炸延时
     */
    public static final int EXP_DELAY = 60;
}