akkartik/sokoban.love - Change 7FNBZUF2PJZ2ZGZRZXQKZQFQGALELKAU2PIGII4745NUMJXGO6YQC

reorg files again to stay within 150 lines

Created by akkartik on March 14, 2024

7FNBZUF2PJZ2ZGZRZXQKZQFQGALELKAU2PIGII4745NUMJXGO6YQC

Dependencies

In channels

main

Change contents

File deletion: solve

BF:BFD[6.1] → [7.0:29]

BF:BFD[7.29] → [7.30:30]

∅:D[8.97] → [7.67:538]

∅:D[9.1375] → [7.67:538]

B:BD[7.67] → [7.67:538]

∅:D[10.270] → [7.750:773]

B:BD[7.750] → [7.750:773]

B:BD[7.773] → [9.1376:1521]

∅:D[9.1521] → [7.773:913]

B:BD[7.773] → [7.773:913]

∅:D[10.431] → [7.913:1357]

B:BD[7.913] → [7.913:1357]

B:BD[7.1357] → [11.1512:1543]

∅:D[9.1551] → [11.1568:1676]

B:BD[11.1568] → [11.1568:1676]

∅:D[9.1607] → [11.1727:1820]

B:BD[11.1727] → [11.1727:1820]

B:BD[11.1676] → [9.1552:1607]

B:BD[11.1543] → [9.1522:1551]

B:BD[7.913] → [10.271:336]

∅:D[3.24] → [10.348:377]

B:BD[10.348] → [10.348:377]

∅:D[3.40] → [10.407:431]

B:BD[10.407] → [10.407:431]

B:BD[10.377] → [3.25:40]

B:BD[10.336] → [3.11:24]

B:BD[7.538] → [10.11:270]

B:BD[7.30] → [12.9418:9459]

∅:D[13.3298] → [12.9459:9460]

B:BD[12.9459] → [12.9459:9460]

B:BD[12.9460] → [9.839:840]

∅:D[9.840] → [14.351:493]

B:BD[12.9460] → [14.351:493]

∅:D[14.569] → [13.3353:3419]

∅:D[9.1028] → [13.3353:3419]

B:BD[13.3353] → [13.3353:3419]

∅:D[11.1130] → [13.3461:3523]

B:BD[13.3461] → [13.3461:3523]

∅:D[11.1183] → [13.3554:3705]

B:BD[13.3554] → [13.3554:3705]

∅:D[11.1511] → [13.4137:4160]

B:BD[13.4137] → [13.4137:4160]

∅:D[9.1282] → [15.231:288]

B:BD[15.231] → [15.231:288]

B:BD[15.307] → [15.307:349]

B:BD[15.370] → [15.370:448]

B:BD[15.469] → [15.469:492]

∅:D[9.1313] → [15.602:607]

B:BD[15.602] → [15.602:607]

B:BD[15.492] → [9.1283:1313]

∅:D[15.607] → [13.4160:4346]

B:BD[13.4160] → [13.4160:4346]

∅:D[15.963] → [13.4346:4351]

B:BD[13.4346] → [13.4346:4351]

B:BD[13.4351] → [16.546:849]

B:BD[13.4346] → [15.608:775]

∅:D[16.504] → [15.814:868]

B:BD[15.814] → [15.814:868]

∅:D[16.545] → [15.912:963]

B:BD[15.912] → [15.912:963]

B:BD[15.868] → [16.505:545]

B:BD[15.775] → [16.469:504]

B:BD[13.4160] → [9.1227:1282]

∅:D[9.1226] → [11.1184:1511]

B:BD[15.119] → [11.1184:1511]

B:BD[13.3705] → [9.1156:1226]

B:BD[13.3523] → [11.1131:1183]

∅:D[5.394] → [11.1073:1130]

∅:D[9.1155] → [11.1073:1130]

B:BD[13.3419] → [11.1073:1130]

B:BD[13.3419] → [5.264:394]

B:BD[14.493] → [9.841:1028]

∅:D[16.849] → [17.11:210]

∅:D[13.4351] → [17.11:210]

B:BD[12.9460] → [17.11:210]

∅:D[17.210] → [8.11:97]

B:BD[12.9460] → [8.11:97]

B:BD[8.97] → [9.1314:1375]

B:BD[12.9459] → [13.0:50]

B:BD[13.1317] → [13.1317:1439]

