• API
• FAQ
• Tools
• Archive
SHARE
TWEET

# Untitled

a guest May 26th, 2019 76 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
1. function hackTAS(s) {
2.     console.time()
3.     // Joined by * so we can split later
4.     const lvlAs1D = s.join `*`.split(''),
5.           rowWidth = s[0].length + 1,
6.           swimDirections = [
7.         [[1],[-1],[rowWidth],[-rowWidth]],
8.         [[1, 2, 3],[-1,-2, -3],[rowWidth, 2 * rowWidth],[-rowWidth, -2 * rowWidth]]
9.     ],
10.           start = lvlAs1D.indexOf('S'),
11.           // Position, steps, flags, seen
12.           queue = [[start, 0, 0, ""]],
13.           visited = new Set()
15.     while (queue[0]) {
16.         let [pos,steps,flags,order] = queue.shift()
17. //        console.log(lvlAs1D[pos])
18.         //console.log(pos,order,flags)
19.         //console.log(map.join``.split('*'))
20.         if (lvlAs1D[pos] == 'E') {
21.             console.log(order)
22.             console.timeEnd()
23.             return steps
24.         }
25.         const [resetOrder, resetFlags] = [order, flags]
26.         // Do we move like fish?
27.         for (const direction of swimDirections[+((flags & 2) == 2)]) {
28.             // Reset so no carryover
29.             [order, flags] = [resetOrder, resetFlags]
30.             // Keep track of in loop
31.             let dkIndex = 0,
32.                 fIndex = 0;
33.             // Loop on movement patterns
34.             for (const x of direction) {
35.                 // Calculate next potential tile
36.                 const nextTile = pos + x;
37.                 // Check if valid number
38.                 if (nextTile in lvlAs1D) {
39.                     // Break on wall or connector
40.                     if ('#*'.includes(d=lvlAs1D[nextTile])) break;
41.                     // Did we find D?
42.                     if (d == 'D' && !order.includes(`\${d}(\${nextTile})`)) {
43.                         // Set found flag and location
44.                         flags |= 16
45.                         dkIndex = nextTile
46.                         // Add to order
47.                         order += `\${d}(\${nextTile})`
48.                     }
49.                     if (d == 'F' && !order.includes(`\${d}(\${nextTile})`)) {
50.                         // Set found flag and location
51.                         flags |= 32
52.                         fIndex = nextTile
53.                         // Add to order
54.                         order += `\${d}(\${nextTile})`
55.                     }
56.
57.                     // Do we have the fish?
58.                     if (flags & 2) {
59.                         // Do we run into C with fish?
60.                         if (d == 'C') {
61.                             // If so, take damage (lose fish), add to queue, and break
62.                             flags ^= 2 /*1*/
63.                             if (flags & 32) flags ^= 32
64.
65.                             const nextHash = `\${nextTile},\${flags},\${order}` /*2*/
66.                             if (!visited.has(nextHash)) {
67.                                 // Did we see D?
68.                                 if (flags & 16) {
69.                                     flags ^= 16
70.                                     // Set D for fish
71.                                     flags |= 1
72.                                 }
73.                                 queue.push([nextTile, steps + 1, flags, order])
75.                             }
76.                             break;/*3*/
77.                         }
78.                     }
79.                     // No fish
80.                     else {
81.                         // Did we run into B?
82.                         if (d == 'B') {
83.                             //If we have D, take 1 damage else break
84.                             if (flags & 1)
85.                                 flags ^= 1;
86.                             else
87.                                 break;
88.                         }
89.                         // Did we run into C?
90.                         if (d == 'C') {
91.                             //If we have D, take 1 damage else break
92.                             if (flags & 1)
93.                                 flags ^= 1;
94.                             else
95.                                 break;
96.                         }
97.                     }
98.                     // Check if next tile is in visited
99.                     const nextHash = `\${nextTile},\${flags},\${order}`
100.                     if (!visited.has(nextHash)) {
101.                         // Did we see D?
102.                         if (flags & 16) {
103.                             flags ^= 16
104.                             flags |= 1
105.                         }
106.                         // Did we see F?
107.                         if (flags & 32) {
108.                             flags ^= 32
109.                             // Set F for fish
110.                             flags |= 2
111.                         }
112.
113.                         queue.push([nextTile, steps + 1, flags, order])