SHARE
TWEET

Untitled

a guest May 26th, 2019 70 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()
  14.     visited.add(`${start},0,""`)
  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])
  74.                                 visited.add(nextHash)
  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])
  114.                         visited.add(nextHash)
  115.                     }
  116.                 }
  117.             }
  118.         }
  119.     }
  120. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top