icfpc12: Check-in Differences

Difference From:

[6e4c06b018] Solver supports trampoline. (user: kinaba, tags: trunk, date: 2012-07-14 18:00:27)

To:

[fc9286dad1] uum (user: kinaba, tags: redesign, date: 2012-07-15 12:11:33)

Added

href="/repos/icfpc12/finfo?name=maps/40x40.map">maps/40x40.map os/icfpc12/artifact/06dc362ef16f425dd01d5ef115311b2a7b369fe0">[06dc362ef16f425d] 1 +######################################## 2 +#L\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 3 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 4 +#.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*# 5 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 6 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 7 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 8 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 9 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 10 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 11 +#.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*# 12 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 13 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 14 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 15 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 16 +#.\.\.\.\.\.\.\.\.\W\.\.\.\.\.\.\.\.\.\# 17 +#.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*# 18 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 19 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 20 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 21 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 22 +#.\.\.\.\!\.\.\.\.\.\.\.\W\.\.\.\.\.\.\# 23 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 24 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 25 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 26 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 27 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 28 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 29 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 30 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 31 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\!\.\.# 32 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 33 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 34 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\# 35 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\!\.\.# 36 +#.\.\.\.\.\.\.\.\W\.\.\.\.\.\.\.\.\.\.\# 37 +#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.# 38 +#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R# 39 +######################################## 40 + 41 +Flooding 80

Added maps/beard1.map version [bb6926793a51311a]


            1  +##########
            2  +#**  \\\\#
            3  +#.R..    #
            4  +# \  ..*\#
            5  +#!   ..*!#
            6  +####   # #
            7  +#\\... # L
            8  +#\\.W... #
            9  +#\\.     #
           10  +##########
           11  +
           12  +Growth 15
           13  +Razors 0

Added maps/beard2.map version [2e942009c89717d7]


            1  +##############################
            2  +#R...........................#
            3  +#.........................W..#
            4  +#..\\\\\\\\\\\\\\\\\\\\\\\\..#
            5  +#............................#
            6  +#..*****.*\...*...*...*****..#
            7  +#..*\....*\....*\*..*.\\*\\..#
            8  +#..*\....****..!*!......*....#
            9  +#..*\....*\....*\*..*...*....#
           10  +#..*\....*\...*...*.....*....#
           11  +#............................#
           12  +#..\\\\\\\\\\\\\\\\\\\\\\\\..#
           13  +#................ ..... .....#
           14  +#................      W....L#
           15  +##############################
           16  +
           17  +Growth 25
           18  +Razors 10
           19  +Flooding 20

Added maps/beard3.map version [1dcab340493857d0]


            1  +        ################
            2  +        #*****#!!  1   #
            3  +        #..\..#        #
            4  +#########\\\\ # .\\\.  #
            5  +#.............# *      #
            6  +#.. .\\\#..!..#\**     #
            7  +#.. LW\\#W  ..##### ####
            8  +#..R\\\\#.. ..*\*\*W...#
            9  +#.......A.. ...\.\...\\#
           10  +#..........     **     #
           11  +############....\.######
           12  +           #.....!#
           13  +           ########
           14  +
           15  +Growth 10
           16  +Trampoline A targets 1

Added maps/beard4.map version [b62967eb47a5f507]


            1  +####################
            2  +#W\\!#\\\**.\#W\\\W#
            3  +##*######..###..\\\#
            4  +#.......\.R ###...\#
            5  +#####.###.#.......##
            6  +#.......#.#\####.###
            7  +#\\##\###\#\\#...#.L
            8  +#\##\.###.####.#.#.#
            9  +#\W#####.....###.W.#
           10  +####\\...\\\...#.#.#
           11  +#W*######.######.#.#
           12  +#\\\\\\\\\.........#
           13  +############\###\###
           14  +#\\.. *..........\\#
           15  +#W... #.........##W#
           16  +####################

Deleted maps/trampoline4.map version [288f9d055c2777fa]


     1         -     ######
     2         -     #....#
     3         -     #.**.#
     4         -     #.**.#
     5         -     #.**.#
     6         -######.\\.######
     7         -#**....*.......#
     8         -#\\....L\\\....#
     9         -#A......*****..#
    10         -######R.....###########
    11         -     ###.....*.....\\\#
    12         -       #\\\\#..1...\\\#
    13         -       #\\\\#......\\\#
    14         -       ################
    15         -
    16         -Trampoline A targets 1

Added score_memo.txt version [95f0626c958d6d31]


            1  +contest1     212!
            2  +contest2     280?
            3  +contest3     275!
            4  +contest4     561?
            5  +contest5    1281?
            6  +contest6     737   // deadend trap
            7  +contest7     867?
            8  +contest8    1245   // tricky
            9  +contest9    3042?
           10  +contest10   2076   // * on lambda, must move * first
           11  +flood1       569   // too slow, because of 1-left danger lambda
           12  +flood2       280?
           13  +flood3       802   // too slow, drown
           14  +flood4       970   // incorrect order of digging
           15  +flood5       561?
           16  +trampoline1  291   // * on trampoline. must move * first
           17  +trampoline2 1728?
           18  +trampoline3  698   // * on trampoline target. must move * first.
           19  +beard1       856?
           20  +beard2      2792   // hutsu-ni muzui
           21  +beard3       811   // tricky. must hurry to cut hige.
           22  +beard4       677   // deadend trap

Added src/Makefile version [01a4f7a0531dae71]


            1  +# To build, the following packages are needed.
            2  +#   wget http://ftp.digitalmars.com/dmd_2.059-0_i386.deb
            3  +#   sudo apt-get install gcc gcc-multilib
            4  +#   sudo pkg -i dmd_2.059-0_i386.deb
            5  +
            6  +all:
            7  + dmd -O -release -inline -oflifter cui_auto_main.d driver.d game.d output.d solver.d util.d

Added src/driver.d version [3d15ff20e76164b8]


            1  +import game;
            2  +import util;
            3  +
            4  +interface GameObserver
            5  +{
            6  + // this(in Game g);
            7  + void on_game_changed(char c, in Game g, bool finished);
            8  +}
            9  +
           10  +class Driver
           11  +{
           12  + this(Game g) { this.game = g; }
           13  + this(File game_data) { this(new Game(game_data)); }
           14  +
           15  + void command(char c)
           16  + {
           17  +  if( finished )
           18  +   return;
           19  +  if( c == 'A' )
           20  +   aborted = true;
           21  +  else
           22  +   game.command(c);
           23  +  foreach(ob; observers)
           24  +   ob.on_game_changed(c, game, finished);
           25  + }
           26  +
           27  + T addObserver(T)()
           28  + {
           29  +  T t = new T(game);
           30  +  observers ~= t;
           31  +  return t;
           32  + }
           33  +
           34  + @property bool finished()
           35  + {
           36  +  return game.cleared || game.dead || aborted;
           37  + }
           38  +
           39  +private:
           40  + Game           game;
           41  + GameObserver[] observers;
           42  + bool           aborted = false;
           43  +}
           44  +
           45  +unittest
           46  +{
           47  + static class MockGame : Game {
           48  +  this() { super(null,null,null); }
           49  +  string log;
           50  +  void command(char c) { log ~= c; }
           51  + }
           52  + static class MockObserver : GameObserver {
           53  +  string log;
           54  +  this(in Game g) {}
           55  +  void on_game_changed(char c, in Game g, bool fin) { log~=c; if(fin)log~="$"; }
           56  + }
           57  +
           58  + auto g = new MockGame;
           59  + auto d = new Driver(g);
           60  + auto o = d.addObserver!MockObserver();
           61  + foreach(char c; "UDLRSAUDLRSA")
           62  +  d.command(c);
           63  + assert(g.log == "UDLRS");
           64  + assert(o.log == "UDLRSA$");
           65  +}

Modified src/game.d from [1b2e4ad2dae20251] to [fc05481901940844].


    45     45    mixin DeriveCreate;
    46     46    mixin DeriveCompare;
    47     47    mixin DeriveShow;
    48     48    Water clone() const { return cast(Water)this; }
    49     49   
    50     50    static load(string[string] params)
    51     51    {
    52         -  return new Water(
    53         -   params.get("Water",    "0").to!int(),
    54         -   params.get("Flooding", "0").to!int()
    55         -  );
           52  +  return new Water(params.get("Water",    "0").to!int(),
           53  +                   params.get("Flooding", "0").to!int());
    56     54    }
    57     55   
    58     56    int level(int number_of_update) const
    59     57    {
    60     58     return pace ? base+(number_of_update/pace) : base;
    61     59    }
    62     60   