∅:D[5.27] → [11.0:102]

B:BD[16.12] → [11.0:102]

∅:D[11.102] → [15.0:31]

B:BD[13.1526] → [15.0:31]

∅:D[15.31] → [13.1526:1548]

B:BD[13.1526] → [13.1526:1548]

∅:D[5.263] → [13.1629:1687]

B:BD[13.1629] → [13.1629:1687]

∅:D[9.286] → [13.1687:1835]

∅:D[11.356] → [13.1687:1835]

B:BD[13.1687] → [13.1687:1835]

∅:D[4.181] → [13.1995:2066]

∅:D[16.329] → [13.1995:2066]

B:BD[13.1995] → [13.1995:2066]

∅:D[14.110] → [13.2149:2266]

∅:D[9.477] → [13.2149:2266]

B:BD[13.2149] → [13.2149:2266]

∅:D[11.581] → [13.2381:2428]

B:BD[13.2381] → [13.2381:2428]

∅:D[14.188] → [13.2505:2560]

∅:D[9.570] → [13.2505:2560]

B:BD[13.2505] → [13.2505:2560]

∅:D[11.746] → [13.2676:2720]

B:BD[13.2676] → [13.2676:2720]

∅:D[14.272] → [13.2803:2858]

∅:D[9.745] → [13.2803:2858]

B:BD[13.2803] → [13.2803:2858]

∅:D[11.908] → [13.2971:3017]

B:BD[13.2971] → [13.2971:3017]

∅:D[14.350] → [13.3094:3149]

∅:D[9.838] → [13.3094:3149]

B:BD[13.3094] → [13.3094:3149]

∅:D[11.1072] → [13.3264:3298]

B:BD[13.3264] → [13.3264:3298]

B:BD[16.468] → [11.909:1072]

B:BD[13.3017] → [9.746:838]

B:BD[16.433] → [11.747:908]

B:BD[9.607] → [9.607:705]

B:BD[16.400] → [11.582:746]

B:BD[13.2428] → [9.478:570]

B:BD[16.364] → [11.418:581]

B:BD[13.2066] → [9.352:477]

B:BD[9.351] → [4.11:181]

B:BD[13.1548] → [11.103:194]

B:BD[11.194] → [9.0:41]

B:BD[9.41] → [5.28:263]

B:BD[13.1439] → [5.11:27]

  local done = initialize_array(false, lh, lw)
  local cands = {}
  table.insert(cands, {x=src.x, y=src.y})
  while #cands > 0 do
    local cand = table.remove(cands, 1)
    local x,y = cand.x, cand.y
    if x == dst.x and y == dst.y then return cand end
    if y >= 1 and y <= lh and x >= 1 and x <= lw and not done[y][x] then
      done[y][x] = true
      local curr = level[y][x]
      if curr ~= CELL_WALL and curr ~= CELL_CRATE and curr ~= CELL_CRATE_ON_TARGET then
      end end end end
function is_empty(level, x,y)
  local curr = level[y][x]
  return curr ~= CELL_WALL and curr ~= CELL_CRATE and curr ~= CELL_CRATE_ON_TARGET
end
function unwind_path(c)
  local result = {}
  while c do
    table.insert(result, {x=c.x, y=c.y})
    c = c.prev
  end
  return result
end
function draw_path(path)
  color(1,0,0)
  for _,cell in ipairs(path) do
    rect('line', left+(cell.x-1)*side, top+(cell.y-1)*side, side, side)
  end end
function initialize_array(val, dim, ...)
  local result = {}
  local other_dims = {...}
  if #other_dims == 0 then
    for i=1,dim do
      table.insert(result, val)
    end
  else
    for i=1,dim do
      table.insert(result, initialize_array(val, ...))
    end
  end
  return result
end
function shortest_path(cands)
  local min, minscore = 1, cands[1].path_length
  for i=2,#cands do
    local iscore = cands[i].path_length
    if iscore < minscore then
      min, minscore = i, iscore
    end
  end
  return min
