TASVideos

Says COMBOMASTR here. I like it when people take the frames to spell out a name. I am more concerned about the graphics errors with stray lines under stuff.

Posted: 4/23/2014 4:59 PM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

We have precedence saying that it is fine to pick a different version based on the language as long as any differences due to this are ignored when comparing times.

Posted: 4/22/2014 1:38 PM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

Heh, I did the same myself. But somehow my code fails to reach a conclusion in a few spots for a few maps. I guess I missed a rule somewhere.

Posted: 4/21/2014 12:46 AM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

The game is basically changing the transformation matrix each hblank. So to emulate the effect you need to do the same, change the matrix for each row of the image.

Posted: 4/18/2014 4:15 PM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

I don't think Light Up and Nurikabe is the same. They certainly are similar, but not the same.

Posted: 4/18/2014 2:20 PM
(Edited: 4/22/2014 2:07 PM)

Post subject: Puzzles done by programs

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

I am a fan of the professor Layton games. The games have a lot of puzzles, some of which are of the type that I believe that they can be solved by a program. The main candidate for this is the daily puzzles, puzzles that are designed to work even when there are many of the same type as opposed to being unique. As such, I challenge you all to solve the puzzles.


    "Bewitched"
    You are given a 2d grid that represents a city block. Each cell in the grid can be either:
    * An open street
    * A street with a street lamp
    * An obstacle (house/tree)
     
    The goal is to find the configuration with the minimum number of lit lamps that:
    * All streets (lamp or not) are lit
    * No lit street lamp shines on another lit street lamp
     
    Lamps light all streets in a plus shape, that is up, down, left and right, until blocked by either an obstacle or the edge of the map.
     
    0=Open street
    1=Obstacle
    2=Lamp street
     
    maps[0]=new Map(5,5, new <uint> [
                            0,1,0,2,0,
                            2,2,0,0,1,
                            0,0,1,0,2,
                            1,2,0,2,2,
                            0,0,2,1,0
                            ]);
                           
                            maps[1]=new Map(5,5, new <uint> [
                            0,2,0,2,2,
                            1,2,0,2,1,
                            0,2,1,2,2,
                            1,2,0,2,1,
                            2,2,2,2,2
                            ]);
                           
                            maps[2]=new Map(9,9,new <uint> [
                            1,2,0,2,0,2,0,2,1,
                            0,0,1,0,2,0,1,0,2,
                            2,1,2,0,2,1,2,2,0,
                            0,0,0,1,0,2,0,0,1,
                            0,2,1,0,0,0,1,0,0,
                            1,0,0,2,2,1,0,0,0,
                            0,0,2,1,0,2,2,1,2,
                            2,0,1,2,0,0,1,0,0,
                            1,2,0,0,2,0,0,2,1
                            ]);
                           
                            maps[3]=new Map(9,9,new <uint> [
                            2,0,1,2,2,1,2,0,2,
                            0,1,2,0,1,0,0,1,0,
                            0,1,0,1,0,2,0,1,0,
                            0,1,0,0,1,0,0,1,0,
                            0,0,2,2,0,2,2,0,0,
                            0,1,0,0,1,0,0,1,0,
                            0,1,2,2,0,1,0,1,0,
                            0,1,0,0,1,2,0,1,0,
                            2,0,2,1,2,0,1,2,2
                            ]);
                           
                            maps[4]=new Map(9,9,new <uint> [
                            1,2,1,1,2,1,1,2,2,
                            1,0,0,2,0,2,0,0,1,
                            0,2,1,0,1,0,1,0,1,
                            1,0,1,0,1,0,1,2,0,
                            1,0,2,0,0,0,0,2,1,
                            2,2,1,0,1,0,1,0,1,
                            1,0,1,2,1,0,1,0,2,
                            1,2,0,0,0,0,2,0,1,
                            2,0,1,1,2,1,1,2,1
                            ]);
                           
                            maps[5]=new Map(14,9,new <uint> [
                            2,0,1,2,0,0,2,1,0,2,1,0,2,1,
                            0,1,2,0,1,2,1,0,2,0,0,2,0,2,
                            2,0,2,1,0,2,2,2,1,0,1,0,1,0,
                            0,1,0,2,2,1,0,1,0,2,2,1,2,2,
                            1,0,2,1,0,0,2,2,2,0,1,2,0,1,
                            2,2,1,2,0,0,1,0,1,0,2,0,1,0,
                            0,1,2,1,0,1,0,2,2,0,1,2,0,2,
                            2,0,0,2,0,2,0,1,0,1,0,2,1,0,
                            1,2,0,1,2,0,1,0,2,0,2,1,2,2
                            ]);
                           
                            maps[6]=new Map(14,9,new <uint> [
                            0,0,2,0,2,0,0,1,0,0,2,0,0,2,
                            0,1,2,0,1,2,2,0,0,1,0,0,1,0,
                            2,0,1,1,2,0,2,1,2,0,1,0,2,2,
                            2,0,0,0,2,1,0,1,2,2,0,0,1,0,
                            1,0,2,1,1,0,0,0,0,1,1,2,0,1,
                            0,1,0,0,2,2,1,0,1,0,2,0,0,2,
                            2,0,2,1,0,0,1,0,2,0,1,1,0,2,
                            0,1,0,2,1,2,0,2,2,1,2,0,1,0,
                            2,0,0,0,2,0,1,2,0,0,0,2,0,0
                            ]);
                           
                            maps[7]=new Map(9,9,new <uint> [
                            0,0,2,0,0,0,0,0,0,
                            0,1,0,1,2,2,1,0,2,
                            2,0,0,2,0,1,1,1,0,
                            0,1,2,1,0,2,1,2,0,
                            2,0,0,2,0,2,0,0,0,
                            0,2,1,0,2,1,0,1,0,
                            0,1,1,1,2,0,0,0,2,
                            2,0,1,2,0,1,0,1,0,
                            0,2,0,0,0,0,2,0,0
                            ]);
                           
                            maps[8]=new Map(9,9,new <uint> [
                            2,0,1,0,2,2,0,0,2,
                            0,1,0,0,2,1,0,1,0,
                            2,0,2,1,0,0,0,2,2,
                            0,0,0,2,0,1,2,0,1,
                            2,1,2,0,1,0,2,1,0,
                            1,2,0,1,0,0,0,0,2,
                            0,0,2,0,2,1,0,2,2,
                            2,1,0,1,0,0,0,1,0,
                            2,0,2,0,2,2,1,2,2
                            ]);
                           
                            maps[9]=new Map(14,9,new <uint> [
                            2,0,1,2,1,0,2,0,2,0,1,2,0,2,
                            0,1,2,0,2,2,1,0,0,0,2,0,0,2,
                            2,0,2,1,0,1,0,0,2,1,0,0,1,0,
                            0,1,1,0,2,0,2,1,0,0,1,2,0,1,
                            0,2,0,2,0,1,0,2,1,2,2,0,0,2,
                            1,0,2,1,0,0,1,2,0,0,0,1,1,0,
                            0,1,2,2,1,2,0,0,1,0,1,0,2,2,
                            2,0,0,0,2,0,2,1,0,2,2,0,1,0,
                            0,0,2,1,0,2,0,2,0,1,0,1,2,0
                            ]);
                           
                            maps[10]=new Map(14,9,new <uint> [
                            0,2,0,0,0,2,1,2,0,0,2,0,0,2,
                            0,2,1,2,1,0,0,0,1,2,0,0,1,0,
                            0,1,2,0,0,1,2,0,0,1,2,1,2,0,
                            2,0,0,2,0,0,0,1,0,0,2,0,0,2,
                            1,2,0,1,0,0,2,0,2,0,1,0,2,1,
                            0,0,0,2,0,0,1,2,0,0,2,0,0,0,
                            2,0,1,0,1,0,2,0,1,2,0,0,1,0,
                            0,1,2,0,0,1,0,2,0,1,0,1,2,2,
                            0,0,2,0,2,0,0,1,0,0,2,0,0,2
                            ]);
                           
                            maps[11]=new Map(9,9,new <uint> [
                            1,2,0,1,2,0,0,2,1,
                            2,0,0,2,0,0,1,0,0,
                            0,1,0,0,2,1,0,1,2,
                            1,0,2,1,0,0,2,0,2,
                            2,0,1,0,1,2,1,2,0,
                            0,2,0,2,0,1,0,0,1,
                            0,1,2,1,2,0,2,1,0,
                            2,0,1,2,0,0,0,2,2,
                            1,2,0,0,2,1,2,0,1,
                            ]);
                           
                            maps[12]=new Map(9,9,new <uint> [
                            1,2,0,0,1,0,2,0,1,
                            0,0,0,2,0,0,2,0,0,
                            1,0,1,0,2,2,1,0,1,
                            0,2,2,1,0,1,2,2,0,
                            0,1,2,0,1,2,0,1,0,
                            2,2,2,1,0,1,0,2,2,
                            1,0,1,0,0,2,1,0,1,
                            0,2,0,2,2,0,2,0,0,
                            1,2,0,0,1,2,0,2,1
                            ]);
                           
                            maps[13]=new Map(14,9,new <uint> [
                            1,0,2,0,2,1,2,0,0,1,2,2,2,2,
                            2,0,0,1,0,2,2,1,0,0,2,0,1,0,
                            0,1,0,2,2,2,1,2,0,0,1,0,0,0,
                            0,0,0,0,1,2,2,2,1,2,2,2,0,0,
                            1,0,1,2,2,2,2,2,2,2,2,1,0,1,
                            2,2,2,2,2,1,2,2,2,1,2,2,2,0,
                            2,0,0,1,0,0,2,1,0,0,0,0,1,2,
                            0,1,0,0,2,0,1,0,0,2,1,0,2,0,
                            0,0,2,0,1,0,0,2,1,0,0,2,0,1
                            ]);
                           
                            maps[14]=new Map(14,9,new <uint> [
                            2,0,2,0,0,2,0,0,0,0,0,0,0,0,
                            0,0,0,0,2,0,1,0,0,0,0,2,0,2,
                            0,2,0,1,0,2,0,0,0,0,0,0,1,0,
                            1,0,0,0,1,0,0,0,0,1,0,0,0,2,
                            0,2,0,2,0,2,0,2,0,2,0,2,0,0,
                            2,0,2,0,1,0,0,0,0,0,0,0,2,1,
                            0,1,0,0,0,2,0,0,2,0,1,2,0,2,
                            2,0,2,0,2,0,2,1,0,2,0,0,2,0,
                            0,2,0,2,0,2,0,0,2,0,0,2,0,2
                            ]);
                           
                            maps[15]=new Map(14,9,new <uint> [
                            1,0,1,0,2,0,2,0,0,2,0,0,0,2,
                            0,2,2,0,1,2,1,0,1,0,1,2,1,0,
                            0,1,0,2,0,0,0,0,1,0,1,0,1,2,
                            2,2,0,2,1,0,1,2,1,0,2,0,2,0,
                            1,0,1,0,2,0,2,0,2,0,0,1,0,1,
                            0,2,0,2,0,1,0,1,0,1,0,2,0,2,
                            2,1,0,1,2,1,0,2,0,0,2,0,1,2,
                            0,1,0,1,0,1,0,1,2,1,0,0,0,0,
                            2,0,2,0,0,2,0,0,0,2,0,1,2,1
                            ]);
                           
                            maps[16]=new Map(9,9,new <uint> [
                            2,0,0,0,2,1,0,0,2,
                            0,1,0,2,0,1,0,2,0,
                            0,0,2,0,0,0,2,0,2,
                            0,2,1,0,0,2,0,0,1,
                            2,1,2,0,2,0,0,1,0,
                            1,2,0,0,0,2,1,0,2,
                            2,0,0,0,0,0,2,0,0,
                            0,0,0,1,0,2,0,1,0,
                            0,0,0,1,2,0,0,0,2
                            ]);
                           
                            maps[17]=new Map(14,9,new <uint> [
                            1,1,2,0,2,0,0,1,2,0,0,0,1,1,
                            0,1,0,1,0,0,2,2,0,1,0,2,2,1,
                            2,0,2,0,0,1,2,0,0,0,1,2,0,0,
                            0,0,1,0,0,2,1,0,0,2,2,0,0,2,
                            1,2,0,0,1,0,0,2,2,1,2,0,2,1,
                            2,0,0,2,0,0,2,1,0,0,0,1,0,2,
                            2,0,0,1,0,2,0,2,1,2,0,2,0,2,
                            1,2,2,0,1,0,0,0,2,0,1,0,1,0,
                            1,1,2,0,0,2,1,2,0,0,0,2,1,1
                            ]);


    "Alchemy":
    You are given a 2d grid. On the grid are flasks. Each flask is labeled with a number.
     
    Flasks can be connected on empty cells in the grid using straight, non crossing lines. Each connection can be done using one or two pipes. Connections can not cross each other.
     
    The number on each flask is the number of pipes connecting it to the other flasks.
     
    The goal is to connect all the flasks into one graph. That means that any flask should be reachable by any other flask.
     
    40603
    00010
    40300
    00001
    20020
     
    30200
    01003
    50400
    00000
    20303
     
    300005003
    003040020
    000002003
    200000000
    004080040
    000000000
    203001003
    000000000
    304020102
     
    30500203000403
    01000000303000
    00301002020100
    30010200303003
    02004003050020
    00200300300103
    20000000003030
    00303010200000
    30030503003003

    "Fiefdoms"
    You are given a 2d grid that represents a small country. On the grid are castles.
     
    Each castle has a number on it. The number represents the area that it controls.
     
    The goal is to create rectangular, non overlapping, regions with an area so that the single castle in each region has an area exactly matching the number on the castle.
     
    Castles with numbers larger than 9 continue using hexadecimal digits.
     
    90002
    00000
    00000
    00000
    60008
     
    06600400
    00000002
    00004000
    25000000
    00000046
    00050000
    30000000
    00400A30
     
    500005000800
    005080000020
    000000090000
    060000000004
    300000000080
    006000000000
    030000060300
    005000600004


    "Ghouls"
    You are given a 2d grid. Along the borders of the grid are guards and ghouls. Ghouls and Guards are color coded, there is only one each of each color. The inside of the grid is split into regions.
     
    Each region contains one mirror. Mirrors are angled at a perfect 45 degrees angle. Each guard emits a beam towards the grid. The beam reflects at a 90 degrees angle when it hits a mirror. Both sides of a mirror may reflect a beam.
     
    The goal is to reflect the beams so that they hit the matching ghoul in exactly the number of bounces marked on the ghoul.
     
    0A00B0
    01122B
    D11220
    03344A
    B33440
    00CD00
    A=1
    B=1
    C=1
    D=1
     
    0ABBD0
    011220
    C13320
    04335D
    04455A
    000C00
    A=1
    B=2
    C=1
    D=1
     
    0ABCDEFG0H00
    011233455660
    07723345566I
    I8722995aaaH
    D888b99ccdaJ
    0eebbfggcddB
    CeebbfggchhK
    0G0AE00JK0F0
    A=2
    B=1
    C=3
    D=1
    E=4
    F=2
    G=2
    H=1
    I=2
    J=3
    K=5

    "Ducklings"
    You are given a 2d grid. On the grid are ducklings and their mothers.
     
    The each grid cell contains one of:
    * Empty
    * Obstacle
    * Mother duck
    * Numbered duckling
     
    The goal is to form chains consisting of a mother duck followed by four ducklings. You may place additional ducks to do so.
     
    Mothers look in the direction opposite from the location of the first duckling of the chain. Mothers must not see any other chain.
     
    Chains may not touch, diagonals don't count.
     
    000002
    0XX0M0
    0M0X00
    00X0M0
    300XX0
    00M000
     
    X00MXM00X
    010000X00
    3X0X0X000
    00X040X00
    X00MX000X
    00X000X00
    000X0XMXM
    00X0M0020
    X030X000X
     
    0X00M002000000
    0010000XX00002
    40000000000000
    000X00X0010MX0
    X020000000X000
    4000040X000000
    0000000X000000
    4X0000300X000X
    00000000X40004