................................................................................

    84     82    assert( 1 == w.level(3) );
    85     83    assert( 1 == w.level(4) );
    86     84    assert( 1 == w.level(5) );
    87     85   }
    88     86   
    89     87   ////////////////////////////////////////////////////////////////////////////////
    90     88   
           89  +class Hige
           90  +{
           91  + public immutable int pace;
           92  + mixin DeriveCreate;
           93  + mixin DeriveCompare;
           94  + mixin DeriveShow;
           95  + Hige clone() const { return cast(Hige)this; }
           96  +
           97  + static load(string[string] params)
           98  + {
           99  +  return new Hige(params.get("Growth", "25").to!int());
          100  + }
          101  +
          102  + bool is_growing_turn(int turn) const
          103  + {
          104  +  return pace ? turn%pace == pace-1 : false;
          105  + }
          106  +
          107  + int until_rise(int turn) const
          108  + {
          109  +  return pace ? pace-turn%pace : int.max;
          110  + }
          111  +}
          112  +
          113  +////////////////////////////////////////////////////////////////////////////////
          114  +
    91    115   class Map
    92    116   {
    93    117    mixin DeriveShow;
    94    118   
    95    119    static Map load(string[] raw_data, string[string] params, char[char] trampo)
    96    120    {
    97    121     // TODO: choose optimal representation.
................................................................................

    98    122     return new Map(raw_data, params, trampo);
    99    123    }
   100    124   
   101    125    char[][] data;
   102    126    Pos robot;
   103    127    Pos lift;
   104    128    int waterproof;
   105         - // TODO: immutable
   106    129    Pos[char] tr_target;
   107    130    Pos[][char] tr_source;
          131  + const(Hige) hige;
          132  + int razor;
   108    133   
   109    134    Map clone() const { return new Map(this); }
   110    135    this(in Map m) {
   111    136     foreach(s; m.data)
   112    137      this.data ~= s.dup;
   113    138     this.robot = m.robot.clone();
   114    139     this.lift = m.lift.clone();
   115    140     this.waterproof = m.waterproof;
   116    141     this.tr_target = cast(Pos[char])m.tr_target;
   117    142     this.tr_source = cast(Pos[][char])m.tr_source;
          143  +  this.hige = m.hige.clone();
          144  +  this.razor = m.razor;
   118    145    }
   119    146   
   120    147    this(string[] raw_data, string[string] params, char[char] trampo)
   121    148    {
   122    149     int width = 0;
   123    150     foreach(r; raw_data)
   124    151      width = max(width, r.length);
................................................................................

   146    173   
   147    174     this.waterproof = params.get("Waterproof", "5").to!int();
   148    175     foreach(fr,to; trampo) {
   149    176      tr_target[fr] = tr_pos[to];
   150    177      if(to !in tr_source) tr_source[to] = [];
   151    178      tr_source[to] ~= tr_pos[fr];
   152    179     }
          180  +
          181  +  this.hige = Hige.load(params);
          182  +  this.razor = params.get("Razors", "0").to!int();
   153    183    }
   154    184   
   155    185    const @property {
   156    186     int H() { return data.length; }
   157    187     int W() { return data[0].length; }
   158    188    }
   159    189   
................................................................................

   183    213    }
   184    214   
   185    215    void opIndexAssign(char c, in Pos p)
   186    216    {
   187    217     this[p.y, p.x] = c;
   188    218    }
   189    219   
   190         - Pos[] lambdas() const {
          220  + Pos[] objects(char c) const {
   191    221     Pos[] ans;
   192    222     for(int y=1; y<=H; ++y)
   193    223     for(int x=1; x<=W; ++x)
   194         -   if(this[y,x] == '\\')
          224  +   if(this[y,x] == c)
   195    225       ans ~= new Pos(y,x);
   196    226     return ans;
   197    227    }
   198    228   
          229  + Pos[] razors() const { return objects('!'); }
          230  + Pos[] lambdas() const { return objects('\\'); }
          231  +
   199    232    bool cleared() const
   200    233    {
   201    234     for(int y=1; y<=H; ++y)
   202    235     for(int x=1; x<=W; ++x)
   203    236      if(this[y,x] == 'L' || this[y,x] == 'O')
   204    237       return false;
   205    238     return true;
   206    239    }
   207    240   
   208         - Tuple!(int,bool) command(char c)
          241  + Tuple!(int,bool) command(char c, int turn)
   209    242    {
   210         -  if(c=='R') return move( 0, +1);
   211         -  if(c=='L') return move( 0, -1);
   212         -  if(c=='U') return move(+1,  0);
   213         -  if(c=='D') return move(-1,  0);
   214         -  if(c=='W') return move( 0,  0);
          243  +  assert( this[robot] == 'R' );
          244  +  if(c=='R') return move( 0, +1, turn);
          245  +  if(c=='L') return move( 0, -1, turn);
          246  +  if(c=='U') return move(+1,  0, turn);
          247  +  if(c=='D') return move(-1,  0, turn);
          248  +  if(c=='W') return move( 0,  0, turn);
          249  +  if(c=='S') return use_razor(turn);
   215    250     assert(false);
   216    251    }
   217    252   
   218         - Tuple!(int, bool) move(int dy, int dx)
          253  + Tuple!(int, bool) use_razor(int turn)
          254  + {
          255  +  if(razor) {
          256  +   razor--;
          257  +   for(int dy=-1; dy<=+1; ++dy)
          258  +   for(int dx=-1; dx<=+1; ++dx)
          259  +    if(this[robot.y+dy,robot.x+dx] == 'W')
          260  +     this[robot.y+dy,robot.x+dx] = ' ';
          261  +  }
          262  +
          263  +  bool dead = update(turn);
          264  +  return tuple(0,dead);
          265  + }
          266  +
          267  + Tuple!(int, bool) move(int dy, int dx, int turn)
   219    268    {
   220    269     int y = robot.y;
   221    270     int x = robot.x;
   222         -  assert( this[robot] == 'R' );
   223    271     int lambda = 0;
   224         -  bool dead = false;
   225    272     if( '\\' == this[y+dy,x+dx] )
   226    273      lambda++;
   227         -  if( " \\.O".count(this[y+dy,x+dx])==1 ) {
          274  +  if( '!' == this[y+dy,x+dx] )
          275  +   razor++;
          276  +  if( " \\!.O".count(this[y+dy,x+dx])==1 ) {
   228    277      this[y,x]=' ';
   229    278      this[y+dy,x+dx]='R';
   230    279      robot = new Pos(y+dy,x+dx);
   231    280     } else if(dy==0 && '*'==this[y+dy,x+dx] && ' '==this[y+dy*2,x+dx*2]) {
   232    281      this[y,x]=' ';
   233    282      this[y+dy,x+dx]='R';
   234    283      this[y+dy*2,x+dx*2]='*';
................................................................................

   237    286      this[y,x]=' ';
   238    287      Pos tp = tr_target[this[y+dy,x+dx]];
   239    288      foreach(p; tr_source[this[tp]])
   240    289       this[p] = ' ';
   241    290      this[tp] = 'R';
   242    291      robot = tp;
   243    292     }
   244         -  if( update() )
   245         -   dead = true;
          293  +  bool dead = update(turn);
   246    294     return tuple(lambda,dead);
   247    295    }
   248    296   
   249         - bool update()
          297  + bool update(int turn)
   250    298    {
   251    299     bool dead = false;
   252    300   
   253    301     char[][] next;
   254    302     foreach(y,s; data)
   255    303      next ~= s.dup;
   256    304   
................................................................................

   284    332         dead=true;
   285    333       }
   286    334      }
   287    335      else if(this[p]=='L') {
   288    336       if(!lambda)
   289    337        access(p) = 'O';
   290    338      }
          339  +   else if(this[p]=='W') {
          340  +    if( hige.is_growing_turn(turn) )
          341  +     for(int dy=-1; dy<=+1; ++dy)
          342  +     for(int dx=-1; dx<=+1; ++dx)
          343  +      if(this[p.y+dy,p.x+dx] == ' ')
          344  +       access(new Pos(p.y+dy,p.x+dx)) = 'W';
          345  +   }
   291    346     }
   292    347     data = next;
   293    348     return dead;
   294    349    }
   295    350   }
   296    351   
   297    352   ////////////////////////////////////////////////////////////////////////////////
   298    353   
   299    354   class Game
   300    355   {
   301         - mixin DeriveShow;
   302         -
   303         - static Game load(File input)
          356  +public:
          357  + this(File input)
   304    358    {
   305         -  string[]       raw_data;
   306         -  string[string] params;
   307         -
   308         -  // Raw map data; read until empty line.
          359  +  // Read map data
          360  +  string[] map_data_lines;
   309    361     for(string line; !(line=input.readln().chomp()).empty; )
   310         -   raw_data ~= line;
   311         -
   312         -  // Additional commands; read until EOF.
   313         -  char[char] trampo;
   314         -  for(string line; !(line=input.readln()).empty; ) {
   315         -   string[] ss = line.split();
   316         -   if( ss.length == 2 )
   317         -    params[ss[0]] = ss[1];
   318         -   if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="targets" )
   319         -    trampo[ss[1][0]] = ss[3][0];
   320         -  }
   321         -
   322         -  return load(raw_data, params, trampo);
   323         - }
   324         -
   325         - static Game load(string[] raw_data, string[string] params, char[char] trampo = null)
   326         - {
   327         -  return new Game(raw_data, params, trampo);
   328         - }
   329         -
   330         - this(string[] raw_data, string[string] params, char[char] trampo)
   331         - {
   332         -  this.map = Map.load(raw_data, params, trampo);
   333         -  this.water = Water.load(params);
   334         - }
   335         -
   336         - Game clone() const { return new Game(this); }
   337         - this(in Game g) {
   338         -  map = g.map.clone();
   339         -  water = g.water.clone();
   340         -  turn = g.turn;
   341         -  dead = g.dead;
   342         -  lambda = g.lambda;
   343         -  exit_bonus = g.exit_bonus;
   344         -  under_water = g.under_water;
   345         - }
   346         -
   347         - void command(char c)
   348         - {
   349         -  if(dead || cleared)
   350         -   return;
   351         -
   352         -  if(c == 'A')
          362  +   map_data_lines ~= line;
          363  +
          364  +  // H*W
          365  +  H_ = map_data_lines.length;
          366  +  W_ = 0;
          367  +  foreach(mdl; map_data_lines)
          368  +   W_ = max(W_, mdl.length);
          369  +
          370  +  // Copy to modifiable buffer and adjust coordinates.
          371  +  raw_data_ = new char[][H_+1];
          372  +  foreach(i,mdl; map_data_lines) {
          373  +   char[] buf = new char[mdl.length+1];
          374  +   buf[0] = '#';
          375  +   buf[1..$] = mdl[];
          376  +   raw_data_[H_-i] = buf;
          377  +  }
          378  +
          379  +  // Detect objects
          380  +  for(int y=1; y<=H_; ++y)
          381  +  for(int x=1; x<raw_data_[y].length; ++x)
          382  +  {
          383  +   char c = raw_data_[y][x];
          384  +   switch(c)
          385  +   {
          386  +   case '#':
          387  +   case '.':
          388  +   case ' ':
          389  +    break;
          390  +   case 'L':
          391  +   case 'O':
          392  +    lift_pos_ = new Pos(y,x);
          393  +    break;
          394  +   case 'A': .. case 'I':
          395  +   case '1': .. case '9':
          396  +    trampoline_pos_[c] = new Pos(y,x);
          397  +    break;
          398  +   case '!':
          399  +    razor_pos_ ~= new Pos(y,x);
          400  +    break;
          401  +   case '\\':
          402  +    lambda_pos_ ~= new Pos(y,x);
          403  +    break;
          404  +
          405  +   // Moving objects are erased from raw_data_
          406  +   case 'R':
          407  +    robot_pos_ = new Pos(y,x);
          408  +    raw_data_[y][x] = ' ';
          409  +    break;
          410  +   case '*':
          411  +   case 'W':
          412  +    dynamic_objects_[new Pos(y,x)] = c;
          413  +    raw_data_[y][x] = ' ';
          414  +    if(c=='*')
          415  +     may_update_[new Pos(y,x)] = true;
          416  +    break;
          417  +   default:
          418  +    assert(false);
          419  +   }
          420  +  }
          421  +
          422  +  // Read other parameters
          423  +  for(string line; !(line=input.readln()).empty; )
   353    424     {
   354         -   exit_bonus = 1;
   355         -   return;
   356         -  }
   357         -
   358         -  // TODO: clarify the event order
   359         -  Tuple!(int,bool) ld = map.command(c);
   360         -  if( map.cleared() ) {
   361         -   exit_bonus = 2;
   362         -  }
   363         -  else {
   364         -   lambda += ld[0];
   365         -   if( ld[1] ) {
   366         -    dead = true;
          425  +   string[] ss = line.split();
          426  +   if( ss.length == 2 )
          427  +    switch(ss[0])
          428  +    {
          429  +    case "Water":      water_base_ = ss[1].to!int(); break;
          430  +    case "Flooding":   water_pace_ = ss[1].to!int(); break;
          431  +    case "Waterproof": max_air_    = ss[1].to!int(); break;
          432  +    case "Growth":     hige_pace_  = ss[1].to!int(); break;
          433  +    case "Razors":     num_razor_  = ss[1].to!int(); break;
          434  +    default: assert(false);
          435  +    }
          436  +   if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="targets" )
          437  +   {
          438  +    char fr=ss[1][0], to=ss[3][0];
          439  +    trampoline_[fr] = to;
          440  +    if(to !in trampoline_rev_) trampoline_rev_[to] = [];
          441  +    trampoline_rev_[to] ~= fr;
   367    442      }
   368    443     }
   369         -  if( map.robot.y <= water_level )
   370         -   ++under_water;
   371         -  else
   372         -   under_water = 0;
   373         -  if( under_water > map.waterproof )
   374         -   dead = true;
   375         -  turn += 1;
          444  +
          445  +  air_left_ = max_air_;
   376    446    }
   377    447   
   378         - Map map;
   379         - Water water;
   380         - int  turn = 0;
   381         - bool dead = false;
   382         - int  lambda = 0;
   383         - int  exit_bonus = 0;
   384         - int  under_water = 0;
   385         - // TODO: when adding members, take care of clone().
   386         - // TODO: fix this poor design.
   387         -
   388    448    @property const {
   389         -  long score() { return lambda*25L*(1+exit_bonus) - turn; }
   390         -  int water_level() { return water.level(turn); }
   391         -  int water_until_rise() { return water.until_rise(turn); }
   392         -  bool cleared() { return exit_bonus>0; }
   393         -  int hp() { return map.waterproof - under_water; }
   394         -  long score_if_abort_now() { return lambda*25*(1+max(1,exit_bonus)) - turn; }
          449  +  int H() { return H_; }
          450  +  int W() { return W_; }
          451  +  char trampoline(char c) { return (c in trampoline_ ? trampoline_[c] : 0); }
          452  +  const(Pos)[] trampoline_rev(char c) {
          453  +   const(Pos)[] pp;
          454  +   if(c in trampoline_rev_) {
          455  +    foreach(ch; trampoline_rev_[c])
          456  +     pp ~= trampoline_pos_[ch];
          457  +   }
          458  +   return pp;
          459  +  }
          460  +  int water_level() {
          461  +   return water_pace_ ? water_base_ + turn_/water_pace_ : water_base_;
          462  +  }
          463  +  int water_until_rise() {
          464  +   return water_pace_ ? water_pace_ - turn_%water_pace_ : int.max;
          465  +  }
          466  +  int hige_until_rise() {
          467  +   return hige_pace_ ? hige_pace_ - turn_%hige_pace_ : int.max;
          468  +  }
          469  +  bool is_hige_turn() {
          470  +   return hige_pace_ ? turn_%hige_pace_ == hige_pace_-1 : false;
          471  +  }
          472  +  int hp() { return air_left_; }
          473  +  int num_razor() { return num_razor_; }
          474  +  bool cleared() { return cleared_; }
          475  +  bool dead() { return dead_; }
          476  +  long score() { return num_lambda_*(dead_ ? 25L : cleared_ ? 75L : 50L) - turn_; }
          477  +  const(Pos) robot() { return robot_pos_; }
          478  +  const(Pos) lift() { return lift_pos_; }
          479  +  Pos[] lambdas() {
          480  +   Pos[] pp;
          481  +   foreach(p; lambda_pos_)
          482  +    pp ~= p.clone();
          483  +   return pp;
          484  +  }
          485  +  Pos[] razors() {
          486  +   Pos[] pp;
          487  +   foreach(p; razor_pos_)
          488  +    pp ~= p.clone();
          489  +   return pp;
          490  +  }
          491  +  const(Pos)[] higes() {
          492  +   const(Pos)[] pp;
          493  +   foreach(p,c; dynamic_objects_)
          494  +    if(c=='W')
          495  +     pp ~= p;
          496  +   return pp;
          497  +  }
          498  + }
          499  + const {
          500  +  char opIndex(in Pos p) { return opIndex(p.y, p.x); }
          501  +  char opIndex(int y, int x) { return map_get(y, x); }
          502  + }
          503  +
          504  +public:
          505  + void command(char c)
          506  + {
          507  +  if(dead || cleared)
          508  +   return;
          509  +
          510  +  if(c == 'U') command_move(+1, 0);
          511  +  if(c == 'D') command_move(-1, 0);
          512  +  if(c == 'L') command_move(0, -1);
          513  +  if(c == 'R') command_move(0, +1);
          514  +  if(c == 'S') use_razor();
          515  +  if(c == 'W') {}
          516  +
          517  +  if(!cleared)
          518  +  {
          519  +   map_update();
          520  +   water_update();
          521  +  }
          522  +  turn_ ++;
          523  + }
          524  +
          525  + void command_move(int dy, int dx)
          526  + {
          527  +  int y = robot_pos_.y, x = robot_pos_.x;
          528  +  char c = this[y+dy, x+dx];
          529  +  Pos p = new Pos(y+dy, x+dx);
          530  +
          531  +  switch(c){
          532  +  case 'O':
          533  +   cleared_ = true;
          534  +   move_robot_to(p);
          535  +   break;
          536  +  case '\\':
          537  +   take_lambda_at(p);
          538  +   move_robot_to(p);
          539  +   break;
          540  +  case '!':
          541  +   take_razor_at(p);
          542  +   move_robot_to(p);
          543  +   break;
          544  +  case 'A': .. case 'I':
          545  +   enter_trampoline_at(p, c);
          546  +   break;
          547  +  case ' ':
          548  +  case '.':
          549  +   move_robot_to(p);
          550  +   break;
          551  +  case '*':
          552  +   if(dy!=0 || this[y,x+dx*2]!=' ')
          553  +    break;
          554  +   move_robot_to(p);
          555  +   push_rock(p, new Pos(y,x+dx*2));
          556  +   break;
          557  +  default:
          558  +   break;
          559  +  }
          560  + }
          561  +
          562  + void use_razor()
          563  + {
          564  +  if(num_razor_ == 0)
          565  +   return;
          566  +  num_razor_ --;
          567  +
          568  +  for(int dy=-1; dy<=+1; ++dy)
          569  +  for(int dx=-1; dx<=+1; ++dx) if(dy||dx)
          570  +  {
          571  +   Pos p = new Pos(robot_pos_.y+dy, robot_pos_.x+dx);
          572  +   if(auto it = p in dynamic_objects_)
          573  +    if(*it == 'W') {
          574  +     something_gone(p);
          575  +     dynamic_objects_.remove(p);
          576  +    }
          577  +  }
          578  + }
          579  +
          580  + void take_lambda_at(Pos p)
          581  + {
          582  +  map_set_empty(p);
          583  +  num_lambda_ ++;
          584  +  lambda_pos_ = lambda_pos_.erase(p);
          585  + }
          586  +
          587  + void take_razor_at(Pos p)
          588  + {
          589  +  map_set_empty(p);
          590  +  num_razor_ ++;
          591  +  razor_pos_ = razor_pos_.erase(p);
          592  + }
          593  +
          594  + void enter_trampoline_at(Pos p, char c)
          595  + {
          596  +  char d = trampoline(c);
          597  +  foreach(cc; trampoline_rev_[d]) {
          598  +   Pos pp = trampoline_pos_[cc];
          599  +   something_gone(pp);
          600  +   map_set_empty(pp);
          601  +  }
          602  +  move_robot_to(trampoline_pos_[d]);
          603  + }
          604  +
          605  + void move_robot_to(Pos p)
          606  + {
          607  +  something_gone(robot_pos_);
          608  +  map_set_empty(p.y, p.x);
          609  +  robot_pos_ = p;
          610  + }
          611  +
          612  + void push_rock(Pos fr, Pos to)
          613  + {
          614  +  dynamic_objects_.remove(fr);
          615  +  dynamic_objects_[to] = '*';
          616  +  may_update_[to] = true;
          617  + }
          618  +
          619  + void something_gone(Pos p)
          620  + {
          621  +  for(int dy=0;  dy<=+1; ++dy)
          622  +  for(int dx=-1; dx<=+1; ++dx) if(dy||dx)
          623  +   may_update_[new Pos(p.y+dy,p.x+dx)] = true;
          624  + }
          625  +
          626  + void map_update()
          627  + {
          628  +  Pos[] may_update_list;
          629  +  foreach(p,_; may_update_)
          630  +   if(this[p] == '*')
          631  +    may_update_list ~= p;
          632  +  may_update_ = null;
          633  +
          634  +  if( is_hige_turn() )
          635  +   foreach(p,c; dynamic_objects_)
          636  +    if(c == 'W')
          637  +     may_update_list ~= p;
          638  +
          639  +  sort(may_update_list);
          640  +  char[Pos] to_be_written;
          641  +  foreach(p; may_update_list)
          642  +   if(is_hige_turn() && this[p]=='W')
          643  +   {
          644  +    for(int dy=-1; dy<=+1; ++dy)
          645  +    for(int dx=-1; dx<=+1; ++dx) {
          646  +     Pos q = new Pos(p.y+dy,p.x+dx);
          647  +     if( this[q] == ' ' )
          648  +      to_be_written[q] = 'W';
          649  +    }
          650  +   }
          651  +   else
          652  +   {
          653  +    int y = p.y;
          654  +    int x = p.x;
          655  +    char below = this[y-1,x];
          656  +    // *
          657  +    // _
          658  +    if(below==' ') {
          659  +     Pos q = new Pos(y-1,x);
          660  +     to_be_written[p] = ' ';
          661  +     to_be_written[q] = '*';
          662  +     may_update_[q] = true;
          663  +    }
          664  +    // *_      *_
          665  +    // *_  or  \_
          666  +    else if((below=='*'||below=='\\')&&this[y-1,x+1]==' '&&this[y,x+1]==' ') {
          667  +     Pos q = new Pos(y-1,x+1);
          668  +     to_be_written[p] = ' ';
          669  +     to_be_written[q] = '*';
          670  +     may_update_[q] = true;
          671  +    }
          672  +    // _*
          673  +    // _*
          674  +    else if(below=='*'&&this[y-1,x-1]==' '&&this[y,x-1]==' ') {
          675  +     Pos q = new Pos(y-1,x-1);
          676  +     to_be_written[p] = ' ';
          677  +     to_be_written[q] = '*';
          678  +     may_update_[q] = true;
          679  +    }
          680  +   }
          681  +
          682  +  foreach(p,c; to_be_written) {
          683  +   dynamic_objects_[p] = c;
          684  +   if(c=='*' && p.y==robot_pos_.y+1 && p.x==robot_pos_.x)
          685  +    dead_ = true;
          686  +  }
          687  +
          688  +  if(lambda_pos_.empty)
          689  +   raw_data_[lift_pos_.y][lift_pos_.x] = 'O';
          690  + }
          691  +
          692  + void water_update()
          693  + {
          694  +  if( robot_pos_.y <= water_level() )
          695  +   air_left_ --;
          696  +  else
          697  +   air_left_ = max_air_;
          698  +  if( air_left_ < 0 )
          699  +   dead_ = true;
          700  + }
          701  +
          702  +private:
          703  + char map_get(int y, int x) const
          704  + {
          705  +  if( y<1 || H<y || x<1 || W<x ) return '#';
          706  +  Pos p = new Pos(y,x);
          707  +  if(p == robot_pos_)
          708  +   return 'R';
          709  +  if(auto it = (p in dynamic_objects_))
          710  +   return *it;
          711  +  if( x<0 || raw_data_[y].length<=x ) return ' ';
          712  +  return raw_data_[y][x];
          713  + }
          714  +
          715  + void map_set_empty(in Pos p)
          716  + {
          717  +  return map_set_empty(p.y, p.x);
          718  + }
          719  +
          720  + void map_set_empty(int y, int x)
          721  + {
          722  +  if( y<1 || H<y || x<1 || W<x ) return;
          723  +  if( x<0 || raw_data_[y].length<=x ) return;
          724  +  raw_data_[y][x] = ' ';
          725  + }
          726  +
          727  +public:
          728  + Game clone() const { return new Game(this); }
          729  + this(in Game g) {
          730  +  H_ = g.H_;
          731  +  W_ = g.W_;
          732  +  raw_data_ = new char[][g.raw_data_.length];
          733  +  foreach(i,d; g.raw_data_) raw_data_[i] = d.dup;
          734  +  trampoline_pos_ = cast(Pos[char]) g.trampoline_pos_;
          735  +  razor_pos_  = (cast(Game)g).razor_pos_.dup;
          736  +  lambda_pos_ = (cast(Game)g).lambda_pos_.dup;
          737  +  lift_pos_   = g.lift_pos_.clone();
          738  +  robot_pos_  = g.robot_pos_.clone();
          739  +  dynamic_objects_ = dup(g.dynamic_objects_);
          740  +  trampoline_     = (cast(Game)g).trampoline_;
          741  +  trampoline_rev_ = (cast(Game)g).trampoline_rev_;
          742  +  water_base_ = g.water_base_;
          743  +  water_pace_ = g.water_pace_;
          744  +  max_air_    = g.max_air_;
          745  +  hige_pace_  = g.hige_pace_;
          746  +  num_razor_  = g.num_razor_;
          747  +  num_lambda_ = g.num_lambda_;
          748  +  turn_       = g.turn_;
          749  +  air_left_   = g.air_left_;
          750  +  cleared_    = g.cleared_;
          751  +  dead_       = g.dead_;
          752  +  may_update_ = dup(g.may_update_);
          753  + }
          754  +
          755  + V[K] dup(V,K)(in V[K] aa) {
          756  +  V[K] aa2;
          757  +  foreach(k,v; aa) aa2[k] = v;
          758  +  return aa2;
   395    759    }
   396         -}
          760  +
          761  +private:
          762  + int          H_;
          763  + int          W_;
          764  + char[][]     raw_data_;
          765  + Pos[char]    trampoline_pos_;
          766  + Pos[]        razor_pos_;
          767  + Pos[]        lambda_pos_;
          768  + Pos          lift_pos_;
          769  + Pos          robot_pos_;
          770  + char[Pos]    dynamic_objects_;
          771  + char[char]   trampoline_;
          772  + char[][char] trampoline_rev_;
          773  + int          water_base_ = 0;
          774  + int          water_pace_ = 0;
          775  + int          max_air_    = 10;
          776  + int          hige_pace_  = 25;
          777  + int          num_razor_  = 0;
          778  + int          num_lambda_ = 0;
   397    779   
   398         -unittest
   399         -{
   400         - Game.load(["###","...","#RL"], ["xxx":"yyy"]);
          780  + int turn_     = 0;
          781  + int air_left_ = 0;
          782  + bool cleared_ = false;
          783  + bool dead_    = false;
          784  + bool[Pos] may_update_;
   401    785   }