end
--?     Real_print('', i, iscore, '<=>', min,minscore)
--?   Real_print('', #cands)
function unwind_steps(c, out)
  -- insert steps in reverse order
    table.insert(out, c.dir)
  end
  return out
end
    c = c.prev
  while c do
        table.insert(cands, {x=x-1, y=y, dir='left', prev=cand})
        table.insert(cands, {x=x+1, y=y, dir='right', prev=cand})
        table.insert(cands, {x=x, y=y-1, dir='up', prev=cand})
        table.insert(cands, {x=x, y=y+1, dir='down', prev=cand})
-- simple solver to remove some drudgery
-- like find_empty_path, but always allow going through empty_cell and never allow going through occupied_cell, regardless of what level says
  local done = initialize_array(false, lh, lw)
  local cands = {}
  while #cands > 0 do
    local cand = table.remove(cands, 1)
    if x == dst.x and y == dst.y then return cand end
    if y >= 1 and y <= lh and x >= 1 and x <= lw and not done[y][x] then
      done[y][x] = true
      end end end end
  if empty.y ~= occupied.y or empty.x ~= occupied.x then
    if x == empty.x and y == empty.y then
      return true
    end
  end
  if x == occupied.x and y == occupied.y then
    return false
  end
end
  return is_empty(level, x,y)
function unwind_steps_to_move_crate(c, out)
  -- insert steps in reverse order
  while c do
    table.insert(out, c.dir)
    unwind_steps(c.moves, out)
    c = c.prev
  end
  return out
end
function vdump_path(c)
  if c == nil then return end
  if not c.dir then
    assert(not c.moves)
    assert(not c.prev)
    return
  end
  Real_print('p'..c.dir)
  local c2 = c.moves
  while c2 do
    if c2.dir then
      Real_print('m'..c2.dir)
    end
    c2 = c2.prev
  end
  vdump_path(c.prev)
end
end
function dump_path(c)
  if c == nil then return end
  if not c.dir then
    assert(not c.moves)
    assert(not c.prev)
    io.stdout:write('\n')
    return
  end
  local c2 = c.moves
  while c2 do
    if c2.dir then
    end
    c2 = c2.prev
  end
  dump_path(c.prev)
      io.stdout:write('m'..c2.dir..' ')
  io.stdout:write('p'..c.dir..' ')
function is_assumed_empty(level, x,y, empty, occupied)
        table.insert(cands, {x=x-1, y=y, dir='left', prev=cand, path_length=p+1})
        table.insert(cands, {x=x+1, y=y, dir='right', prev=cand, path_length=p+1})
        table.insert(cands, {x=x, y=y-1, dir='up', prev=cand, path_length=p+1})
        table.insert(cands, {x=x, y=y+1, dir='down', prev=cand, path_length=p+1})
      if is_assumed_empty(level, x,y, empty_cell, occupied_cell) then
    local x,y, p = cand.x, cand.y, cand.path_length
  table.insert(cands, {x=src.x, y=src.y, path_length=0})
--?   Real_print('find', src.x, src.y, '-', dst.x, dst.y, '-', empty_cell.x, empty_cell.y, '-', occupied_cell.x, occupied_cell.y)
function find_assumed_empty_path_to_empty_cell(level, src, dst, empty_cell, occupied_cell)
  if not is_assumed_empty(level, dst.x, dst.y, empty_cell, occupied_cell) then
    return
  end
function draw_crate_to_move()
  if crate_to_move == nil then return end
  color(1,0,0)
  local x,y = crate_to_move.x, crate_to_move.y
  rect('line', left+(x-1)*side, top+(y-1)*side, side, side)
end
-- moving player without moving any crates
function find_empty_path(level, src, dst)
  if not is_empty(level, dst.x, dst.y) then
    return
  end
-- moving crate without moving any other crates
function find_path_for_crate(level, player, crate, dst)
  local done = initialize_array(false, lh, lw)
  local cands = {}
  table.insert(cands, {crate={x=crate.x, y=crate.y}, player={x=player.x, y=player.y}, path_length=0})
--?   io.stdout:write('---\n')
  while #cands > 0 do
    if c.x == dst.x and c.y == dst.y then return cand end
    if c.y >= 1 and c.y <= lh and c.x >= 1 and c.x <= lw and not done[c.y][c.x] then
      done[c.y][c.x] = true
      local curr = level[c.y][c.x]
        -- try to push crate left, by first getting to the right of it
        if moves or (p.x == c.x+1 and p.y == c.y) then
          -- after the push, both player and crate have moved
        end
        -- try to push crate right
        if moves or (p.x == c.x-1 and p.y == c.y) then
        end
        -- try to push crate up
        if moves or (p.x == c.x and p.y == c.y+1) then
        end
        -- try to push crate down
        if moves or (p.x == c.x and p.y == c.y-1) then
        end
      end end end end
          table.insert(cands, {player={x=c.x, y=c.y}, crate={x=c.x, y=c.y+1}, dir='down', moves=moves, prev=cand, path_length=cand.path_length+moves.path_length})
        moves = find_assumed_empty_path_to_empty_cell(level, p, {x=c.x, y=c.y-1}, crate, c)
          table.insert(cands, {player={x=c.x, y=c.y}, crate={x=c.x, y=c.y-1}, dir='up', moves=moves, prev=cand, path_length=cand.path_length+moves.path_length})
        local moves = find_assumed_empty_path_to_empty_cell(level, p, {x=c.x, y=c.y+1}, crate, c)
          table.insert(cands, {player={x=c.x, y=c.y}, crate={x=c.x+1, y=c.y}, dir='right', moves=moves, prev=cand, path_length=cand.path_length+moves.path_length})
        moves = find_assumed_empty_path_to_empty_cell(level, p, {x=c.x-1, y=c.y}, crate, c)
          table.insert(cands, {player={x=c.x, y=c.y}, crate={x=c.x-1, y=c.y}, dir='left', moves=moves, prev=cand, path_length=cand.path_length+moves.path_length})
        local moves = find_assumed_empty_path_to_empty_cell(level, p, {x=c.x+1, y=c.y}, --[[empty]] crate, --[[occupied]] c)
      if curr ~= CELL_WALL and (curr ~= CELL_CRATE or (c.y == crate.y and c.x == crate.x)) and (curr ~= CELL_CRATE_ON_TARGET or (c.y == crate.y and c.x == crate.x)) then
    local min_index = shortest_path(cands)
    local cand = table.remove(cands, min_index)
    local p, c = cand.player, cand.crate
--?     i = i+1
--?     io.stdout:write(tostring(i)..' '..tostring(crate.x)..','..tostring(crate.y)..' '..tostring(crate.id)..' '..tostring(p.x)..','..tostring(p.y)..' '..tostring(c.x)..','..tostring(c.y)..' ')
--?     dump_path(cand)
--?   local i=0

File addition: move_to_empty (----------)

[6.1]

-- moving player without moving any crates
function draw_crate_to_move()
  if crate_to_move == nil then return end
  color(1,0,0)
  local x,y = crate_to_move.x, crate_to_move.y
  rect('line', left+(x-1)*side, top+(y-1)*side, side, side)
end
function car.update()
  if next_pending_move and Current_time >= next_pending_move then
    local dir = table.remove(pending_moves)
    move(dir, --[[add to undo]] false)
    if #pending_moves > 0 then
      next_pending_move = Current_time + 0.1
    end
  end
end
function make_all_pending_moves()
  while #pending_moves > 0 do
    local dir = table.remove(pending_moves)
    move(dir, --[[add to undo]] false)
  end
end
function plan_move_to_empty_space(y, x)
  local path = find_empty_path(level_state, player, {y=y, x=x})
  if path == nil then return end
  pending_moves = unwind_steps(path, {})
  local src = level_state[player.y][player.x]
  local dest = level_state[y][x]
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=x, y=y, cell=dest}}
  table.insert(undo_history, u)  -- add to undo without making move yet
  next_pending_move = Current_time
