firesite.java

2004年robotcup世界冠军源代码

package yab.agent.object;

import java.util.*;
import java.util.List;
import java.awt.*;

import MRL.Utilities.*;
import yab.agent.Util;
import yab.agent.DisasterSpace;


public class FireSite implements ConstantConditions {


    public FireSite(Building fire) {
        fires.add(fire);
        ArrayList inDangerNeighbors = fire.inDangerNeighbors();
        if (inDangerNeighbors != null && inDangerNeighbors.size() > 0) {
            DangerousFires.add(fire);
        }

        siteNighbors.addAll(fire.connectedBuildings);
    }

    private boolean isReachable = false;
    public int numConnectedBldgs;
    public float DistancetoConnecteds;
    HashSet fires = new HashSet();
    HashSet DangerousFires = new HashSet();
    HashSet siteNighbors = new HashSet();
    public MotionlessObject nearestPosition;
    private ArrayList m_criticalBuildings;
    //added by saeed from here
    public float sumCndValues; 
    private float value=-1.0f;
    private int numOfBuildings = 0;
    private int totalFieryness;
    private float totalArea;
    public boolean isPutOff = false;
    public boolean isIgniteAgain = false;
    public boolean isIgnitionTimeSet = false;
    public int burningTime = 0 ;
    public int sensingTime = 0;
    public boolean isSensingTimeSet = false;
    private int m_maxX;
    private int m_maxY;
    private int m_minX;
    private int m_minY;
    //added by saeed until here

    /**
     * Checks whether fire can be added to the site
     *
     * @return 1, if can, 2 if cannot
     */
    public int addFire(Building fire) {
        if (containsFire(fire)) {
            return 1;
        }
        if (!isSiteNeighbor(fire)) {
            return -1;
        }
        fires.add(fire);
        siteNighbors.remove(fire);
        ArrayList inDangerNeighbors = fire.inDangerNeighbors();
        ArrayList burnedNeighbors = fire.burnedNeighbors();
        if (inDangerNeighbors != null) {
        }
        if (inDangerNeighbors != null && inDangerNeighbors.size() > 0) {
            DangerousFires.add(fire);
        }
        for (int i = 0; i < burnedNeighbors.size(); ++i) {
            Building b = (Building) burnedNeighbors.get(i);
            ArrayList inDangers = b.inDangerNeighbors();
            if (inDangers == null || inDangers.size() == 0) {
                DangerousFires.remove(b);
            }
        }
        for (int i = 0; i < fire.connectedBuildings.size(); ++i) {
            Building b = (Building) fire.connectedBuildings.get(i);
            if (!containsFire(b)) {
                siteNighbors.add(b);
            }
        }
        return 0;
    }

    /**
     * Removes any fire which will not cause any other fire to start.
     */
    public void updateCauseFieriness() {
        Object[] fires = DangerousFires.toArray();
        for (int i = 0; i < fires.length; ++i) {
            Building b = (Building) fires[i];
            int f = b.fieryness();
            if (f == 4 || f == 0) {
                DangerousFires.remove(b);
            }
        }
        fires = DangerousFires.toArray();
    }

    public void mergeWith(FireSite fs) {
        fires.addAll(fs.fires);
        siteNighbors.addAll(fs.siteNighbors);
        Object[] temp = siteNighbors.toArray();
        for (int i = 0; i < temp.length; ++i) {
            if (fires.contains(temp[i])) {
                siteNighbors.remove(temp[i]);
            }
        }
        DangerousFires.addAll(fs.DangerousFires);
    }


    public ArrayList burningBuildings() {
        ArrayList ret = new ArrayList();
        Object[] frs = fires.toArray();
        for (int i = 0; i < frs.length; ++i) {
            int f = ((Building) frs[i]).fieryness();
            if (f >= 1 && f <= 3) ret.add(frs[i]);
        }
        return ret;
    }

