ambulancecenteragent.java

2004年robotcup世界冠军源代码

       for (Iterator it = victimAgent.iterator() ; it.hasNext();)
          {
              Humanoid hum  =(Humanoid)it.next();

                  if (hum instanceof FireBrigade)
                      buridFB.add(hum);
                  else if (hum instanceof PoliceForce)
                      buridPF.add(hum);
                  else if (hum instanceof AmbulanceTeam)
                      buridAT.add(hum);

          }



        if (time() <=75)
        {

             for (Iterator it = buridAT.iterator();it.hasNext();)
             {
                target=(Humanoid)it.next();
                if (numberOfFreeAtThatCanAccessTarget(target)>=1)
                    return target;

             }
             for (Iterator it = buridFB.iterator();it.hasNext();)
             {
                target=(Humanoid)it.next();
                if (numberOfFreeAtThatCanAccessTarget(target)>=1 )
                    return target;

             }
             for (Iterator it = buridPF.iterator();it.hasNext();)
             {
                target=(Humanoid)it.next();
                if (numberOfFreeAtThatCanAccessTarget(target)>=1)
                   return target;

             }
        }


        else //  after 75
        {

           if (!buridAT.isEmpty())
           {

               for (Iterator it = buridAT.iterator();it.hasNext();)
               {
                  target=(Humanoid)it.next();
                  if (numberOfFreeAtThatCanAccessTarget(target)>=1)
                     return target;

               }
           }
           else if (!buridFB.isEmpty() &&  world.burningBuildings.size()>=7)
           {
               for (Iterator it = buridFB.iterator();it.hasNext();)
               {
                 target=(Humanoid)it.next();
                  if (numberOfFreeAtThatCanAccessTarget(target)>=1 )
                     return target;

               }
           }
           else
           {
               tempBuriedAgentSet.addAll(victimAgent);
           }

        }

      return null;
    }

    private int numberOfFreeAtThatCanAccessTarget(Humanoid tar)
    {
        int n=0;

        for (Iterator it = freeAmbulances.iterator();it.hasNext();)
        {
            AmbulanceTeam at = (AmbulanceTeam)it.next();

            if (isAccesibleFromTo(at,tar.motionlessPosition()))
                n++;
        }
        return n;

    }

    private void assingAmbulancesToBuridAgent(Humanoid agentTarget)
    {
        int n= agentTarget.buriedness()/5;


        while (!freeAmbulances.isEmpty()&& agentTarget.ambulanceAssigned.size()<n)
        {


            AmbulanceTeam at = (AmbulanceTeam) selectAmbulanceToAssign(agentTarget);
            if (at != null)
            {
              messageManager.reportTarget(at,agentTarget);
              at.myAssignedTarget=agentTarget;
              freeAmbulances.remove(at);
              agentTarget.ambulanceAssigned.add(at);
              at.setTargetAssignmentTime(time());

            }
            else
                break;


        }


     }

////////////////////////////////////////////////////////////////////////////////

      private void rescueCivilianTargets()
      {
        if(civilianVictimSet.isEmpty() || freeAmbulances.isEmpty())
            return;


        Humanoid target = (Humanoid) selectCivilianTargets(civilianVictimSet);

        if (target!=null)
        {

            assignAmbulance(target);
            targetSet.add(target);
            lastTarget=target;
            target.assigned = true;
            civilianVictimSet.remove(target);
            rescueCivilianTargets();
        }
        else
            return;


      }

      //// ????????????????????????????
      private Humanoid selectCivilianTargets(ArrayList victims)
      {
          Humanoid target;

          for (Iterator it = victims.iterator() ; it.hasNext();)
          {
              target = (Humanoid)it.next();

              if ( target.getNoOfAmbulanceThatNeededToRescueMe()!=-1 && isRescueable(target)
                  && numberOfFreeAtThatCanAccessTarget(target)>0  )
              {
                  return target;
              }

          }

        return null;
      }