end
function find_empty_path(level, src, dst)
  if not is_empty(level, dst.x, dst.y) then
    return
  end
  local done = initialize_array(false, lh, lw)
  local cands = {}
  table.insert(cands, {x=src.x, y=src.y})
  while #cands > 0 do
    local cand = table.remove(cands, 1)
    local x,y = cand.x, cand.y
    if x == dst.x and y == dst.y then return cand end
    if y >= 1 and y <= lh and x >= 1 and x <= lw and not done[y][x] then
      done[y][x] = true
      local curr = level[y][x]
      if curr ~= CELL_WALL and curr ~= CELL_CRATE and curr ~= CELL_CRATE_ON_TARGET then
        table.insert(cands, {x=x-1, y=y, dir='left', prev=cand})
        table.insert(cands, {x=x+1, y=y, dir='right', prev=cand})
        table.insert(cands, {x=x, y=y-1, dir='up', prev=cand})
        table.insert(cands, {x=x, y=y+1, dir='down', prev=cand})
      end end end end
function is_empty(level, x,y)
  local curr = level[y][x]
  return curr ~= CELL_WALL and curr ~= CELL_CRATE and curr ~= CELL_CRATE_ON_TARGET
end
function unwind_path(c)
  local result = {}
  while c do
    table.insert(result, {x=c.x, y=c.y})
    c = c.prev
  end
  return result