    public ArrayList burnedDownBuildings() {
        ArrayList ret = new ArrayList();
        Object[] frs = fires.toArray();
        for (int i = 0; i < frs.length; ++i) {
            if (((Building) frs[i]).fieryness() == 8) ret.add(frs[i]);
        }
        return ret;
    }

    public ArrayList semiBurnedBuildings() {
        ArrayList ret = new ArrayList();
        Object[] frs = fires.toArray();
        for (int i = 0; i < frs.length; ++i) {
            int f = ((Building) frs[i]).fieryness();
            if (f >= 5 && f <= 7) ret.add(frs[i]);
        }
        return ret;
    }

    public boolean containsFire(Building fire) {
        return fires.contains(fire);
    }

    public boolean isSiteNeighbor(Building b) {
        return siteNighbors.contains(b);
    }

    public ArrayList getFires() {
        ArrayList ret = new ArrayList();
        ret.addAll(fires);
        return ret;
    }

    public boolean isSafe() {
        boolean isSafe = true;
        for (Iterator iter = fires.iterator(); iter.hasNext();) {
            Building build = (Building) iter.next();
            int f = build.fieryness();
            if (f >= 1 && f <= 3) {
                isSafe = false;
                break;
            }
        }
        return isSafe;
    }

    public Building nearestBuilding(FireSite fs) {
        int tempdis = Integer.MAX_VALUE;
        Building tempBuilding = null;
        for (Iterator iter = fires.iterator(); iter.hasNext();) {
            Building build = (Building) iter.next();
            if (tempBuilding == null)
                tempBuilding = build;
            for (Iterator it = fs.fires.iterator(); it.hasNext();) {
                Building b = (Building) it.next();
                int dis = (Util.distance(build.x(), build.y(), b.x(), b.y()));
                if (dis < tempdis) {
                    tempdis = dis;
                    tempBuilding = build;
                }
            }
        }
        return tempBuilding;
    }

    public ArrayList criticalBuildings() {
        return m_criticalBuildings;
    }

    private double m_priority;

    public void setPriority(double value) {
        m_priority = value;
    }

    public double getPriority() {
        return m_priority;
    }

    private double m_totalVolume;

    public void setTotlaVolume(double value) {
        m_totalVolume = value;
    }

    public double getTotalVolume() {
        return m_totalVolume;
    }

    private Point m_center = new Point();

    public void setCenter(int x, int y) {
        m_center.x = x;
        m_center.y = y;
    }

    public Point getCenter() {
        return m_center;
    }

    private Refuge m_nearestRefuge;

    public void setNearestRefuge(Refuge ref) {
        m_nearestRefuge = ref;
    }

    public Refuge getNearestRefuge() {
        return m_nearestRefuge;
    }


    //added by saeed
    public void setMaxX(int maxX) {
        m_maxX = maxX;
    }

    public void setMaxY(int maxY) {
        m_maxY = maxY;
    }

    public void setMinX(int minX) {
        m_minX = minX;
    }

    public void setMinY(int minY) {
        m_minY = minY;
    }

    public int getMaxX() {
        return m_maxX;
    }

    public int getMaxY() {
        return m_maxY;
    }

    public int getMinX() {
        return m_minX;
    }

    public int getMinY() {
        return m_minY;
    }

    private double m_distanceToRefuge;

    public void setDistanceToNearestRefuge(double distance) {
        m_distanceToRefuge = distance;
    }

    public double getDistanceToNearestRefuge() {
        return m_distanceToRefuge;
    }


