firebrigadeagent.java

2004年robotcup世界冠军源代码

                                 y_minDistance).and(
                                 Y_PRP.lte(site.getMaxY() + 1000)).
                                 and((X_PRP.gte(site.getMinX())).and(X_PRP.lte(
                    site.getMaxX())));
            targetBuildings = northCnd.extract(target.burningBuildings());
            break;
        case 1:
            Condition eastCnd = X_PRP.gte(site.getMaxX() -
                                x_minDistance).and(
                                X_PRP.lte(site.getMaxX() + 1000)).
                                and((Y_PRP.gte(site.getMinY())).and(Y_PRP.lte(
                    site.getMaxY())));
            targetBuildings = eastCnd.extract(target.burningBuildings());
            break;
        case 2:
            Condition southCnd = Y_PRP.gte(site.getMinY() -
                                 1000).and(Y_PRP.lte(site.getMinY() +
                    y_minDistance)).
                                 and((X_PRP.gte(site.getMinX())).and(X_PRP.lte(
                    site.getMaxX())));
            targetBuildings = southCnd.extract(target.burningBuildings());
            break;

        case 3:
            Condition westCnd = X_PRP.gte(site.getMinX() -
                                1000).and(X_PRP.lte(site.getMinX() +
                    x_minDistance)).
                                and((Y_PRP.lte(site.getMaxY())).and(Y_PRP.gte(
                    site.getMinY())));
            targetBuildings = westCnd.extract(target.burningBuildings());
            break;

        }
        return targetBuildings;
    }

    public List selectTargetsForDirection(List buildingsInDirection) {
        List targetsInDirection = null;
        targetsInDirection = buildingsInDirection;
        return targetsInDirection;
    }

    public int getTotalDictanceOfVictimsInDirection(FireSite site,
            int direction) {

        List positions = POSITION_PRP.collect(world.needRescueCivs);
        int x_DepthSearch = Math.abs((site.getMaxX() - site.getMinX()) / 3);
        int y_DepthSearch = Math.abs((site.getMaxY() - site.getMinY()) / 3);
        int totalDistanceToFireSite;
        int mainDepthSearch = 75000;
        List victims = null;
        int xForDistance = 0;
        int yFOrDistance = 0;
        Building lastBuilding;

        switch (direction) {
        case 0:
            Condition northCondition = Y_PRP.gte(site.getMaxY() - y_DepthSearch).
                                       and(Y_PRP.lte(site.getMaxY() +
                    mainDepthSearch)).
                                       and((X_PRP.gte(site.getMinX() -
                    x_DepthSearch)).and(X_PRP.lte(site.getMaxX() +
                                                  x_DepthSearch)));
            lastBuilding = (Building) Y_PRP.max(site.burningBuildings());
            xForDistance = lastBuilding.x();
            yFOrDistance = lastBuilding.y();
            victims = northCondition.extract(positions);
            break;
        case 1:
            Condition eastCondition = X_PRP.gte(site.getMaxX() - x_DepthSearch).
                                      and(X_PRP.lte(site.getMaxX() +
                    mainDepthSearch)).
                                      and((Y_PRP.gte(site.getMinY() -
                    y_DepthSearch)).and(Y_PRP.lte(site.getMaxY() +
                                                  y_DepthSearch)));
            lastBuilding = (Building) X_PRP.max(site.burningBuildings());
            xForDistance = lastBuilding.x();
            yFOrDistance = lastBuilding.y();
            victims = eastCondition.extract(positions);
            break;
        case 2:
            Condition southCondition = Y_PRP.gte(site.getMinY() -
                                                 mainDepthSearch).and(Y_PRP.lte(
                    site.getMinY() + y_DepthSearch)).
                                       and((X_PRP.gte(site.getMinX() -
                    x_DepthSearch)).and(X_PRP.lte(site.getMaxX() +
                                                  x_DepthSearch)));
            lastBuilding = (Building) Y_PRP.min(site.burningBuildings());
            xForDistance = lastBuilding.x();
            yFOrDistance = lastBuilding.y();
            victims = southCondition.extract(positions);
            break;
        case 3:
            Condition westCondition = X_PRP.gte(site.getMinX() -
                                                mainDepthSearch).and(X_PRP.lte(
                    site.getMinX() + x_DepthSearch)).
                                      and((Y_PRP.lte(site.getMaxY() +
                    y_DepthSearch)).and(Y_PRP.gte(site.getMinY() -
                                                  y_DepthSearch)));
            lastBuilding = (Building) X_PRP.min(site.burningBuildings());
            xForDistance = lastBuilding.x();
            yFOrDistance = lastBuilding.y();
            victims = westCondition.extract(positions);
            break;
        }

        totalDistanceToFireSite = 0;
        for (Iterator it = victims.iterator(); it.hasNext(); ) {
            MotionlessObject hum = (MotionlessObject) it.next();
            int disToSite = Util.distance(hum.x(), hum.y(), xForDistance,
                                          yFOrDistance);
            totalDistanceToFireSite += disToSite;
        }

        return totalDistanceToFireSite;
    }

    void setUnBuriedAgents() {
        for (int i = 0; i < world.fireBrigades.size(); i++) {
            FireBrigade fb = (FireBrigade) world.fireBrigades.get(i);
            if (!fb.needRescue())
                unBuriedAgents.add(fb);
        }
    }

    public int getDistanceToCenterOfMap(FireSite site) {
        Node nodeCenter = world.getCenter();
        int x_centerMap = nodeCenter.x();
        int y_centerMap = nodeCenter.y();
        int distance = Util.distance(x_centerMap, y_centerMap,
                                     site.getCenter().x, site.getCenter().y);
        return distance;
    }

    public void extinguishPutOutBuildings() throws ActionCommandException {
        if (target == null)
            return;
        if (target.burnedDownBuildings().isEmpty())
            return;
        if (!target.burningBuildings().isEmpty())
            return;
        world.sortByID(world.fireBrigades);
        Building myTarget;
        if (target.isPutOff) {
            for (Iterator it = target.burnedDownBuildings().iterator();
                               it.hasNext(); ) {
                Building putOffBldg = (Building) it.next();
                if (!putOffBldg.isBurnedDownTimeSet) {
                    if (putOffBldg.buildingAreaTotal() <= 25000)
                        putOffBldg.extraExtinguishTime = 1;
                    else if (putOffBldg.buildingAreaTotal() > 25000 &&
                             putOffBldg.buildingAreaTotal() < 55000)
                        putOffBldg.extraExtinguishTime = 2;
                    else
                        putOffBldg.extraExtinguishTime = 3;
                    putOffBldg.timeOfPutout = time();
                    putOffBldg.isBurnedDownTimeSet = true;
                }
                if (time() >=
                    putOffBldg.timeOfPutout + putOffBldg.extraExtinguishTime)
                    putOffBldg.isPutOutAndExtinguish = true;
                if (time() <
                    putOffBldg.timeOfPutout + putOffBldg.extraExtinguishTime &&
                    putOffBldg.isBurnedDownTimeSet
                    && !putOffBldg.isPutOutAndExtinguish) {
                    if (self().distance(putOffBldg) <
                        SimulatorsConstants.EXTINGUISHABLE_DISTANCE) {
                        extinguish(putOffBldg);
                    } else
                        move(putOffBldg.entrance());
                }
            }

        }

    }

    public int getNumberUnBurnedBuildingAround(Building bd) {
        List connectedBldgs = bd.connectedBuildings;
        Condition cndUnBurned = FIERYNESS_PRP.eq(0);
        int count = Utils.getConditionCount(connectedBldgs, cndUnBurned);
        return count;
    }

    public void extinguishBuildingsInDirection(List buildingsInDirection) {

        float bd_value;
        float value = Float.MIN_VALUE;
        int distanceToCenterOfSite;
        int k=0;
        for (Iterator it = buildingsInDirection.iterator(); it.hasNext(); ) {
           //k++;
            Building bd = (Building) it.next();
            int bdCount = getNumberUnBurnedBuildingAround(bd);
            int victimCount = getVictimsAroundBuilding(bd);
            int disToSelf = self().distance(bd);
            distanceToCenterOfSite = getDistanceToCenterOfSite(bd);
            sortAgentDistanceToBuilding(bd);   // 18 june
            int index = firebrigadesAssignedToBuilding.indexOf(self());  // 18 june
            if ( ( bd.buildingAreaTotal() / 10000 ) < index-k )
               {
                   k+= (int)(bd.buildingAreaTotal() / 10000 );
                   System.err.println("self " + self().id + " time " + time() + " continue "  );
                   continue; // 18 june
               }
            bd_value = (float) ((time() - bd.getFireStart()) * -0.2 +
                                victimCount * 5 + bdCount +
                                distanceToCenterOfSite * 0.0005
                                + disToSelf * -0.0001 +
                                bd.buildingAreaTotal() * -0.0001 + 1000);
            if (bd_value > value) {
                value = bd_value;
                target_Building = bd;
            }
        }
    }

    public int getDistanceToCenterOfSite(Building bd) {
        int direction = target.getDirectionForExtinguish();
        int distance = 0;
        switch (direction) {
        case 0:
            distance = Math.abs(bd.y() - target.getCenter().y);
            break;
        case 1:
            distance = Math.abs(bd.x() - target.getCenter().x);
            break;
        case 2:
            distance = Math.abs(bd.y() - target.getCenter().y);
            break;
        case 3:
            distance = Math.abs(bd.x() - target.getCenter().x);
            break;

        }
        return distance;
    }

    Condition bagoor = FIERYNESS_PRP.lte(1).or(FIERYNESS_PRP.eq(5));


    public int getNumberVictimInConnectedBldgs(int direction, FireSite site) {
        int numOfSearch = 2;
        int numberVictim = 0;
        HashSet<Building> cndBldgs = new HashSet<Building>();
        HashSet<Building> unBurnedBldgs = new HashSet<Building>();

        List targets = getTargetsInExtinguishDirection(direction, site);
        for (int i = 0; i < numOfSearch; i++) {
            for (Iterator it = targets.iterator(); it.hasNext(); ) {
                Building bd = (Building) it.next();
                cndBldgs.addAll(bd.connectedBuildings);

            }

            unBurnedBldgs.addAll(FIERYNESS_PRP.eq(0).extract(cndBldgs));
            targets.clear();
            targets.addAll(unBurnedBldgs);
        }

            cndBldgs.removeAll(bagoor.not().extract(cndBldgs));
            targets.addAll(cndBldgs);

        List victimPositions = POSITION_PRP.collect(world.needRescueCivs);
        for (int i = 0; i < targets.size(); i++) {
            Building bd = (Building) targets.get(i);
            for (int j = 0; j < victimPositions.size(); j++) {
                if ((RealObject) victimPositions.get(j) == bd)
                    numberVictim++;
            }
        }
        return numberVictim;
    }


    public int getLastCoordinateInDirection(int direction, FireSite site) {
        Building lastBuilding;
        int lastCoordinate = 0;
        List bldgs;
        int distanceToEnd = 0;
        switch (direction) {
        case 0:
            Condition northCondition = Y_PRP.gt(site.getMaxY()).
                                       and((X_PRP.gt(site.getMinX() - 10000)).
                                           and(X_PRP.lt(site.getMaxX() + 10000)));
            bldgs = northCondition.extract(world.buildings);
            if (bldgs.isEmpty())
                return 0;
            lastBuilding = (Building) Y_PRP.max(bldgs);
            lastCoordinate = lastBuilding.y();
            distanceToEnd = Math.abs(lastCoordinate - target.getMaxY());
            break;
        case 1:
            Condition eastCondition = X_PRP.gt(site.getMaxX()).
                                      and((Y_PRP.gt(site.getMinY() - 10000)).
                                          and(Y_PRP.lt(site.getMaxY() + 10000)));
            bldgs = eastCondition.extract(world.buildings);
            if (bldgs.isEmpty())
                return 0;
            lastBuilding = (Building) X_PRP.max(bldgs);
            lastCoordinate = lastBuilding.x();
            distanceToEnd = Math.abs(lastCoordinate - target.getMaxX());
            break;
        case 2:
            Condition southCondition = Y_PRP.lt(site.getMinY()).
                                       and((X_PRP.gt(site.getMinX() - 10000)).
                                           and(X_PRP.lt(site.getMaxX() + 10000)));
            bldgs = southCondition.extract(world.buildings);
            if (bldgs.isEmpty())
                return 0;
            lastBuilding = (Building) Y_PRP.min(bldgs);
            lastCoordinate = lastBuilding.y();
            distanceToEnd = Math.abs(lastCoordinate - target.getMinY());
            break;
        case 3:
            Condition westCondition = X_PRP.lt(site.getMinX()).
                                      and((Y_PRP.lte(site.getMaxY() + 10000)).
                                          and(Y_PRP.gte(site.getMinY() - 10000)));
            bldgs = westCondition.extract(world.buildings);
            if (bldgs.isEmpty())
                return 0;
            lastBuilding = (Building) X_PRP.min(bldgs);