end
function unwind_steps(c, out)
  -- insert steps in reverse order
  while c do
    table.insert(out, c.dir)
    c = c.prev
  end
  return out
end
function initialize_array(val, dim, ...)
  local result = {}
  local other_dims = {...}
  if #other_dims == 0 then
    for i=1,dim do
      table.insert(result, val)
    end
  else
    for i=1,dim do
      table.insert(result, initialize_array(val, ...))
    end
  end
  return result
end
function dump_path(c)
  if c == nil then return end
  if not c.dir then
    assert(not c.moves)
    assert(not c.prev)
    io.stdout:write('\n')
    return
  end
  io.stdout:write('p'..c.dir..' ')
  local c2 = c.moves
  while c2 do
    if c2.dir then
      io.stdout:write('m'..c2.dir..' ')
    end
    c2 = c2.prev
  end
  dump_path(c.prev)
end

File addition: move_crate (----------)

[6.1]

-- moving crate without moving any other crates
function plan_move_crate(y, x)
  local path = find_path_for_crate(level_state, player, crate_to_move, {y=y, x=x})
  if path == nil then return end
--?   Real_print('--')
--?   vdump_path(path)
  pending_moves = unwind_steps_to_move_crate(path, {})
  for i=#pending_moves,1,-1 do print(pending_moves[i]) end
  local src = level_state[player.y][player.x]
  local crate_cell = level_state[crate_to_move.y][crate_to_move.x]
  local dest = level_state[y][x]
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=crate_to_move.x, y=crate_to_move.y, cell=crate_cell},
    {x=x, y=y, cell=dest}}
  print('player initial', player.x, player.y, src)
  print('crate initial', crate_to_move.x, crate_to_move.y, crate_cell)
  print('crate final', x, y, dest)
  -- we also need to save the initial state of the final position of the player
  local fpy,fpx = compute_cell(y,x, opposite_dir(pending_moves[1]))
  print('player final', fpx, fpy, level_state[fpy][fpx])
  table.insert(u, {x=fpx, y=fpy, cell=level_state[fpy][fpx]})
  table.insert(undo_history, u)  -- add to undo without making move yet
  next_pending_move = Current_time
end
function find_path_for_crate(level, player, crate, dst)
  local done = initialize_array(false, lh, lw)
  local cands = {}
--?   local i=0
  table.insert(cands, {crate={x=crate.x, y=crate.y}, player={x=player.x, y=player.y}, path_length=0})
--?   io.stdout:write('---\n')
  while #cands > 0 do
    local min_index = shortest_path(cands)
    local cand = table.remove(cands, min_index)
    local p, c = cand.player, cand.crate
--?     i = i+1
--?     io.stdout:write(tostring(i)..' '..tostring(crate.x)..','..tostring(crate.y)..' '..tostring(crate.id)..' '..tostring(p.x)..','..tostring(p.y)..' '..tostring(c.x)..','..tostring(c.y)..' ')
--?     dump_path(cand)
    if c.x == dst.x and c.y == dst.y then return cand end
    if c.y >= 1 and c.y <= lh and c.x >= 1 and c.x <= lw and not done[c.y][c.x] then
      done[c.y][c.x] = true
      local curr = level[c.y][c.x]
      if curr ~= CELL_WALL and (curr ~= CELL_CRATE or (c.y == crate.y and c.x == crate.x)) and (curr ~= CELL_CRATE_ON_TARGET or (c.y == crate.y and c.x == crate.x)) then
        -- try to push crate left, by first getting to the right of it
        local moves = find_assumed_empty_path_to_empty_cell(level, p, {x=c.x+1, y=c.y}, --[[empty]] crate, --[[occupied]] c)
        if moves or (p.x == c.x+1 and p.y == c.y) then
          -- after the push, both player and crate have moved
          table.insert(cands, {player={x=c.x, y=c.y}, crate={x=c.x-1, y=c.y}, dir='left', moves=moves, prev=cand, path_length=cand.path_length+moves.path_length})
        end
        -- try to push crate right
        moves = find_assumed_empty_path_to_empty_cell(level, p, {x=c.x-1, y=c.y}, crate, c)
        if moves or (p.x == c.x-1 and p.y == c.y) then
          table.insert(cands, {player={x=c.x, y=c.y}, crate={x=c.x+1, y=c.y}, dir='right', moves=moves, prev=cand, path_length=cand.path_length+moves.path_length})
        end
        -- try to push crate up
        local moves = find_assumed_empty_path_to_empty_cell(level, p, {x=c.x, y=c.y+1}, crate, c)
        if moves or (p.x == c.x and p.y == c.y+1) then
          table.insert(cands, {player={x=c.x, y=c.y}, crate={x=c.x, y=c.y-1}, dir='up', moves=moves, prev=cand, path_length=cand.path_length+moves.path_length})
        end
        -- try to push crate down
        moves = find_assumed_empty_path_to_empty_cell(level, p, {x=c.x, y=c.y-1}, crate, c)
        if moves or (p.x == c.x and p.y == c.y-1) then
          table.insert(cands, {player={x=c.x, y=c.y}, crate={x=c.x, y=c.y+1}, dir='down', moves=moves, prev=cand, path_length=cand.path_length+moves.path_length})
        end
      end end end end