    public int totalFieryness_Area=0;
    public void updateSite(DisasterSpace world) {
        numOfBuildings = 0;
        totalFieryness = 0;
        totalArea = 0.0f;
        m_totalFireStart=0;
        totalFieryness_Area = 0;

        if (!this.burningBuildings().isEmpty() && this.isPutOff && !this.isIgnitionTimeSet)
        {
            this.isIgniteAgain = true;
            this.isIgnitionTimeSet = true;
            this.burningTime = world.time(); 
        }
        if (this.burningBuildings().isEmpty()) {
            this.isPutOff = true;
            this.isIgniteAgain = false;
            this.isIgnitionTimeSet = false;
            this.isSensingTimeSet = false;
            return;
        } else
            this.isPutOff = false;

        calculateCoordinates();

        for (Iterator it = this.burningBuildings().iterator(); it.hasNext();) {
            Building bd = (Building) it.next();


            ++numOfBuildings;
            totalFieryness += bd.fieryness();
            totalArea += bd.buildingAreaTotal();
            totalFieryness_Area += ( bd.buildingAreaTotal()*bd.fieryness() ) / 3;
            

        }
    }

    public int getNumberOfbuildings() {
        return numOfBuildings;
    }

    public float getTotalArea() {
        return totalArea;
    }

    public int getTotalfieryness() {
        return totalFieryness;
    }

    public void setValue(float value) {
        this.value = value;
    }


    public float getValue() {
        return this.value;
    }


    private Property X_PRP = new Property() {
        public Object eval(Object obj) {
            return new Integer(((MotionlessObject) obj).x());
        }
    };

    private Property Y_PRP = new Property() {
        public Object eval(Object obj) {
            return new Integer(((MotionlessObject) obj).y());
        }
    };

    public void calculateCoordinates() {
        int max_X = Integer.MIN_VALUE, max_Y = Integer.MIN_VALUE, min_X = Integer.MAX_VALUE, min_Y = Integer.MAX_VALUE;

        Building bd;

        bd =(Building)X_PRP.max(this.burningBuildings());
        max_X = bd.x();
        setBldgInMaxX(bd);
        setMaxX(max_X);

        bd =(Building)X_PRP.min(this.burningBuildings());
        min_X = bd.x();
        setBldgInMinX(bd);
        setMinX(min_X);

        bd =(Building)Y_PRP.max(this.burningBuildings());
        max_Y = bd.y();
        setBldgInMaxY(bd);
        setMaxY(max_Y);

        bd =(Building)Y_PRP.min(this.burningBuildings());
        min_Y = bd.y();
        setBldgInMinY(bd);
        setMinY(min_Y);

        int x_center = (max_X + min_X) / 2;
        int y_center = (max_Y + min_Y) / 2;
        setCenter(x_center, y_center);
    }

    private int m_numberVictimsAround;

    public void setNumberVictimsAround(int victimNumber) {
        m_numberVictimsAround = victimNumber;
    }

    public int getNumberVictimsAround() {
        return m_numberVictimsAround;
    }
 //saeed 85-2-3
    private int m_directionOfExtinguish;

    public void setDirectionForExtinguish(int direction) {
        m_directionOfExtinguish = direction;
    }

    public int getDirectionForExtinguish() {
        return m_directionOfExtinguish;
    }

    private int m_totalFireStart;
    public int getTotalFireStart(){
        return m_totalFireStart;
    }

    public void setReachability(boolean reachability)
    {
        isReachable = reachability;
    }

    public boolean isReachable()
    {
        return isReachable;
    }

    private Building maxX_Bldg;
    public void setBldgInMaxX(Building bd)
    {
          maxX_Bldg = bd;
    }

    private Building minX_Bldg;
    public void setBldgInMinX(Building bd)
    {
          minX_Bldg = bd;
    }

    private Building maxY_Bldg;
    public void setBldgInMaxY(Building bd)
    {
          maxY_Bldg = bd;
    }

    private Building minY_Bldg;
    public void setBldgInMinY(Building bd)
    {
          minY_Bldg = bd;
    }

    public Building getMaxXBldg()
    {
        return maxX_Bldg;
    }

    public Building getMinXBldg()
    {
        return minX_Bldg;
    }

    public Building getMaxYBldg()
    {
        return maxY_Bldg;
    }

    public Building getMinYBldg()
    {
        return minY_Bldg;
    }


}