Whose Tile Is It Anyway? ("Whose Tile" for short)

You are given a grid with open and closed cells and a set of blocks.
All blocks are straight lines. The blocks may be rotated on 90 degree angles.
Each block is composed of colored cells and align with the grid when placed in the grid.

The goal is to position all the blocks inside the open cells of the grid so that all overlapping parts of the blocks have the same color as the corresponding position of the other blocks.

Zero indicates open cells and ones indicate closed cells.

00000
01011
00000
01101
00001
BBBBB
RRRR
BBBRR
BBB
BRBRB
RRR

01000010
00011000
01000010
01011010
00000000
01110101
RBYGRBYG
RGBG
RBRBRB
YBYB
YYRGY
BYG
RGYRG
BYY
BBGGB
RB
YR

00000010
01010110
01000000
00010110
01100000
00001110
RRBBBR
BYGO
RRRGGG
GYBR
GGGYYY
GGO
BBYYGY
BR
BGGGO
BOOOG

000000
101010
000010
101000
001101
100000
RBYGYR
RBBY
BGRBYO
GYBR
OBGYR
GRYB
RBY
BGY
BY

01000001
00010110
10100000
00001010
10100010
00001000
GGPOY
YOBY
BYRPO
YROY
GGPGO
GOGO
GPGOG
GYGY
YBY
PBP
OBO
GBG
OY
GY