-- like find_empty_path, but always allow going through empty_cell and never allow going through occupied_cell, regardless of what level says
function find_assumed_empty_path_to_empty_cell(level, src, dst, empty_cell, occupied_cell)
  if not is_assumed_empty(level, dst.x, dst.y, empty_cell, occupied_cell) then
    return
  end
  local done = initialize_array(false, lh, lw)
  local cands = {}
--?   Real_print('find', src.x, src.y, '-', dst.x, dst.y, '-', empty_cell.x, empty_cell.y, '-', occupied_cell.x, occupied_cell.y)
  table.insert(cands, {x=src.x, y=src.y, path_length=0})
  while #cands > 0 do
    local cand = table.remove(cands, 1)
    local x,y, p = cand.x, cand.y, cand.path_length
    if x == dst.x and y == dst.y then return cand end
    if y >= 1 and y <= lh and x >= 1 and x <= lw and not done[y][x] then
      done[y][x] = true
      if is_assumed_empty(level, x,y, empty_cell, occupied_cell) then
        table.insert(cands, {x=x-1, y=y, dir='left', prev=cand, path_length=p+1})
        table.insert(cands, {x=x+1, y=y, dir='right', prev=cand, path_length=p+1})
        table.insert(cands, {x=x, y=y-1, dir='up', prev=cand, path_length=p+1})
        table.insert(cands, {x=x, y=y+1, dir='down', prev=cand, path_length=p+1})
      end end end end
function is_assumed_empty(level, x,y, empty, occupied)
  if empty.y ~= occupied.y or empty.x ~= occupied.x then
    if x == empty.x and y == empty.y then
      return true
    end
  end
  if x == occupied.x and y == occupied.y then
    return false
  end
  return is_empty(level, x,y)
end
function unwind_steps_to_move_crate(c, out)
  -- insert steps in reverse order
  while c do
    table.insert(out, c.dir)
    unwind_steps(c.moves, out)
    c = c.prev
  end
  return out
end
function shortest_path(cands)
--?   Real_print('', #cands)
  local min, minscore = 1, cands[1].path_length
  for i=2,#cands do
    local iscore = cands[i].path_length
--?     Real_print('', i, iscore, '<=>', min,minscore)
    if iscore < minscore then
      min, minscore = i, iscore
    end
  end
  return min
end
function compute_cell(y, x, dir)
  if dir == 'up' then
    return y-1, x
  elseif dir == 'down' then
    return y+1, x
  elseif dir == 'left' then
    return y, x-1
  elseif dir == 'right' then
    return y, x+1
  end end
function opposite_dir(dir)
  if dir == 'up' then
    return 'down'
  elseif dir == 'down' then
    return 'up'
  elseif dir == 'left' then
    return 'right'
  elseif dir == 'right' then
    return 'left'
  end end

Deletion in screens/move at line 92 [12.1]

B:BD[12.3206] → [10.753:815]

∅:D[10.815] → [12.3238:3243]

B:BD[12.3238] → [12.3238:3243]

B:BD[12.3243] → [10.816:864]

B:BD[10.864] → [8.99:176]

∅:D[8.176] → [12.3349:3732]

B:BD[12.3349] → [12.3349:3732]

  if add_to_undo then
    table.insert(undo_history, u)
  end
end
function move_to_empty_space(y, x, add_to_undo)
  local path = unwind_path(find_empty_path(level_state, player, {y=y, x=x}))
  if #path == 0 then return end
  local src = level_state[player.y][player.x]
  local dest = level_state[y][x]
  if dest == CELL_WALL or dest == CELL_CRATE or dest == CELL_CRATE_ON_TARGET then
    return
  end
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=x, y=y, cell=dest}}
  move_player_to(y, x)
  remove_player_from(player.y, player.x)
  player.x, player.y = x, y

