Difference From:
[fc9286dad1] uum (user: kinaba, tags: redesign, date: 2012-07-15 12:11:33)
To:
[7e9400ba3d] Scores. (user: kinaba, tags: trunk, date: 2012-07-15 02:26:34)
Deleted maps/40x40.map version [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 <
Modified score_memo.txt from [95f0626c958d6d31] to [486054e680f2488a].
1 contest1 212! | 1 contest1 212! DLRDDUULLLDDL 2 contest2 280? | 2 contest2 45 RRRRUA 3 contest3 275! | 3 contest3 275! LDDDRRRRDDLLLLLDRRURURRUR 4 contest4 561? | 4 contest4 561? DRDRDRDRRLUURUUULURDDDLLLLLUURRDDRRRUUR 5 contest5 1281? | 5 contest5 1281? LLUURUUURRRRRRLUULDLLULLRRDRDDDDDDUURRURRDDDLLRRUUULLLLUUUULDD 6 contest6 737 // deadend trap | 6 contest6 737 RUULRRRRRRRRRRUUURUURUUULULLULLLLLLLLDDLDDDDDDUUUUUUUURRRDDRRR 7 contest7 867? | 7 contest7 867? RDRRRDDLLLDDLLRRURURRRDDRRRLLLULL 8 contest8 1245 // tricky | 8 contest8 1245 RRRRRLLLLLUULLLDLLLLRRRRRURUUUUUUUUUULLLLUUULLLLRRDDDDDDLRDDDD 9 contest9 3042? | 9 contest9 1990 LRUURRRDUDUDULLLDDRRRRRRRRRUUURRRLDDRLDRRRRRRRRRRRUULLLDLULLRD 10 contest10 2076 // * on lambda, must move * first | 10 contest10 2976 UUUUULLLLLLUUUUULLUULLLRDDUUUUUUURRRUDLLUUURRRDRRRRLLUURRRRLLL 11 flood1 569 // too slow, because of 1-left danger lambda | 11 flood1 569 LLLLDDDRRRDRDRUUULLLLLURRRRRDRRA 12 flood2 280? | 12 flood2 45 RRRRUA 13 flood3 802 // too slow, drown | 13 flood3 716 LLUURUUURRRRRRLUULDLLULLRRDRDDDDDDA 14 flood4 970 // incorrect order of digging | 14 flood4 970 DDDDLRRRRDDUUUUUUUULLLLLULLLLLLLLUUDRRURUULDRDLLLLLLDDDDLLRRRR 15 flood5 561? | 15 flood5 561? DRDRDRDRRLUURUUULURDDDLLLLLUURRDDRRRUUR 16 trampoline1 291 // * on trampoline. must move * first | 16 trampoline1 291 LDLLLLURRA 17 trampoline2 1728? | 17 trampoline2 1728? ULLLLLRRRRDRRULULRRLLLLLLLDLWWRULLLDDLLLURRLLUULURURRLLUULLDLL 18 trampoline3 698 // * on trampoline target. must move * first. | 18 trampoline3 698 RRRRDDLDDDDDDRDRRRRRRRUUUURRUDRRRRUUURRRDDRRRRRRRRRRA 19 beard1 856? | 19 beard1 856? RRRURRRDDULLLLLLDLDRURRDDDLLDDLUURDRSRRRRRUR 20 beard2 2792 // hutsu-ni muzui | 20 beard2 2716 RRDDRRRRRRRRRRRRRRRRRRRRRRRRDDRDDLLDDDDLLLLLLLLLLLLLLLLLLLLLLL 21 beard3 811 // tricky. must hurry to cut hige. | 21 beard3 811 RRRRULULRRURRURRRLDDSLDDLDLDDLLLUULDDDDA 22 beard4 677 // deadend trap | 22 beard4 677 LLRDDDDDDRRLLDDLLLLLLLLA > 23 > 24
Deleted src/Makefile version [01a4f7a0531dae71]
Deleted 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(f < 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 [fc05481901940844] to [5d6b45c159e125db].
45 mixin DeriveCreate; 45 mixin DeriveCreate; 46 mixin DeriveCompare; 46 mixin DeriveCompare; 47 mixin DeriveShow; 47 mixin DeriveShow; 48 Water clone() const { return cast(Water)this; } 48 Water clone() const { return cast(Water)this; } 49 49 50 static load(string[string] params) 50 static load(string[string] params) 51 { 51 { > 52 return new Water( 52 return new Water(params.get("Water", "0").to!int(), | 53 params.get("Water", "0").to!int(), 53 params.get("Flooding", "0").to!int()); | 54 params.get("Flooding", "0").to!int() > 55 ); 54 } 56 } 55 57 56 int level(int number_of_update) const 58 int level(int number_of_update) const 57 { 59 { 58 return pace ? base+(number_of_update/pace) : base; 60 return pace ? base+(number_of_update/pace) : base; 59 } 61 } 60 62 ................................................................................................................................................................................ 122 return new Map(raw_data, params, trampo); 124 return new Map(raw_data, params, trampo); 123 } 125 } 124 126 125 char[][] data; 127 char[][] data; 126 Pos robot; 128 Pos robot; 127 Pos lift; 129 Pos lift; 128 int waterproof; 130 int waterproof; > 131 // TODO: immutable 129 Pos[char] tr_target; 132 Pos[char] tr_target; 130 Pos[][char] tr_source; 133 Pos[][char] tr_source; 131 const(Hige) hige; 134 const(Hige) hige; 132 int razor; 135 int razor; 133 136 134 Map clone() const { return new Map(this); } 137 Map clone() const { return new Map(this); } 135 this(in Map m) { 138 this(in Map m) { ................................................................................................................................................................................ 349 } 352 } 350 } 353 } 351 354 352 //////////////////////////////////////////////////////////////////////////////// 355 //////////////////////////////////////////////////////////////////////////////// 353 356 354 class Game 357 class Game 355 { 358 { 356 public: | 359 mixin DeriveShow; > 360 357 this(File input) | 361 static Game load(File input) 358 { 362 { 359 // Read map data | 363 string[] raw_data; 360 string[] map_data_lines; | 364 string[string] params; 361 for(string line; !(line=input.readln().chomp()).empty; ) < 362 map_data_lines ~= line; < 363 365 364 // H*W | 366 // Raw map data; read until empty line. 365 H_ = map_data_lines.length; | 367 for(string line; !(line=input.readln().chomp()).empty; ) 366 W_ = 0; | 368 raw_data ~= line; 367 foreach(mdl; map_data_lines) < 368 W_ = max(W_, mdl.length); < 369 369 370 // Copy to modifiable buffer and adjust coordinates. | 370 // Additional commands; read until EOF. 371 raw_data_ = new char[][H_+1]; | 371 char[char] trampo; 372 foreach(i,mdl; map_data_lines) { | 372 for(string line; !(line=input.readln()).empty; ) { 373 char[] buf = new char[mdl.length+1]; | 373 string[] ss = line.split(); 374 buf[0] = '#'; | 374 if( ss.length == 2 ) 375 buf[1..$] = mdl[]; | 375 params[ss[0]] = ss[1]; 376 raw_data_[H_-i] = buf; | 376 if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="tar 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 } < > 377 trampo[ss[1][0]] = ss[3][0]; 420 } 378 } 421 379 422 // Read other parameters | 380 return load(raw_data, params, trampo); 423 for(string line; !(line=input.readln()).empty; ) < > 381 } 424 { | 382 425 string[] ss = line.split(); | 383 static Game load(string[] raw_data, string[string] params, char[char] tr 426 if( ss.length == 2 ) < 427 switch(ss[0]) < 428 { | 384 { 429 case "Water": water_base_ = ss[1].to!int(); < 430 case "Flooding": water_pace_ = ss[1].to!int(); < 431 case "Waterproof": max_air_ = ss[1].to!int(); < 432 case "Growth": hige_pace_ = ss[1].to!int(); < 433 case "Razors": num_razor_ = ss[1].to!int(); < 434 default: assert(false); < > 385 return new Game(raw_data, params, trampo); 435 } | 386 } 436 if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="tar < 437 { | 387 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; < > 388 this(string[] raw_data, string[string] params, char[char] trampo) > 389 { > 390 this.map = Map.load(raw_data, params, trampo); > 391 this.water = Water.load(params); 442 } | 392 } 443 } < 444 393 445 air_left_ = max_air_; | 394 Game clone() const { return new Game(this); } > 395 this(in Game g) { > 396 map = g.map.clone(); > 397 water = g.water.clone(); > 398 turn = g.turn; > 399 dead = g.dead; > 400 lambda = g.lambda; > 401 exit_bonus = g.exit_bonus; > 402 under_water = g.under_water; 446 } 403 } 447 404 448 @property const { < 449 int H() { return H_; } < 450 int W() { return W_; } < 451 char trampoline(char c) { return (c in trampoline_ ? trampoline_ < 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_ : w < 462 } < 463 int water_until_rise() { < 464 return water_pace_ ? water_pace_ - turn_%water_pace_ : i < 465 } < 466 int hige_until_rise() { < 467 return hige_pace_ ? hige_pace_ - turn_%hige_pace_ : int. < 468 } < 469 bool is_hige_turn() { < 470 return hige_pace_ ? turn_%hige_pace_ == hige_pace_-1 : f < 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 < 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) 405 void command(char c) 506 { 406 { 507 if(dead || cleared) 407 if(dead || cleared) 508 return; 408 return; 509 409 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') {} | 410 if(c == 'A') > 411 { > 412 exit_bonus = 1; > 413 return; > 414 } 516 415 > 416 // TODO: clarify the event order > 417 Tuple!(int,bool) ld = map.command(c, turn); 517 if(!cleared) | 418 if( map.cleared() ) { 518 { < 519 map_update(); < 520 water_update(); | 419 exit_bonus = 2; > 420 } > 421 else { > 422 lambda += ld[0]; > 423 if( ld[1] ) { > 424 dead = true; > 425 } 521 } 426 } 522 turn_ ++; | 427 if( map.robot.y <= water_level ) 523 } < 524 < > 428 ++under_water; > 429 else 525 void command_move(int dy, int dx) | 430 under_water = 0; 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': < > 431 if( under_water > map.waterproof ) 533 cleared_ = true; | 432 dead = 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 } < > 433 turn += 1; 560 } 434 } 561 435 562 void use_razor() | 436 Map map; 563 { < 564 if(num_razor_ == 0) < > 437 Water water; 565 return; | 438 int turn = 0; 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); < > 439 bool dead = false; 583 num_lambda_ ++; | 440 int lambda = 0; 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 } < > 441 int exit_bonus = 0; > 442 int under_water = 0; > 443 // TODO: when adding members, take care of clone(). > 444 // TODO: fix this poor design. 593 445 594 void enter_trampoline_at(Pos p, char c) | 446 @property const { 595 { | 447 long score() { return lambda*25L*(1+exit_bonus) - turn; } 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] < 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 < 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() ) | 448 int water_level() { return water.level(turn); } 695 air_left_ --; < 696 else < 697 air_left_ = max_air_; < 698 if( air_left_ < 0 ) < 699 dead_ = true; < > 449 int water_until_rise() { return water.until_rise(turn); } > 450 int hige_until_rise() { return map.hige.until_rise(turn); } > 451 bool cleared() { return exit_bonus>0; } > 452 int hp() { return map.waterproof - under_water; } > 453 long score_if_abort_now() { return lambda*25*(1+max(1,exit_bonus 700 } | 454 } 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; < 759 } < 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; < 779 < 780 int turn_ = 0; < 781 int air_left_ = 0; < 782 bool cleared_ = false; < 783 bool dead_ = false; < 784 bool[Pos] may_update_; < 785 } 455 }
Modified src/gui.d from [e84cacd6262f93a7] to [b071b446f6e834b9].
4 import driver; 4 import driver; 5 5 6 class GUI(Solver) : Form, GameObserver 6 class GUI(Solver) : Form, GameObserver 7 { 7 { 8 this(in Game g) 8 this(in Game g) 9 { 9 { 10 this.solver = new Solver(g); 10 this.solver = new Solver(g); 11 setup_size(g.W, g.H); | 11 setup_size(g.map.W, g.map.H); 12 setup_resources(g); 12 setup_resources(g); 13 draw(g); 13 draw(g); 14 } 14 } 15 15 16 private void delegate(char c) fn; 16 private void delegate(char c) fn; 17 void set_fn(F)(F f) { this.fn = f; } 17 void set_fn(F)(F f) { this.fn = f; } 18 18 ................................................................................................................................................................................ 79 this.render['\\'] = "λ"; 79 this.render['\\'] = "λ"; 80 this.render['R'] = "☃"; 80 this.render['R'] = "☃"; 81 this.render['d'] = "☠"; 81 this.render['d'] = "☠"; 82 this.render['L'] = "☒"; 82 this.render['L'] = "☒"; 83 this.render['O'] = "☐"; 83 this.render['O'] = "☐"; 84 this.render['W'] = "ꔣ"; 84 this.render['W'] = "ꔣ"; 85 this.render['!'] = "✄"; 85 this.render['!'] = "✄"; > 86 foreach(c,tp; g.map.tr_target) { > 87 char d = g.map[tp]; 86 foreach(char c; 'A'..'J') this.render[c] = [cast(dchar)('☢'+g.tr | 88 this.render[c] = [cast(dchar)('☢'+d-'1')].to!string(); > 89 } 87 foreach(char c; '1'..':') this.render[c] = [cast(dchar)('☢'+c-'1 90 foreach(char c; '1'..':') this.render[c] = [cast(dchar)('☢'+c-'1 88 this.paint ~= (Control c, PaintEventArgs ev) { 91 this.paint ~= (Control c, PaintEventArgs ev) { 89 graphicContext.copyTo(ev.graphics, Rect(0,0,this.clientS 92 graphicContext.copyTo(ev.graphics, Rect(0,0,this.clientS 90 }; 93 }; 91 } 94 } 92 95 93 void draw(in Game g) 96 void draw(in Game g) ................................................................................................................................................................................ 99 graphicContext.fillRectangle(this.backColor, Rect(0,0,scrW,scrH) 102 graphicContext.fillRectangle(this.backColor, Rect(0,0,scrW,scrH) 100 103 101 // Fill water. 104 // Fill water. 102 int w = g.water_level(); 105 int w = g.water_level(); 103 graphicContext.fillRectangle(this.colors['w'], Rect(0, scrH-cell 106 graphicContext.fillRectangle(this.colors['w'], Rect(0, scrH-cell 104 107 105 // Paint map. 108 // Paint map. 106 for(int y=1; y<=g.H; ++y) | 109 for(int y=1; y<=g.map.H; ++y) 107 for(int x=1; x<=g.W; ++x) { | 110 for(int x=1; x<=g.map.W; ++x) { 108 Rect r = Rect(cell*(x-1), scrH-cell*y, cell, cell); 111 Rect r = Rect(cell*(x-1), scrH-cell*y, cell, cell); 109 char c = g[y,x]; | 112 char c = g.map[y,x]; 110 if( c != ' ' ) { 113 if( c != ' ' ) { 111 if( c == 'R' && g.dead ) 114 if( c == 'R' && g.dead ) 112 c = 'd'; 115 c = 'd'; 113 graphicContext.drawText(this.render[c], font, th 116 graphicContext.drawText(this.render[c], font, th 114 } 117 } 115 } 118 } 116 119 117 // Update textual info. 120 // Update textual info. 118 this.text = .text( 121 this.text = .text( 119 "Score: ", g.score, 122 "Score: ", g.score, 120 " Air: ", g.hp, 123 " Air: ", g.hp, 121 " Tide: ", g.water_until_rise, 124 " Tide: ", g.water_until_rise, 122 " Wadler: ", g.hige_until_rise, 125 " Wadler: ", g.hige_until_rise, 123 " Razor: ", g.num_razor); | 126 " Razor: ", g.map.razor); 124 invalidate(); 127 invalidate(); 125 } 128 } 126 129 127 private: 130 private: 128 void setup_keyhandling() 131 void setup_keyhandling() 129 { 132 { 130 noMessageFilter(); 133 noMessageFilter(); 131 this.keyDown ~= &my_keydown; 134 this.keyDown ~= &my_keydown; 132 } 135 } 133 136 134 void do_manual_command(char c) < 135 { < 136 solver.force(c); < 137 fn(c); < 138 } < 139 < 140 void my_keydown(Control c, KeyEventArgs ev) 137 void my_keydown(Control c, KeyEventArgs ev) 141 { 138 { 142 switch(ev.keyCode) 139 switch(ev.keyCode) 143 { 140 { 144 case Keys.DOWN: do_manual_command('D'); break; | 141 case Keys.DOWN: fn('D'); break; 145 case Keys.UP: do_manual_command('U'); break; | 142 case Keys.UP: fn('U'); break; 146 case Keys.LEFT: do_manual_command('L'); break; | 143 case Keys.LEFT: fn('L'); break; 147 case Keys.RIGHT: do_manual_command('R'); break; | 144 case Keys.RIGHT: fn('R'); break; 148 case Keys.W: do_manual_command('W'); break; | 145 case Keys.W: fn('W'); break; 149 case Keys.S: do_manual_command('S'); break; | 146 case Keys.S: fn('S'); break; 150 case Keys.A: do_manual_command('A'); break; | 147 case Keys.A: fn('A'); break; 151 case Keys.G: fn(solver.single_step()); break; 148 case Keys.G: fn(solver.single_step()); break; 152 default: break; 149 default: break; 153 } 150 } 154 } 151 } 155 152 156 Solver solver; 153 Solver solver; 157 } 154 }
Modified src/output.d from [e2d0d7db868c3a44] to [62e6040714438eff].
20 } 20 } 21 21 22 class GuardedOutput : GameObserver 22 class GuardedOutput : GameObserver 23 { 23 { 24 this(in Game g) 24 this(in Game g) 25 { 25 { 26 setup_sigint_handling(); 26 setup_sigint_handling(); 27 score_log ~= g.score; | 27 ideal_log ~= g.score_if_abort_now; 28 flushed = false; 28 flushed = false; 29 } 29 } 30 30 31 override void on_game_changed(char c, in Game g, bool finished) 31 override void on_game_changed(char c, in Game g, bool finished) 32 { 32 { 33 if(flushed) 33 if(flushed) 34 return; 34 return; 35 35 36 log ~= c; 36 log ~= c; 37 score_log ~= g.score; 37 score_log ~= g.score; > 38 ideal_log ~= g.score_if_abort_now; 38 if(finished || log.length+1==g.W*g.H) | 39 if(finished || log.length+1==g.map.W*g.map.H) 39 flush(); 40 flush(); 40 } 41 } 41 42 42 private: 43 private: 43 string log; 44 string log; 44 long[] score_log; 45 long[] score_log; > 46 long[] ideal_log; 45 bool flushed; 47 bool flushed; 46 48 47 void flush() 49 void flush() 48 { 50 { 49 if(flushed) < 50 return; < 51 < 52 Tuple!(long, int) cand; | 51 Tuple!(long, int, int) cand; 53 cand[0] = long.min; 52 cand[0] = long.min; 54 53 55 for(int i=0; i<score_log.length; ++i) 54 for(int i=0; i<score_log.length; ++i) 56 if(cand[0] < score_log[i]) 55 if(cand[0] < score_log[i]) 57 cand = tuple(score_log[i],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); 58 60 > 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]]; 59 std.c.stdio.printf("%.*sA\n", cand[1], log.ptr); | 66 std.c.stdio.printf("%.*sA\n", str.length, str.ptr); > 67 } 60 std.c.stdio.fflush(std.c.stdio.stdout); 68 std.c.stdio.fflush(std.c.stdio.stdout); 61 flushed = true; 69 flushed = true; 62 } 70 } 63 71 64 private: 72 private: 65 static __gshared GuardedOutput g_output; 73 static __gshared GuardedOutput g_output; 66 74
Modified src/solver.d from [22c356ff1975e92f] to [df1ca9c8d7e8adb9].
1 import util; 1 import util; 2 import game; 2 import game; 3 3 4 class Solver_0 4 class Solver_0 5 { 5 { 6 this(in Game g) {} | 6 this(const(Game) g) {} 7 char single_step() { return 'W'; } 7 char single_step() { return 'W'; } 8 void force(char c) {} < 9 } 8 } 10 9 11 class Solver_1 10 class Solver_1 12 { 11 { 13 int wait_count = 0; 12 int wait_count = 0; 14 int choke_count = 0; 13 int choke_count = 0; 15 14 16 Game g; 15 Game g; 17 this(in Game g) | 16 this(const(Game) g) 18 { 17 { 19 this.g = g.clone(); 18 this.g = g.clone(); 20 forbidden_cell = new bool[][](g.H+2, g.W+2); | 19 forbidden_cell = new bool[][](g.map.H+2, g.map.W+2); 21 } 20 } 22 21 23 char single_step() 22 char single_step() 24 { 23 { 25 Tuple!(string,int) de = death_move(g); 24 Tuple!(string,int) de = death_move(g); 26 char c = act(g, de[0], de[1]); 25 char c = act(g, de[0], de[1]); 27 force(c); | 26 g.command(c); 28 return c; 27 return c; 29 } 28 } 30 29 31 void force(char c) < 32 { < 33 if(c != 'A') < 34 g.command(c); < 35 } < 36 < 37 Tuple!(string,int) death_move(const(Game) g) 30 Tuple!(string,int) death_move(const(Game) g) 38 { 31 { 39 string death; 32 string death; 40 int choice = 0; 33 int choice = 0; 41 foreach(char c; "UDLRW") { 34 foreach(char c; "UDLRW") { 42 Game gg = g.clone(); 35 Game gg = g.clone(); 43 gg.command(c); 36 gg.command(c); 44 if( !gg.cleared && gg.dead ) 37 if( !gg.cleared && gg.dead ) 45 death ~= c; 38 death ~= c; 46 else if( gg.robot != g.robot ) | 39 else if( gg.map.robot != g.map.robot ) 47 choice++; 40 choice++; 48 else if( c != 'W' ) // meaningless move 41 else if( c != 'W' ) // meaningless move 49 death ~= c; 42 death ~= c; 50 } 43 } 51 return tuple(death, choice); 44 return tuple(death, choice); 52 } 45 } 53 46 54 Tuple!(Pos, int)[] log; 47 Tuple!(Pos, int)[] log; 55 bool[][] forbidden_cell; 48 bool[][] forbidden_cell; 56 49 57 char act(const(Game) g, string death, int breath) 50 char act(const(Game) g, string death, int breath) 58 { 51 { 59 const Pos ro = g.robot; | 52 const Pos ro = g.map.robot; 60 const Pos li = g.lift; < 61 Pos[] la = g.lambdas(); | 53 const Pos[] la = g.map.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(); | 54 const Pos[] ra = g.map.razors(); 68 const(Pos)[] hi = g.higes(); < > 55 const Pos li = g.map.lift; > 56 const Pos[] hi = g.map.objects('W'); 69 57 70 Tuple!(char,int)[] cand; 58 Tuple!(char,int)[] cand; 71 char c = 'W'; 59 char c = 'W'; 72 if( la.empty ) { 60 if( la.empty ) { 73 cand = search(g, ro, [li], death); 61 cand = search(g, ro, [li], death); 74 } else { 62 } else { 75 cand ~= search(g, ro, la~ra, death); 63 cand ~= search(g, ro, la~ra, death); 76 } 64 } 77 65 78 // 'higesori' mode 66 // 'higesori' mode 79 if( !hi.empty && g.num_razor>0 ) { | 67 if( !hi.empty && g.map.razor>0 ) { 80 int his = 0; 68 int his = 0; 81 for(int dy=-1; dy<=+1; ++dy) 69 for(int dy=-1; dy<=+1; ++dy) 82 for(int dx=-1; dx<=+1; ++dx) 70 for(int dx=-1; dx<=+1; ++dx) 83 if(g[ro.y+dy,ro.x+dx] == 'W') | 71 if(g.map[ro.y+dy,ro.x+dx] == 'W') 84 his++; 72 his++; 85 73 86 if(his>=2 || his==hi.length) 74 if(his>=2 || his==hi.length) 87 cand = [tuple('S',int.max)]; 75 cand = [tuple('S',int.max)]; 88 if(cand.empty) { 76 if(cand.empty) { 89 const(Pos)[] tgt; 77 const(Pos)[] tgt; 90 for(int y=1; y<=g.H; ++y) | 78 for(int y=1; y<=g.map.H; ++y) 91 for(int x=1; x<=g.W; ++x) | 79 for(int x=1; x<=g.map.W; ++x) 92 if(g[y,x]=='.'||g[y,x]==' ') { | 80 if(g.map[y,x]=='.'||g.map[y,x]==' ') { 93 his = 0; 81 his = 0; 94 for(int dy=-1; dy<=+1; ++dy) 82 for(int dy=-1; dy<=+1; ++dy) 95 for(int dx=-1; dx<=+1; ++dx) 83 for(int dx=-1; dx<=+1; ++dx) 96 if(g[y+dy,x+dx] == 'W') | 84 if(g.map[y+dy,x+dx] == ' 97 his++; 85 his++; 98 if(his>=2) 86 if(his>=2) 99 tgt ~= new Pos(y,x); 87 tgt ~= new Pos(y,x); 100 } 88 } 101 cand ~= search(g, ro, tgt, death, true); 89 cand ~= search(g, ro, tgt, death, true); 102 } 90 } 103 } 91 } 104 92 105 // 'dig' mode 93 // 'dig' mode 106 if(cand.empty) { 94 if(cand.empty) { 107 const(Pos)[] tgt; 95 const(Pos)[] tgt; 108 for(int y=1; y<=g.H; ++y) | 96 for(int y=1; y<=g.map.H; ++y) 109 for(int x=1; x<=g.W; ++x) | 97 for(int x=1; x<=g.map.W; ++x) 110 if(g[y,x]=='.') | 98 if(g.map[y,x]=='.') 111 if(g[y+1,x]=='*'||g[y+1,x-1]=='*'||g[y+1 | 99 if(g.map[y+1,x]=='*'||g.map[y+1,x-1]=='* 112 ||g[y,x+1]=='*'||g[y,x-1]=='*') | 100 ||g.map[y,x+1]=='*'||g.map[y,x-1]=='*') 113 tgt ~= new Pos(y,x); 101 tgt ~= new Pos(y,x); 114 cand ~= search(g, ro, tgt, death, true); 102 cand ~= search(g, ro, tgt, death, true); 115 } 103 } 116 104 117 if(cand.empty) { 105 if(cand.empty) { 118 choke_count++; 106 choke_count++; 119 cand ~= tuple('W',int.max); 107 cand ~= tuple('W',int.max); ................................................................................................................................................................................ 133 } 121 } 134 } 122 } 135 123 136 if(c == 'W') 124 if(c == 'W') 137 wait_count++; 125 wait_count++; 138 else 126 else 139 wait_count = 0; 127 wait_count = 0; 140 if(choke_count >= g.H) | 128 if(choke_count >= g.map.H) 141 c = 'A'; 129 c = 'A'; 142 130 143 bool[char] choice; 131 bool[char] choice; 144 foreach(t; cand) 132 foreach(t; cand) 145 choice[t[0]] = true; 133 choice[t[0]] = true; 146 log ~= tuple(ro.clone(), cast(int)choice.length); 134 log ~= tuple(ro.clone(), cast(int)choice.length); 147 if(log.length > 5) 135 if(log.length > 5) ................................................................................................................................................................................ 157 return c; 145 return c; 158 } 146 } 159 147 160 Tuple!(char,int)[] search(in Game g, in Pos s, in Pos[] gs, string death 148 Tuple!(char,int)[] search(in Game g, in Pos s, in Pos[] gs, string death 161 { 149 { 162 bool danger(int y, int x) 150 bool danger(int y, int x) 163 { 151 { 164 if(g[y,x] == ' ' || g[y,x] == 'R') | 152 if(g.map[y,x] == ' ' || g.map[y,x] == 'R') 165 return false; 153 return false; 166 if(g[y+1,x] == '*') | 154 if(g.map[y+1,x] == '*') > 155 return true; > 156 if(g.map[y+1,x-1]=='*' && (g.map[y,x-1]=='\\'||g.map[y,x 167 return true; 157 return true; 168 if(g[y+1,x-1]=='*' && (g[y,x-1]=='\\'||g[y,x-1]=='*') && | 158 if(g.map[y+1,x+1]=='*' && (g.map[y,x+1]=='*') && (g.map[ 169 return true; 159 return true; 170 if(g[y+1,x+1]=='*' && (g[y,x+1]=='*') && (g[y+1,x]==' '| | 160 if(g.map[y,x-1]=='*' && (g.map[y-1,x-1]=='\\'||g.map[y-1 171 return true; 161 return true; 172 if(g[y,x-1]=='*' && (g[y-1,x-1]=='\\'||g[y-1,x-1]=='*') | 162 if(g.map[y,x+1]=='*' && (g.map[y-1,x+1]=='*') && (g.map[ 173 return true; < 174 if(g[y,x+1]=='*' && (g[y-1,x+1]=='*') && (g[y-1,x]==' '| < 175 return true; 163 return true; 176 return false; 164 return false; 177 } 165 } 178 166 179 // avoid directly below '*' 167 // avoid directly below '*' 180 Tuple!(char,int)[] tryA() { 168 Tuple!(char,int)[] tryA() { 181 const(Pos)[] q; 169 const(Pos)[] q; 182 foreach(p; gs) 170 foreach(p; gs) 183 if(!danger(p.y,p.x)) 171 if(!danger(p.y,p.x)) 184 q ~= p; 172 q ~= p; 185 bool[][] v = new bool[][](g.H+2, g.W+2); | 173 bool[][] v = new bool[][](g.map.H+2, g.map.W+2); 186 foreach(p; q) v[p.y][p.x]=true; 174 foreach(p; q) v[p.y][p.x]=true; 187 for(int step=1; q.length; ++step) { 175 for(int step=1; q.length; ++step) { 188 Pos[] q2; 176 Pos[] q2; 189 foreach(p; q) { 177 foreach(p; q) { 190 int[] yyy=[p.y-1,p.y+1,p.y,p.y]; 178 int[] yyy=[p.y-1,p.y+1,p.y,p.y]; 191 int[] xxx=[p.x,p.x,p.x-1,p.x+1]; 179 int[] xxx=[p.x,p.x,p.x-1,p.x+1]; 192 for(int i=0; i<yyy.length; ++i) { 180 for(int i=0; i<yyy.length; ++i) { 193 int y = yyy[i]; 181 int y = yyy[i]; 194 int x = xxx[i]; 182 int x = xxx[i]; 195 if('1'<=g[y,x]&&g[y,x]<='9') { | 183 if('1'<=g.map[y,x]&&g.map[y,x]<= 196 foreach(ppp; g.trampolin | 184 foreach(ppp; g.map.tr_so 197 yyy ~= ppp.y; 185 yyy ~= ppp.y; 198 xxx ~= ppp.x; 186 xxx ~= ppp.x; 199 } 187 } 200 continue; 188 continue; 201 } 189 } 202 if(v[y][x]) continue; 190 if(v[y][x]) continue; 203 if(y==s.y && x==s.x && i<4) { 191 if(y==s.y && x==s.x && i<4) { 204 char c = "UDRL"[i]; 192 char c = "UDRL"[i]; 205 if( death.count(c) == 0 193 if( death.count(c) == 0 206 return [tuple(c, 194 return [tuple(c, 207 } else if(forbidden_cell[y][x]){ 195 } else if(forbidden_cell[y][x]){ 208 } else if(g[y,x]==' '||g[y,x]==' | 196 } else if(g.map[y,x]==' '||g.map 209 if(danger(y,x)) 197 if(danger(y,x)) 210 continue; 198 continue; 211 q2 ~= new Pos(y,x); 199 q2 ~= new Pos(y,x); 212 v[y][x]=true; 200 v[y][x]=true; 213 } 201 } 214 } 202 } 215 } 203 } ................................................................................................................................................................................ 218 return []; 206 return []; 219 } 207 } 220 208 221 // any empty space is my ground 209 // any empty space is my ground 222 Tuple!(char,int)[] tryB() { 210 Tuple!(char,int)[] tryB() { 223 const(Pos)[] q; 211 const(Pos)[] q; 224 foreach(p; gs) q ~= p; 212 foreach(p; gs) q ~= p; 225 bool[][] v = new bool[][](g.H+2, g.W+2); | 213 bool[][] v = new bool[][](g.map.H+2, g.map.W+2); 226 foreach(p; q) v[p.y][p.x]=true; 214 foreach(p; q) v[p.y][p.x]=true; 227 for(int step=10; q.length; ++step) { 215 for(int step=10; q.length; ++step) { 228 Pos[] q2; 216 Pos[] q2; 229 foreach(p; q) { 217 foreach(p; q) { 230 int[] yyy=[p.y-1,p.y+1,p.y,p.y]; 218 int[] yyy=[p.y-1,p.y+1,p.y,p.y]; 231 int[] xxx=[p.x,p.x,p.x-1,p.x+1]; 219 int[] xxx=[p.x,p.x,p.x-1,p.x+1]; 232 for(int i=0; i<yyy.length; ++i) { 220 for(int i=0; i<yyy.length; ++i) { 233 int y = yyy[i]; 221 int y = yyy[i]; 234 int x = xxx[i]; 222 int x = xxx[i]; 235 if('1'<=g[y,x]&&g[y,x]<='9') { | 223 if('1'<=g.map[y,x]&&g.map[y,x]<= 236 foreach(ppp; g.trampolin | 224 foreach(ppp; g.map.tr_so 237 yyy ~= ppp.y; 225 yyy ~= ppp.y; 238 xxx ~= ppp.x; 226 xxx ~= ppp.x; 239 } 227 } 240 continue; 228 continue; 241 } 229 } 242 if(v[y][x]) continue; 230 if(v[y][x]) continue; 243 if(y==s.y && x==s.x && i<4) { 231 if(y==s.y && x==s.x && i<4) { 244 char c = "UDRL"[i]; 232 char c = "UDRL"[i]; 245 if( death.count(c) == 0 233 if( death.count(c) == 0 246 return [tuple(c, 234 return [tuple(c, 247 } else if(forbidden_cell[y][x]){ 235 } else if(forbidden_cell[y][x]){ 248 } else if(g[y,x]==' '||g[y,x]==' | 236 } else if(g.map[y,x]==' '||g.map 249 q2 ~= new Pos(y,x); 237 q2 ~= new Pos(y,x); 250 v[y][x]=true; 238 v[y][x]=true; 251 } 239 } 252 } 240 } 253 } 241 } 254 q = q2; 242 q = q2; 255 } 243 } ................................................................................................................................................................................ 256 return []; 244 return []; 257 } 245 } 258 246 259 // push rocks! 247 // push rocks! 260 Tuple!(char,int)[] tryC() { 248 Tuple!(char,int)[] tryC() { 261 const(Pos)[] q; 249 const(Pos)[] q; 262 foreach(p; gs) q ~= p; 250 foreach(p; gs) q ~= p; 263 bool[][] v = new bool[][](g.H+2, g.W+2); | 251 bool[][] v = new bool[][](g.map.H+2, g.map.W+2); 264 foreach(p; q) v[p.y][p.x]=true; 252 foreach(p; q) v[p.y][p.x]=true; 265 for(int step=20; q.length; ++step) { 253 for(int step=20; q.length; ++step) { 266 Pos[] q2; 254 Pos[] q2; 267 foreach(p; q) { 255 foreach(p; q) { 268 int[] yyy=[p.y-1,p.y+1,p.y,p.y]; 256 int[] yyy=[p.y-1,p.y+1,p.y,p.y]; 269 int[] xxx=[p.x,p.x,p.x-1,p.x+1]; 257 int[] xxx=[p.x,p.x,p.x-1,p.x+1]; 270 for(int i=0; i<yyy.length; ++i) { 258 for(int i=0; i<yyy.length; ++i) { 271 int y = yyy[i]; 259 int y = yyy[i]; 272 int x = xxx[i]; 260 int x = xxx[i]; 273 if(g[p] == '*') { | 261 if(g.map[p] == '*') { 274 if(i>=4)continue; 262 if(i>=4)continue; 275 if(y!=p.y)continue; 263 if(y!=p.y)continue; 276 if(g[y,p.x+(p.x-x)]!=' ' | 264 if(g.map[y,p.x+(p.x-x)]! 277 } 265 } 278 if('1'<=g[y,x]&&g[y,x]<='9') { | 266 if('1'<=g.map[y,x]&&g.map[y,x]<= 279 foreach(ppp; g.trampolin | 267 foreach(ppp; g.map.tr_so 280 yyy ~= ppp.y; 268 yyy ~= ppp.y; 281 xxx ~= ppp.x; 269 xxx ~= ppp.x; 282 } 270 } 283 continue; 271 continue; 284 } 272 } 285 if(v[y][x]) continue; 273 if(v[y][x]) continue; 286 if(y==s.y && x==s.x && i<4) { 274 if(y==s.y && x==s.x && i<4) { 287 char c = "UDRL"[i]; 275 char c = "UDRL"[i]; 288 if( death.count(c) == 0 276 if( death.count(c) == 0 289 return [tuple(c, 277 return [tuple(c, 290 } else if(forbidden_cell[y][x]){ 278 } else if(forbidden_cell[y][x]){ 291 } else if(g[y,x]==' '||g[y,x]==' | 279 } else if(g.map[y,x]==' '||g.map 292 q2 ~= new Pos(y,x); 280 q2 ~= new Pos(y,x); 293 v[y][x]=true; 281 v[y][x]=true; 294 } 282 } 295 } 283 } 296 } 284 } 297 q = q2; 285 q = q2; 298 } 286 } 299 return []; 287 return []; 300 } 288 } 301 return (danger_ok ? [] : tryA()) ~ tryB() ~ tryC(); 289 return (danger_ok ? [] : tryA()) ~ tryB() ~ tryC(); 302 } 290 } 303 } 291 } 304 292 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], < 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; | 293 alias Solver_1 MainSolver;
Modified src/util.d from [b76be1f6ad977d56] to [0665970b47ba63ed].
1 public import std.algorithm; 1 public import std.algorithm; 2 public import std.array; 2 public import std.array; 3 public import std.conv; 3 public import std.conv; 4 public import std.range; 4 public import std.range; 5 public import std.stdio; 5 public import std.stdio; 6 public import std.string; 6 public import std.string; 7 public import std.typecons; 7 public import std.typecons; 8 public import std.math; < 9 import std.c.stdlib; 8 import std.c.stdlib; 10 9 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 } < 32 < 33 void application_exit() 10 void application_exit() 34 { 11 { 35 std.c.stdlib.exit(0); 12 std.c.stdlib.exit(0); 36 } 13 } 37 14 38 template DeriveCreate() 15 template DeriveCreate() 39 { 16 {