////////////////////////////////////////////////////////////////////////////////????????????????????????????????

      private boolean isRescueable(Humanoid temp)
      {
          int totalWork=0;

          for (Iterator it = world.ambulanceTeams.iterator() ; it.hasNext();)
          {
                AmbulanceTeam at  = (AmbulanceTeam)it.next();

                if ( at.getTimeToGetFree()+2<temp.getTimeToDead())
                 totalWork = totalWork + (temp.getTimeToDead()-(at.getTimeToGetFree()));
          }


          if (totalWork>temp.buriedness()+4)
              return true;
          else
              return false;
      }

      private int TimeToDeathFromInjury(Humanoid injured) {

      if (!(injured.position() instanceof Building))
       {

           if(injured.damage() < 5 )
               return Integer.MAX_VALUE;
           else
           {
               int time =Math.max(injured.hearTime(),injured.time());
               return (injured.hp()-(world.time()-time)*injured.damage())/injured.damage();

           }

       }

       Building bu = (Building) injured.motionlessPosition();
       if (bu != null && bu.isBurning()) {
           return Integer.MAX_VALUE;
       }
       int damage = injured.damage();
       int hp = injured.hp();
       int time=injured.hearTime();
       int timeto_death = 0;

       if (damage > 0 && hp < 10000) {
           double alpha = 0;
           double newAlpha = 0.01;
           while (java.lang.Math.abs(alpha - newAlpha) > 1E-10) {

               alpha = newAlpha;
               double tmp = java.lang.Math.exp( -alpha * time);
               newAlpha = ((alpha * time + 1) * tmp - 1) /
                          (time * tmp - (double) (10000 - hp) / damage);

           }

           if   (alpha> 0)
           timeto_death = time - world.time() +
                   (int) (java.lang.Math.ceil((7.0 / 8) *
                          java.lang.Math.log(alpha * hp /damage + 1) / alpha));
           else timeto_death=(hp-(world.time()-time)*damage)/damage;

           return timeto_death;
       }

       return Integer.MAX_VALUE / 2;


      }

      private int TimeToDeathFromFire(Humanoid injured) {
          if (injured.position() == null ||
                      !(injured.motionlessPosition() instanceof Building)) {
                      return Integer.MAX_VALUE;
                  }
                  Building b = (Building) injured.motionlessPosition();
                  if (NearestFiredBlg(b) == null) {
                      return Integer.MAX_VALUE;
                  }

                  int tempVar=0;
                       //  int damage = injured.damage();
                  Building po = NearestFiredBlg(b);
                  //if (damage<150)
                   if (time()-po.getFireStart()<=10)
                       tempVar=10-(time()-po.getFireStart());


                  return (int) (java.lang.Math.floor(XYDistance(b,po) /
                                             1000)+tempVar);
      }

      int TimeFiredMapUpdate = 0;
      HashMap NearestFiredMap = new HashMap();

      private Building NearestFiredBlg(Building blg) {

          if (TimeFiredMapUpdate < world.time()) {

              TimeFiredMapUpdate = world.time();
              NearestFiredMap.clear();

              Humanoid hum;
              Building bldg;
              Building target;
              Collection bbs = world.burningBuildings;
              if(bbs.isEmpty()) return null;
              for(Iterator it = world.humanoids.iterator();it.hasNext();){
                  hum = (Humanoid) it.next();
                  if(hum.position() != null && hum.motionlessPosition() instanceof Building){
                      bldg = (Building) hum.motionlessPosition();
                      if(NearestFiredMap.keySet().contains(bldg)) continue;
                      target = (Building)bldg.distancePrp.min(bbs);
                      NearestFiredMap.put(bldg,target);
                  }
              }

          } //if

          Building bl = (Building) NearestFiredMap.get(blg);
          return bl;

      }

      private double XYDistance(Building b1, Building b2) {

          return java.lang.Math.pow(java.lang.Math.pow(b1.x() - b2.x(), 2)
                                    + java.lang.Math.pow(b1.y() - b2.y(), 2), 0.5);

      }


      private long SqrDistance(Building b1, Building b2) {
          long dx = b1.x() - b2.x();
          long dy = b1.y() - b2.y();

          return dx * dx + dy * dy;
      }


      public final Router.CostFunction MOVING_COST_FUNCTION = new Router.CostFunction()
    {
       final float WEIGHT = (float) Integer.MAX_VALUE;
        final float notSeenC = 3f;
        final float notPassableC = WEIGHT;
        final float oneWayNotSeenC = WEIGHT/2;
        final float oneWayHasBlocksC = WEIGHT;
        final float hasBlocksC = WEIGHT;
        final Set trafficSet = world.inTraffic;
        final boolean bpol = world.self instanceof PoliceForce;
    public float cost(MotionlessObject from, MotionlessObject to) {
      float c = 1;
      if (! (to instanceof Road))
      {
          if(to instanceof Node)
          {
              if(from instanceof Road)
              {
                  if(to==(((Road)from).head()) && ((Road)from).linesToHead()<=0)
                  {
                    return notPassableC;
                  }
                  else if(to==(((Road)from).tail()) && ((Road)from).linesToTail()<=0 )
                  {
                    return notPassableC;
                  }
                  else if(((Road)from).linesToHead()<=0 || ((Road)from).linesToTail()<=0)
                  {
                    if (!((Road)from).hasBeenSeen())
                        return oneWayNotSeenC;
                    else if (((Road)from).passableLinesTo((PointObject)to) <= 0)
                        return oneWayHasBlocksC;
                  }

              }

          }
          return c;
      }
      Road rd = (Road) to;
      if(rd.head()==(PointObject) from)
      {
          if(rd.linesToTail()<=0) return notPassableC;
          else if (rd.linesToHead()<=0)
          {
              if (!(rd.hasBeenSeen()))
                 return oneWayNotSeenC;
              else if(rd.passableLinesFrom((PointObject)from) <=0)
                 return oneWayHasBlocksC;

          }

      }
      else if(rd.tail()==(PointObject) from)
      {
          if(rd.linesToHead()<=0) return notPassableC;
          else if (rd.linesToTail()<=0)
          {
              if (!(rd.hasBeenSeen()))
                 return oneWayNotSeenC;
              else if(rd.passableLinesFrom((PointObject)from) <=0)
                 return oneWayHasBlocksC;

          }
      }

      c*= rd.length();

      if(NOT_PASSABLE_C.eval(rd)) //rd.passableLinesFrom((PointObject)from) == 0
        return c*hasBlocksC;

      if(rd.hasBeenSeen()) return c;

      return c * notSeenC  ;
    }
  };

    public boolean isAccesibleFromTo(MovingObject from,MotionlessObject to)
    {
        ArrayList des=new ArrayList();
         des.add(to);

         if (time() <=20)
         {

             Route rt=Router.get(HumanoidAgent.outsidePosition(from),des,HumanoidAgent.RELIABILITY_COST_FUNCTION);
             if(rt.cost < NOT_SEEN_RD)
             {
               return true;
             }

         }
         else
         {

             Route rt=Router.get(HumanoidAgent.outsidePosition(from),des,MOVING_COST_FUNCTION);
             if(rt.cost < NOT_SEEN_RD)
             {
               return true;
             }


         }





         return false;

    }



  }