00000000
10101010
00001010
01010000
01010110
00000000
YYBRGYBR
GYGY
GYBRGYBB
GYRR
BRGYBR
YGGY
RRYB
GGYY
YBY
GBG
RBR

Posted: 4/17/2014 11:00 PM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

How about the RTS resource problem? You have a turn based game where you can either wait each turn or queue up a new worker unit. You start with F number of resources. Each worker unit costs C resources and takes D turns to become active and produces E resources per turn once active. The goal is to reach N resources in the shortest number of turns.

Posted: 4/15/2014 4:01 PM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

We already have a version of that game.

Posted: 4/13/2014 11:01 PM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

Fun fact: people can tell when individual subpixels are "wrong". Try viewing text anti aliased on a subpixel level with the wrong subpixel order.

Posted: 4/11/2014 10:42 PM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

Most certainly not intended. But definitely in the spirit of the game.

Posted: 4/11/2014 5:03 PM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

Variable scope isn't a strange thing.

Posted: 4/11/2014 1:44 PM
(Edited: 4/11/2014 4:28 PM)

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

More intended solution for 15: function () { throw ""}() Short and to the point. 16: Rather straight forward task. var playerColorId=0 function p() { playerColorId=(playerColorId+1)%3 map.getPlayer().setColor(colors[playerColorId]); } map.getPlayer().setPhoneCallback(p) 17: if(t1.getType() == 'teleporter' && t2.getType() == 'teleporter') { p1=map.getCanvasCoords(t1) p2=map.getCanvasCoords(t2) c=map.getCanvasContext(); c.moveTo(p1.x,p1.y); c.lineTo(p2.x,p2.y); c.stroke(); c.strokeStyle="white"; } 18: Hold right and don't write any code! Quite the disappointing level. 19: Assuming that the AI opponent remains stuck at the start due to incompetence: Up x4, right x2, down x1, right x1, down x1, right x1, down x1

Posted: 4/11/2014 12:12 AM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

13: //remotecontrol ftw! if(player.getX()==1) { if(player.getY()==map.getHeight() - 1) me.move("up"); else if(player.getY()==map.getHeight() - 2) me.move("down"); else if(player.getY()==map.getHeight() - 3) me.move("left"); else if(player.getY()==map.getHeight() - 4) me.move("right"); }

Posted: 4/10/2014 11:08 AM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

Your English seems a little weak. Feel free to post in a more comfortable language, someone will come around to translate for you.

Posted: 4/7/2014 11:50 AM

Quote

henke37

Editor, Experienced Forum User

Joined: 3/10/2010
Posts: 899
Location: Sweden

It should be no problem for a human to enter the same solutions to within a few frames. There are no timing tricks in this game. No real glitches, no random gameplay elements. All this tests is frame perfect solution entering and avoiding mistakes.