Modified src/gui.d from [8a1eba48f0346eec] to [e84cacd6262f93a7].


     4      4   import driver;
     5      5   
     6      6   class GUI(Solver) : Form, GameObserver
     7      7   {
     8      8    this(in Game g)
     9      9    {
    10     10     this.solver = new Solver(g);
    11         -  setup_size(g.map.W, g.map.H);
           11  +  setup_size(g.W, g.H);
    12     12     setup_resources(g);
    13     13     draw(g);
    14     14    }
    15     15   
    16     16    private void delegate(char c) fn;
    17     17    void set_fn(F)(F f) { this.fn = f; }
    18     18   
................................................................................

    64     64     this.colors['.'] = Color(255,191,127);
    65     65     this.colors['*'] = Color(255,127,127);
    66     66     this.colors['R'] = Color(128,128,0);
    67     67     this.colors['d'] = Color(255,0,0);
    68     68     this.colors['\\'] =
    69     69     this.colors['L'] =
    70     70     this.colors['O'] = Color(127,255,127);
    71         -  this.colors['W'] = Color(204,229,255);
           71  +  this.colors['w'] = Color(204,229,255);
           72  +  this.colors['W'] =
           73  +  this.colors['!'] = Color(159,159,159);
    72     74     foreach(char c; 'A'..'J') this.colors[c] = Color(142,142,255);
    73     75     foreach(char c; '1'..':') this.colors[c] = Color(255,142,255);
    74     76     this.render['#'] = "■";
    75     77     this.render['*'] = "✹";
    76     78     this.render['.'] = "♒";
    77     79     this.render['\\'] = "λ";
    78     80     this.render['R'] = "☃";
    79     81     this.render['d'] = "☠";
    80     82     this.render['L'] = "☒";
    81     83     this.render['O'] = "☐";
    82         -  foreach(c,tp; g.map.tr_target) {
    83         -   char d = g.map[tp];
    84         -   this.render[c] = [cast(dchar)('㋀'+d-'1')].to!string();
    85         -  }
    86         -  foreach(char c; '1'..':') this.render[c] = [cast(dchar)('㏠'+c-'1')].to!string();
           84  +  this.render['W'] = "ꔣ";
           85  +  this.render['!'] = "✄";
           86  +  foreach(char c; 'A'..'J') this.render[c] = [cast(dchar)('☢'+g.trampoline(c)-'1')].to!string();
           87  +  foreach(char c; '1'..':') this.render[c] = [cast(dchar)('☢'+c-'1')].to!string();
    87     88     this.paint ~= (Control c, PaintEventArgs ev) {
    88     89      graphicContext.copyTo(ev.graphics, Rect(0,0,this.clientSize.width,this.clientSize.height));
    89     90     };
    90     91    }
    91     92   
    92     93    void draw(in Game g)
    93     94    {
................................................................................

    95     96     int scrH = this.clientSize.height;
    96     97   
    97     98     // Fill bg.
    98     99     graphicContext.fillRectangle(this.backColor, Rect(0,0,scrW,scrH));
    99    100   
   100    101     // Fill water.
   101    102     int w = g.water_level();
   102         -  graphicContext.fillRectangle(this.colors['W'], Rect(0, scrH-cell*w-1, scrW, cell*w+1));
          103  +  graphicContext.fillRectangle(this.colors['w'], Rect(0, scrH-cell*w-1, scrW, cell*w+1));
   103    104   
   104    105     // Paint map.
   105         -  for(int y=1; y<=g.map.H; ++y)
   106         -  for(int x=1; x<=g.map.W; ++x) {
          106  +  for(int y=1; y<=g.H; ++y)
          107  +  for(int x=1; x<=g.W; ++x) {
   107    108      Rect r = Rect(cell*(x-1), scrH-cell*y, cell, cell);
   108         -   char c = g.map[y,x];
          109  +   char c = g[y,x];
   109    110      if( c != ' ' ) {
   110    111       if( c == 'R' && g.dead )
   111    112        c = 'd';
   112    113       graphicContext.drawText(this.render[c], font, this.colors[c], r);
   113    114      }
   114    115     }
   115    116   
   116    117     // Update textual info.
   117         -  this.text = .text("Score: ", g.score, " Air: ", g.hp, " Tide: ", g.water_until_rise);
          118  +  this.text = .text(
          119  +   "Score: ", g.score,
          120  +   " Air: ", g.hp,
          121  +   " Tide: ", g.water_until_rise,
          122  +   " Wadler: ", g.hige_until_rise,
          123  +   " Razor: ", g.num_razor);
   118    124     invalidate();
   119    125    }
   120    126   
   121    127   private:
   122    128    void setup_keyhandling()
   123    129    {
   124    130     noMessageFilter();
   125    131     this.keyDown ~= &my_keydown;
   126    132    }
          133  +
          134  + void do_manual_command(char c)
          135  + {
          136  +  solver.force(c);
          137  +  fn(c);
          138  + }
   127    139   
   128    140    void my_keydown(Control c, KeyEventArgs ev)
   129    141    {
   130    142     switch(ev.keyCode)
   131    143     {
   132         -  case Keys.DOWN:  fn('D'); break;
   133         -  case Keys.UP:    fn('U'); break;
   134         -  case Keys.LEFT:  fn('L'); break;
   135         -  case Keys.RIGHT: fn('R'); break;
   136         -  case Keys.W:     fn('W'); break;
   137         -  case Keys.A:     fn('A'); break;
          144  +  case Keys.DOWN:  do_manual_command('D'); break;
          145  +  case Keys.UP:    do_manual_command('U'); break;
          146  +  case Keys.LEFT:  do_manual_command('L'); break;
          147  +  case Keys.RIGHT: do_manual_command('R'); break;
          148  +  case Keys.W:     do_manual_command('W'); break;
          149  +  case Keys.S:     do_manual_command('S'); break;
          150  +  case Keys.A:     do_manual_command('A'); break;
   138    151     case Keys.G:     fn(solver.single_step()); break;
   139    152     default:         break;
   140    153     }
   141    154    }
   142    155   
   143    156    Solver solver;
   144    157   }