Deletion in screens/move at line 94 [12.1]

B:BD[10.921] → [10.921:972]

B:BD[10.972] → [8.177:241]

∅:D[8.241] → [10.1030:1376]

B:BD[10.1030] → [10.1030:1376]

B:BD[10.1376] → [13.4352:4499]

B:BD[13.4499] → [5.396:419]

∅:D[5.419] → [16.869:892]

B:BD[16.869] → [16.869:892]

∅:D[16.892] → [13.4499:5437]

B:BD[13.4499] → [13.4499:5437]

∅:D[13.5437] → [10.1376:1464]

B:BD[10.1376] → [10.1376:1464]

B:BD[10.1464] → [2.12:95]

∅:D[2.95] → [10.1464:1495]

B:BD[10.1464] → [10.1464:1495]

B:BD[10.1582] → [10.1582:1641]

∅:D[10.1641] → [12.3764:3769]

B:BD[12.3764] → [12.3764:3769]

B:BD[12.3769] → [10.1642:1789]

  end
end
function plan_move_to_empty_space(y, x)
  local path = find_empty_path(level_state, player, {y=y, x=x})
  if path == nil then return end
  pending_moves = unwind_steps(path, {})
  local src = level_state[player.y][player.x]
  local dest = level_state[y][x]
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=x, y=y, cell=dest}}
  table.insert(undo_history, u)  -- add to undo without making move yet
  next_pending_move = Current_time
end
function plan_move_crate(y, x)
  local path = find_path_for_crate(level_state, player, crate_to_move, {y=y, x=x})
  if path == nil then return end
--?   Real_print('--')
--?   vdump_path(path)
  pending_moves = unwind_steps_to_move_crate(path, {})
  for i=#pending_moves,1,-1 do print(pending_moves[i]) end
  local src = level_state[player.y][player.x]
  local crate_cell = level_state[crate_to_move.y][crate_to_move.x]
  local dest = level_state[y][x]
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=crate_to_move.x, y=crate_to_move.y, cell=crate_cell},
    {x=x, y=y, cell=dest}}
  print('player initial', player.x, player.y, src)
  print('crate initial', crate_to_move.x, crate_to_move.y, crate_cell)
  print('crate final', x, y, dest)
  -- we also need to save the initial state of the final position of the player
  local fpy,fpx = compute_cell(y,x, opposite_dir(pending_moves[1]))
  print('player final', fpx, fpy, level_state[fpy][fpx])
  table.insert(u, {x=fpx, y=fpy, cell=level_state[fpy][fpx]})
  table.insert(undo_history, u)  -- add to undo without making move yet
  next_pending_move = Current_time
end
function car.update()
  if next_pending_move and Current_time >= next_pending_move then
    local dir = table.remove(pending_moves)
    move(dir, --[[add to undo]] false)
    if #pending_moves > 0 then
      next_pending_move = Current_time + 0.1
    end
  end
end
function make_all_pending_moves()
  while #pending_moves > 0 do
    local dir = table.remove(pending_moves)
    move(dir, --[[add to undo]] false)

Deletion in screens/move at line 155 [12.1]

B:BD[12.4963] → [13.5438:5877]


function compute_cell(y, x, dir)
  if dir == 'up' then
    return y-1, x
  elseif dir == 'down' then
    return y+1, x
  elseif dir == 'left' then
    return y, x-1
  elseif dir == 'right' then
    return y, x+1
  end end
function opposite_dir(dir)
  if dir == 'up' then
    return 'down'
  elseif dir == 'down' then
    return 'up'
  elseif dir == 'left' then
    return 'right'
  elseif dir == 'right' then
    return 'left'
  end end