Changeset 118


Ignore:
Timestamp:
11/10/10 23:16:40 (11 years ago)
Author:
BegemoT
Message:
 
Location:
AIChallenge/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • AIChallenge/src/Action.java

    r117 r118  
     1import java.util.*; 
     2 
    13/** 
    24 * @author ruslan 
     
    911                public double score( final IPlanet target, 
    1012                                     final IPWRuntime runtime ) { 
    11                         throw new UnsupportedOperationException( "Method not implemented yet" ); 
     13                        final IGameMap map = runtime.map(); 
     14                        final int turnsLeft = runtime.turnsLeft(); 
     15 
     16                        int msf = 0; 
     17                        int esf = 0; 
     18                        for( final IPlanet p : map.planets() ) { 
     19                                final SimpleIncomingIterator iter = SimpleIncomingIterator.create( p, map ); 
     20                                final EnumIntMap<Player> forecast = Helper.forecast( p, iter, runtime, turnsLeft ); 
     21                                msf += forecast.get( Player.ME ); 
     22                                esf += forecast.get( Player.ENEMY ); 
     23                        } 
     24                        //todo: fleets can still be in flight on game end! 
     25                        return ( ( double ) msf ) / esf; 
    1226                } 
    1327        }, 
     
    1630                public double score( final IPlanet target, 
    1731                                     final IPWRuntime runtime ) { 
     32                        final IGameMap map = runtime.map(); 
     33 
     34//                      final SimpleIncomingIterator iter = SimpleIncomingIterator.create( target, map ); 
     35//                      //eval forecast limit == max(my planets distance, fleets distance) 
     36//                      int horizon = iter.maxTurn(); 
     37//                      if( myPlanets.length > 0 ) { 
     38//                              horizon = Math.max( 
     39//                                              horizon, 
     40//                                              map.distance( target, myPlanets[myPlanets.length - 1] ) 
     41//                              ); 
     42//                      } 
     43// 
     44//                      class FightCB implements Helper.IFightCallback { 
     45//                              private final int horizonMax; 
     46//                              private final int horizonMin; 
     47// 
     48//                              private Player owner; 
     49//                              private EnumIntMap<Player> landed; 
     50//                              private final EnumIntMap<Player> lost = Player.createMap(); 
     51// 
     52//                              private int turn; 
     53// 
     54//                              FightCB( final int horizonMin, 
     55//                                       final int horizonMax ) { 
     56//                                      this.horizonMin = horizonMin; 
     57//                                      this.horizonMax = horizonMax; 
     58//                              } 
     59// 
     60//                              public boolean afterTurn( final int turn, 
     61//                                                        final Player owner, 
     62//                                                        final EnumIntMap<Player> shipsLanded, 
     63//                                                        final EnumIntMap<Player> shipsLost ) { 
     64//                                      lost.add( shipsLost ); 
     65//                                      if( turn < horizonMin ) { 
     66//                                              return true; 
     67//                                      } 
     68//                                      if( turn >= horizonMax || owner != Player.ME ) { 
     69//                                              this.landed = shipsLanded; 
     70//                                              this.owner = owner; 
     71//                                              this.turn = turn; 
     72//                                              return false; 
     73//                                      } 
     74//                                      return true; 
     75//                              } 
     76// 
     77//                              public void clear() { 
     78//                                      lost.clear(); 
     79//                              } 
     80//                      } 
     81//                      { 
     82//                              //do we actually need reinforcements? 
     83//                              final FightCB future = new FightCB( horizon, horizon ); 
     84//                              iter.reset(); 
     85//                              Helper.forEachTurn( target, iter, runtime, future ); 
     86//                              if( future.owner == Player.ME ) { 
     87//                                      return new VictoryForecast( false, -1, -1, -1, -1 ); 
     88//                              } 
     89//                      } 
     90//                      Arrays.sort( myPlanets, Commons.byDistanceAndShipsAvailable( map, target ) ); 
     91//                      for( final IPlanet planet : myPlanets ) { 
     92//                              final int dist = map.distance( planet, target ); 
     93//                              final int available = available( planet, map ); 
     94//                              if( dist > 0 && available > 0 ) { 
     95//                                      //search for first turn from now -- on which we're lost? 
     96//                                      final FightCB future = new FightCB( dist, horizon ); 
     97//                                      iter.reset(); 
     98//                                      Helper.forEachTurn( target, iter, runtime, future ); 
     99//                                      if( future.owner == Player.ME ) { 
     100//                                              return new VictoryForecast( 
     101//                                                              true, 
     102//                                                              future.lost.get( Player.ME ), 
     103//                                                              future.lost.get( Player.ENEMY ), 
     104//                                                              future.landed.get( Player.ME ), 
     105//                                                              future.turn 
     106//                                              ); 
     107//                                      } 
     108//                                      final int opponentsShips = future.landed.get( Player.ENEMY ) + future.landed.get( Player.NEUTRAL ); 
     109//                                      final int shipsForFight = Math.min( 
     110//                                                      available, 
     111//                                                      opponentsShips + 1 
     112//                                      ); 
     113//                                      assert ( shipsForFight > 0 ) : "ShipsForFight=" + shipsForFight + " <=0"; 
     114// 
     115//                                      //collect resources: 
     116//                                      //...already available 
     117//                                      iter.add( dist, Player.ME, shipsForFight ); 
     118//                                      //...and will be available on each turn after now 
     119//                                      final int growth = planet.growthRate(); 
     120//                                      for( int i = dist + 1; i <= horizon; i++ ) { 
     121//                                              iter.add( i, Player.ME, growth ); 
     122//                                      } 
     123//                                      //and do forecast 
     124//                                      iter.reset(); 
     125//                                      future.clear(); 
     126//                                      Helper.forEachTurn( target, iter, runtime, future ); 
     127//                                      if( future.owner == Player.ME ) { 
     128//                                              return new VictoryForecast( 
     129//                                                              true, 
     130//                                                              future.lost.get( Player.ME ), 
     131//                                                              future.lost.get( Player.ENEMY ), 
     132//                                                              future.landed.get( Player.ME ), 
     133//                                                              future.turn 
     134//                                              ); 
     135//                                      } 
     136//                              } 
     137//                      } 
     138//                      return new VictoryForecast( false, -1, -1, -1, -1 ); 
    18139                        throw new UnsupportedOperationException( "Method not implemented yet" ); 
    19140                } 
    20141        }, 
    21         ESCAPE{ 
     142        ESCAPE { 
    22143                @Override 
    23144                public double score( final IPlanet target, 
  • AIChallenge/src/SimpleBot2.java

    r117 r118  
    230230                final IGameMap map = runtime.map(); 
    231231 
    232  
    233232                final SimpleIncomingIterator iter = SimpleIncomingIterator.create( target, map ); 
    234233                //eval forecast limit == max(my planets distance, fleets distance) 
     
    278277                        } 
    279278                } 
    280                 //do we actually need reinforcements? 
    281279                { 
     280                        //do we actually need reinforcements? 
    282281                        final FightCB future = new FightCB( horizon, horizon ); 
    283282                        iter.reset(); 
Note: See TracChangeset for help on using the changeset viewer.