Modified src/output.d from [62e6040714438eff] to [e2d0d7db868c3a44].


    20     20   }
    21     21   
    22     22   class GuardedOutput : GameObserver
    23     23   {
    24     24    this(in Game g)
    25     25    {
    26     26     setup_sigint_handling();
    27         -  ideal_log ~= g.score_if_abort_now;
           27  +  score_log ~= g.score;
    28     28     flushed = false;
    29     29    }
    30     30   
    31     31    override void on_game_changed(char c, in Game g, bool finished)
    32     32    {
    33     33     if(flushed)
    34     34      return;
    35     35   
    36     36     log ~= c;
    37     37     score_log ~= g.score;
    38         -  ideal_log ~= g.score_if_abort_now;
    39         -  if(finished || log.length+1==g.map.W*g.map.H)
           38  +  if(finished || log.length+1==g.W*g.H)
    40     39      flush();
    41     40    }
    42     41   
    43     42   private:
    44     43    string log;
    45     44    long[] score_log;
    46         - long[] ideal_log;
    47     45    bool   flushed;
    48     46   
    49     47    void flush()
    50     48    {
    51         -  Tuple!(long, int, int) cand;
           49  +  if(flushed)
           50  +   return;
           51  +
           52  +  Tuple!(long, int) cand;
    52     53     cand[0] = long.min;
    53     54   
    54     55     for(int i=0; i<score_log.length; ++i)
    55     56      if(cand[0] < score_log[i])
    56         -    cand = tuple(score_log[i],i,0);
    57         -  for(int i=0; i<ideal_log.length; ++i)
    58         -   if(cand[0] < ideal_log[i])
    59         -    cand = tuple(ideal_log[i],i,1);
           57  +    cand = tuple(score_log[i],i);
    60     58   
    61         -  if(cand[2]==0) {
    62         -   string str = log[0..cand[1]+1];
    63         -   std.c.stdio.printf("%.*s\n", str.length, str.ptr);
    64         -  } else {
    65         -   string str = log[0..cand[1]];
    66         -   std.c.stdio.printf("%.*sA\n", str.length, str.ptr);
    67         -  }
           59  +  std.c.stdio.printf("%.*sA\n", cand[1], log.ptr);
    68     60     std.c.stdio.fflush(std.c.stdio.stdout);
    69     61     flushed = true;
    70     62    }
    71     63   
    72     64   private:
    73     65    static __gshared GuardedOutput g_output;
    74     66

Modified src/solver.d from [4aac390deb513002] to [22c356ff1975e92f].


     1      1   import util;
     2      2   import game;
     3      3   
     4      4   class Solver_0
     5      5   {
     6         - this(const(Game) g) {}
            6  + this(in Game g) {}
     7      7    char single_step() { return 'W'; }
            8  + void force(char c) {}
     8      9   }
     9     10   
    10     11   class Solver_1
    11     12   {
    12     13    int wait_count = 0;
           14  + int choke_count = 0;
    13     15   
    14     16    Game g;
    15         - this(const(Game) g)
           17  + this(in Game g)
    16     18    {
    17     19     this.g = g.clone();
    18         -  forbidden_cell = new bool[][](g.map.H+2, g.map.W+2);
           20  +  forbidden_cell = new bool[][](g.H+2, g.W+2);
    19     21    }
    20     22   
    21     23    char single_step()
    22     24    {
    23     25     Tuple!(string,int) de = death_move(g);
    24     26     char c = act(g, de[0], de[1]);
    25         -  g.command(c);
           27  +  force(c);
    26     28     return c;
    27     29    }
           30  +
           31  + void force(char c)
           32  + {
           33  +  if(c != 'A')
           34  +   g.command(c);
           35  + }
    28     36   
    29     37    Tuple!(string,int) death_move(const(Game) g)
    30     38    {
    31     39     string death;
    32     40     int choice = 0;
    33     41     foreach(char c; "UDLRW") {
    34     42      Game gg = g.clone();
    35     43      gg.command(c);
    36     44      if( !gg.cleared && gg.dead )
    37     45       death ~= c;
    38         -   else if( gg.map.robot != g.map.robot )
           46  +   else if( gg.robot != g.robot )
    39     47       choice++;
           48  +   else if( c != 'W' ) // meaningless move
           49  +    death ~= c;
    40     50     }
    41     51     return tuple(death, choice);
    42     52    }
    43     53   
    44     54    Tuple!(Pos, int)[] log;
    45     55    bool[][] forbidden_cell;
    46     56   
    47     57    char act(const(Game) g, string death, int breath)
    48     58    {
    49         -  const Pos   ro = g.map.robot;
    50         -  const Pos[] la = g.map.lambdas();
    51         -  const Pos   li = g.map.lift;
           59  +  const Pos    ro = g.robot;
           60  +  const Pos    li = g.lift;
           61  +  Pos[] la = g.lambdas();
           62  +  sort!((Pos a,Pos b){
           63  +   int ad=abs(a.y-li.y)+abs(a.x-li.x);
           64  +   int bd=abs(b.y-li.y)+abs(b.x-li.x);
           65  +   return ad>bd;;
           66  +  })(la);
           67  +  Pos[] ra = g.razors();
           68  +  const(Pos)[] hi = g.higes();
    52     69   
    53     70     Tuple!(char,int)[] cand;
    54     71     char c = 'W';
    55     72     if( la.empty ) {
    56     73      cand = search(g, ro, [li], death);
    57     74     } else {
    58         -   cand ~= search(g, ro, la, death);
           75  +   cand ~= search(g, ro, la~ra, death);
           76  +  }
           77  +
           78  +  // 'higesori' mode
           79  +  if( !hi.empty && g.num_razor>0 ) {
           80  +   int his = 0;
           81  +   for(int dy=-1; dy<=+1; ++dy)
           82  +   for(int dx=-1; dx<=+1; ++dx)
           83  +    if(g[ro.y+dy,ro.x+dx] == 'W')
           84  +     his++;
           85  +
           86  +   if(his>=2 || his==hi.length)
           87  +    cand = [tuple('S',int.max)];
           88  +   if(cand.empty) {
           89  +    const(Pos)[] tgt;
           90  +    for(int y=1; y<=g.H; ++y)
           91  +    for(int x=1; x<=g.W; ++x)
           92  +     if(g[y,x]=='.'||g[y,x]==' ') {
           93  +      his = 0;
           94  +      for(int dy=-1; dy<=+1; ++dy)
           95  +      for(int dx=-1; dx<=+1; ++dx)
           96  +       if(g[y+dy,x+dx] == 'W')
           97  +        his++;
           98  +      if(his>=2)
           99  +       tgt ~= new Pos(y,x);
          100  +     }
          101  +    cand ~= search(g, ro, tgt, death, true);
          102  +   }
    59    103     }
          104  +
          105  +  // 'dig' mode
    60    106     if(cand.empty) {
    61    107      const(Pos)[] tgt;
    62         -   for(int y=1; y<=g.map.H; ++y)
    63         -   for(int x=1; x<=g.map.W; ++x)
    64         -    if(g.map[y,x]=='.')
    65         -     if(g.map[y+1,x]=='*'||g.map[y+1,x-1]=='*'||g.map[y+1,x+1]=='*'
    66         -      ||g.map[y,x+1]=='*'||g.map[y,x-1]=='*')
          108  +   for(int y=1; y<=g.H; ++y)
          109  +   for(int x=1; x<=g.W; ++x)
          110  +    if(g[y,x]=='.')
          111  +     if(g[y+1,x]=='*'||g[y+1,x-1]=='*'||g[y+1,x+1]=='*'
          112  +      ||g[y,x+1]=='*'||g[y,x-1]=='*')
    67    113         tgt ~= new Pos(y,x);
    68    114      cand ~= search(g, ro, tgt, death, true);
    69    115     }
    70    116   
    71         -  if(cand.empty)
          117  +  if(cand.empty) {
          118  +   choke_count++;
    72    119      cand ~= tuple('W',int.max);
          120  +  }
    73    121     sort!((Tuple!(char,int) c1, Tuple!(char,int) c2){
    74    122      if(c1[1] != c2[1])
    75    123       return c1[1] < c2[1];
    76    124      return c1[0] < c2[0];
    77    125     })(cand);
    78    126     c = cand[0][0];
    79    127   
    80         -  if(death.count(c)) {
    81         -   foreach(char live; "UDLRWA")
          128  +  if(death.count(c) || wait_count>=2) {
          129  +   foreach(char live; "UDLRW")
    82    130       if(death.count(live)==0) {
    83    131        c=live;
    84    132        break;
    85    133       }
    86    134     }
    87    135   
    88         -  if(c=='W') {
          136  +  if(c == 'W')
    89    137      wait_count++;
    90         -   if(wait_count > g.map.H)
    91         -    c = 'A';
    92         -  }
    93    138     else
    94    139      wait_count = 0;
          140  +  if(choke_count >= g.H)
          141  +   c = 'A';
    95    142   
    96    143     bool[char] choice;
    97    144     foreach(t; cand)
    98    145      choice[t[0]] = true;
    99    146     log ~= tuple(ro.clone(), cast(int)choice.length);
   100    147     if(log.length > 5)
   101    148      log = log[$-5..$];
................................................................................

   110    157     return c;
   111    158    }
   112    159   
   113    160    Tuple!(char,int)[] search(in Game g, in Pos s, in Pos[] gs, string death, bool danger_ok=false)
   114    161    {
   115    162     bool danger(int y, int x)
   116    163     {
   117         -   if(g.map[y,x] == ' ' || g.map[y,x] == 'R')
          164  +   if(g[y,x] == ' ' || g[y,x] == 'R')
   118    165       return false;
   119         -   if(g.map[y+1,x] == '*')
          166  +   if(g[y+1,x] == '*')
          167  +    return true;
          168  +   if(g[y+1,x-1]=='*' && (g[y,x-1]=='\\'||g[y,x-1]=='*') && (g[y+1,x]==' '||g[y+1,x]=='R'))
   120    169       return true;
   121         -   if(g.map[y+1,x-1]=='*' && (g.map[y,x-1]=='\\'||g.map[y,x-1]=='*') && (g.map[y+1,x]==' '||g.map[y+1,x]=='R'))
          170  +   if(g[y+1,x+1]=='*' && (g[y,x+1]=='*') && (g[y+1,x]==' '||g[y+1,x]=='R'))
   122    171       return true;
   123         -   if(g.map[y+1,x+1]=='*' && (g.map[y,x+1]=='*') && (g.map[y+1,x]==' '||g.map[y+1,x]=='R'))
          172  +   if(g[y,x-1]=='*' && (g[y-1,x-1]=='\\'||g[y-1,x-1]=='*') && (g[y-1,x]==' '||g[y-1,x]=='R'))
   124    173       return true;
   125         -   if(g.map[y,x-1]=='*' && (g.map[y-1,x-1]=='\\'||g.map[y-1,x-1]=='*') && (g.map[y-1,x]==' '||g.map[y-1,x]=='R'))
   126         -    return true;
   127         -   if(g.map[y,x+1]=='*' && (g.map[y-1,x+1]=='*') && (g.map[y-1,x]==' '||g.map[y-1,x]=='R'))
          174  +   if(g[y,x+1]=='*' && (g[y-1,x+1]=='*') && (g[y-1,x]==' '||g[y-1,x]=='R'))
   128    175       return true;
   129    176      return false;
   130    177     }
   131    178   
   132    179     // avoid directly below '*'
   133    180     Tuple!(char,int)[] tryA() {
   134    181      const(Pos)[] q;
   135    182      foreach(p; gs)
   136    183       if(!danger(p.y,p.x))
   137    184        q ~= p;
   138         -   bool[][] v = new bool[][](g.map.H+2, g.map.W+2);
          185  +   bool[][] v = new bool[][](g.H+2, g.W+2);
   139    186      foreach(p; q) v[p.y][p.x]=true;
   140    187      for(int step=1; q.length; ++step) {
   141    188       Pos[] q2;
   142    189       foreach(p; q) {
   143    190        int[] yyy=[p.y-1,p.y+1,p.y,p.y];
   144    191        int[] xxx=[p.x,p.x,p.x-1,p.x+1];
   145    192        for(int i=0; i<yyy.length; ++i) {
   146    193         int y = yyy[i];
   147    194         int x = xxx[i];
   148         -      if('1'<=g.map[y,x]&&g.map[y,x]<='9') {
   149         -       foreach(ppp; g.map.tr_source[g.map[y,x]]) {
          195  +      if('1'<=g[y,x]&&g[y,x]<='9') {
          196  +       foreach(ppp; g.trampoline_rev(g[y,x])) {
   150    197           yyy ~= ppp.y;
   151    198           xxx ~= ppp.x;
   152    199          }
   153    200          continue;
   154    201         }
   155    202         if(v[y][x]) continue;
   156    203         if(y==s.y && x==s.x && i<4) {
   157    204          char c = "UDRL"[i];
   158    205          if( death.count(c) == 0 )
   159    206           return [tuple(c,step)];
   160    207         } else if(forbidden_cell[y][x]){
   161         -      } else if(g.map[y,x]==' '||g.map[y,x]=='\\'||g.map[y,x]=='.'||i>=4) {
          208  +      } else if(g[y,x]==' '||g[y,x]=='\\'||g[y,x]=='.'||g[y,x]=='!'||i>=4) {
   162    209          if(danger(y,x))
   163    210           continue;
   164    211          q2 ~= new Pos(y,x);
   165    212          v[y][x]=true;
   166    213         }
   167    214        }
   168    215       }
................................................................................

   171    218      return [];
   172    219     }
   173    220   
   174    221     // any empty space is my ground
   175    222     Tuple!(char,int)[] tryB() {
   176    223      const(Pos)[] q;
   177    224      foreach(p; gs) q ~= p;
   178         -   bool[][] v = new bool[][](g.map.H+2, g.map.W+2);
          225  +   bool[][] v = new bool[][](g.H+2, g.W+2);
   179    226      foreach(p; q) v[p.y][p.x]=true;
   180    227      for(int step=10; q.length; ++step) {
   181    228       Pos[] q2;
   182    229       foreach(p; q) {
   183    230        int[] yyy=[p.y-1,p.y+1,p.y,p.y];
   184    231        int[] xxx=[p.x,p.x,p.x-1,p.x+1];
   185    232        for(int i=0; i<yyy.length; ++i) {
   186    233         int y = yyy[i];
   187    234         int x = xxx[i];
   188         -      if('1'<=g.map[y,x]&&g.map[y,x]<='9') {
   189         -       foreach(ppp; g.map.tr_source[g.map[y,x]]) {
          235  +      if('1'<=g[y,x]&&g[y,x]<='9') {
          236  +       foreach(ppp; g.trampoline_rev(g[y,x])) {
   190    237           yyy ~= ppp.y;
   191    238           xxx ~= ppp.x;
   192    239          }
   193    240          continue;
   194    241         }
   195    242         if(v[y][x]) continue;
   196    243         if(y==s.y && x==s.x && i<4) {
   197    244          char c = "UDRL"[i];
   198    245          if( death.count(c) == 0 )
   199    246           return [tuple(c,step)];
   200    247         } else if(forbidden_cell[y][x]){
   201         -      } else if(g.map[y,x]==' '||g.map[y,x]=='\\'||g.map[y,x]=='.'||i>=4) {
          248  +      } else if(g[y,x]==' '||g[y,x]=='\\'||g[y,x]=='.'||g[y,x]=='!'||i>=4) {
   202    249          q2 ~= new Pos(y,x);
   203    250          v[y][x]=true;
   204    251         }
   205    252        }
   206    253       }
   207    254       q = q2;
   208    255      }
................................................................................

   209    256      return [];
   210    257     }
   211    258   
   212    259     // push rocks!
   213    260     Tuple!(char,int)[] tryC() {
   214    261      const(Pos)[] q;
   215    262      foreach(p; gs) q ~= p;
   216         -   bool[][] v = new bool[][](g.map.H+2, g.map.W+2);
          263  +   bool[][] v = new bool[][](g.H+2, g.W+2);
   217    264      foreach(p; q) v[p.y][p.x]=true;
   218    265      for(int step=20; q.length; ++step) {
   219    266       Pos[] q2;
   220    267       foreach(p; q) {
   221    268        int[] yyy=[p.y-1,p.y+1,p.y,p.y];
   222    269        int[] xxx=[p.x,p.x,p.x-1,p.x+1];
   223    270        for(int i=0; i<yyy.length; ++i) {
   224    271         int y = yyy[i];
   225    272         int x = xxx[i];
   226         -      if('1'<=g.map[y,x]&&g.map[y,x]<='9') {
   227         -       foreach(ppp; g.map.tr_source[g.map[y,x]]) {
          273  +      if(g[p] == '*') {
          274  +       if(i>=4)continue;
          275  +       if(y!=p.y)continue;
          276  +       if(g[y,p.x+(p.x-x)]!=' '&&g[y,p.x+(p.x-x)]!='R')continue;
          277  +      }
          278  +      if('1'<=g[y,x]&&g[y,x]<='9') {
          279  +       foreach(ppp; g.trampoline_rev(g[y,x])) {
   228    280           yyy ~= ppp.y;
   229    281           xxx ~= ppp.x;
   230    282          }
   231    283          continue;
   232    284         }
   233    285         if(v[y][x]) continue;
   234    286         if(y==s.y && x==s.x && i<4) {
   235    287          char c = "UDRL"[i];
   236    288          if( death.count(c) == 0 )
   237    289           return [tuple(c,step)];
   238    290         } else if(forbidden_cell[y][x]){
   239         -      } else if(g.map[y,x]==' '||g.map[y,x]=='\\'||g.map[y,x]=='.'||i>=4) {
   240         -       q2 ~= new Pos(y,x);
   241         -       v[y][x]=true;
   242         -      } else if(i<4 && (y-p.y)==0 && g.map[p]==' ' && g.map[y,x]=='*' && (g.map[y+(y-p.y),x+(x-p.x)]==' '||g.map[y+(y-p.y),x+(x-p.x)]=='R')) {
          291  +      } else if(g[y,x]==' '||g[y,x]=='\\'||g[y,x]=='.'||g[y,x]=='*'||g[y,x]=='!'||i>=4) {
   243    292          q2 ~= new Pos(y,x);
   244    293          v[y][x]=true;
   245    294         }
   246    295        }
   247    296       }
   248    297       q = q2;
   249    298      }
   250    299      return [];
   251    300     }
   252    301     return (danger_ok ? [] : tryA()) ~ tryB() ~ tryC();
   253    302    }
   254    303   }
   255    304   
   256         -alias Solver_1 MainSolver;
          305  +class Solver_2(Solver)
          306  +{
          307  + string plan;
          308  + bool plan_broken = true;
          309  +
          310  + Game g;
          311  + this(in Game g)
          312  + {
          313  +  this.g = g.clone();
          314  +  make_plan(g);
          315  + }
          316  +
          317  + Tuple!(Solver,string) run_sub_solver(in Game g)
          318  + {
          319  +  string log;
          320  +  auto s = new Solver(g);
          321  +  while(!g.cleared && !g.dead && plan.length<=g.H*g.W) {
          322  +   char c = s.single_step();
          323  +   if( c == 'A' )
          324  +    break;
          325  +   log ~= c;
          326  +  }
          327  +  while(log.length>0 && log[$-1]=='W')
          328  +   log.length--;
          329  +  return tuple(s, log);
          330  + }
          331  +
          332  + void make_plan(in Game g) {
          333  +  plan_broken = false;
          334  +  Tuple!(Solver,string) x = run_sub_solver(g);
          335  +  plan = x[1];
          336  +  if(x[0].g.cleared)
          337  +   return;
          338  +  modify_plan(g, x[0].g.score);
          339  + }
          340  +
          341  + void modify_plan(in Game ini, long unmod)
          342  + {
          343  +  int bp = max(0, (cast(int)plan.length)-10);
          344  +  Game g = ini.clone();
          345  +  for(int i=0; i<bp; ++i) g.command(plan[i]);
          346  +
          347  +  Tuple!(string,long) cand = tuple(plan, unmod);
          348  +  for(int i=bp; i<plan.length; ++i) {
          349  +   foreach(string c; ["U","D","L","R","UD","DU","LR","RL"])
          350  +    if(c[0] != plan[i]) {
          351  +     Tuple!(string,long) zz = try_plan(c, g);
          352  +     if(cand[1]<zz[1])
          353  +      cand = tuple(plan[0..i]~c~zz[0], zz[1]);
          354  +    }
          355  +   g.command(plan[i]);
          356  +  }
          357  +  plan = cand[0];
          358  + }
          359  +
          360  + Tuple!(string,long) try_plan(string c, in Game g)
          361  + {
          362  +  Game gg = g.clone();
          363  +  foreach(cc;c)gg.command(cc);
          364  +  Tuple!(Solver, string) x = run_sub_solver(gg);
          365  +  return tuple(x[1], x[0].g.score);
          366  + }
          367  +
          368  + char single_step() {
          369  +  if(plan_broken)
          370  +   make_plan(g);
          371  +  if(plan.empty)
          372  +   return 'A';
          373  +  char c = plan[0];
          374  +  plan = plan[1..$];
          375  +  g.command(c);
          376  +  return c;
          377  + }
          378  +
          379  + void force(char c) {
          380  +  g.command(c);
          381  +  if(plan.length==0 || plan[0]!=c) {
          382  +   plan = "";
          383  +   plan_broken = true;
          384  +  }
          385  +  else
          386  +   plan = plan[1..$];
          387  + }
          388  +}
          389  +
          390  +alias Solver_2!(Solver_1) MainSolver;
          391  +//alias Solver_1 MainSolver;

Modified src/util.d from [783554bf667412ed] to [b76be1f6ad977d56].


     1      1   public import std.algorithm;
     2      2   public import std.array;
     3      3   public import std.conv;
     4      4   public import std.range;
     5      5   public import std.stdio;
     6      6   public import std.string;
     7      7   public import std.typecons;
            8  +public import std.math;
     8      9   import std.c.stdlib;
           10  +
           11  +T[] erase(T,V)(T[] xs, V y)
           12  +{
           13  + foreach(i,x; xs)
           14  +  if(x == y)
           15  +   return xs[0..i]~xs[i+1..$];
           16  + return xs;
           17  +}
           18  +
           19  +// To avoide the following ICE:
           20  +//   src\phobos\std\algorithm.d(4552):
           21  +//     Error: function std.algorithm.count!("a == b",string,char).count
           22  +//     compiler error, parameter 'value', bugzilla 2962?
           23  +//     Assertion failure: '0' on line 717 in file 'glue.c'
           24  +int count(T,V)(T[] a, V v)
           25  +{
           26  + int cnt = 0;
           27  + foreach(e; a)
           28  +  if(e == v)
           29  +   ++cnt;
           30  + return cnt;
           31  +}
     9     32   
    10     33   void application_exit()
    11     34   {
    12     35    std.c.stdlib.exit(0);
    13     36   }
    14     37   
    15     38   template DeriveCreate()
................................................................................

    19     42     this.tupleof = params;
    20     43    }
    21     44   }
    22     45   
    23     46   template DeriveCompare()
    24     47   {
    25     48   override:
    26         - bool opEquals(Object rhs)
           49  + bool opEquals(Object rhs) const
    27     50    {
    28     51     return tuple(this.tupleof) == tuple((cast(typeof(this))rhs).tupleof);
    29     52    }
    30     53   
    31         - int opCmp(Object rhs)
           54  + int opCmp(Object rhs) const
    32     55    {
    33     56     return tuple(this.tupleof).opCmp(tuple((cast(typeof(this))rhs).tupleof));
    34     57    }
    35     58   
    36         - hash_t toHash()
           59  + hash_t toHash() const
    37     60    {
    38     61     hash_t v = 0;
    39     62     foreach(mem; this.tupleof) {
    40     63      v *= 11;
    41     64      static if(__traits(compiles, v^=mem))
    42     65       v ^= mem;
    43     66      else
................................................................................

    46     69     return v;
    47     70    }
    48     71   }
    49     72   
    50     73   template DeriveShow()
    51     74   {
    52     75   override:
    53         - string toString()
           76  + string toString() const
    54     77    {
    55     78     string str = text(typeof(this).stringof, "(");
    56     79     foreach(i,mem; this.tupleof) {
    57     80      if(i) str ~= ", ";
    58     81      str = text(str, this.tupleof[i].stringof[5..$], ":",  mem);
    59     82     }
    60     83     return str ~ ")";
    61     84    }
    62     85   }