akkartik/sokoban.love - Change AHABKD5VEK5RSTM3CME4XJAHCVTHYV2D2WAWUGSJ6PBUCUI7CB3AC

reorg files again to stay within 150 lines

Created by akkartik on March 13, 2024

AHABKD5VEK5RSTM3CME4XJAHCVTHYV2D2WAWUGSJ6PBUCUI7CB3AC

Dependencies

In channels

main

Change contents

File deletion: sokoban

BF:BFD[9.1] → [10.5467:5498]

BF:BFD[10.5498] → [10.1:1]

B:BD[10.1] → [10.2:234]

B:BD[10.234] → [11.0:32]

∅:D[11.32] → [10.266:286]

B:BD[10.266] → [10.266:286]

B:BD[10.286] → [11.33:66]

∅:D[11.66] → [10.319:460]

B:BD[10.319] → [10.319:460]

B:BD[10.460] → [11.67:102]

∅:D[11.102] → [10.488:626]

B:BD[10.488] → [10.488:626]

B:BD[10.626] → [11.103:251]

∅:D[11.251] → [10.664:1834]

B:BD[10.664] → [10.664:1834]

B:BD[10.1834] → [11.252:276]

∅:D[11.276] → [12.11:43]

B:BD[10.1834] → [12.11:43]

∅:D[12.43] → [10.1851:2590]

B:BD[10.1851] → [10.1851:2590]

B:BD[10.2590] → [11.277:301]

∅:D[11.301] → [12.44:76]

B:BD[10.2590] → [12.44:76]

∅:D[12.76] → [10.2607:3348]

B:BD[10.2607] → [10.2607:3348]

B:BD[10.3348] → [11.302:326]

∅:D[11.326] → [12.77:109]

B:BD[10.3348] → [12.77:109]

∅:D[12.109] → [10.3365:4137]

B:BD[10.3365] → [10.3365:4137]

B:BD[10.4137] → [11.327:351]

∅:D[11.351] → [12.110:142]

B:BD[10.4137] → [12.110:142]

∅:D[12.142] → [10.4154:4159]

B:BD[10.4154] → [10.4154:4159]

∅:D[8.526] → [10.4159:5145]

B:BD[10.4159] → [10.4159:5145]

∅:D[12.191] → [10.5145:5264]

B:BD[10.5145] → [10.5145:5264]

B:BD[10.5264] → [3.11:48]

∅:D[3.48] → [10.5283:5466]

B:BD[10.5283] → [10.5283:5466]

B:BD[10.5145] → [12.143:191]

B:BD[10.4159] → [8.0:526]

-- game logic
-- sprites
CELL_PLAYER = 0
CELL_PLAYER_ON_TARGET = 1
CELL_CRATE = 2
CELL_CRATE_ON_TARGET = 3
CELL_TARGET = 4
CELL_WALL = 5
CELL_GRASS = 6  -- vestigial?
CELL_VACANT = 7
function load_level(level)
  local result = {}
  for _,row in ipairs(level) do
    local dest = {}
    for _,pair in ipairs(row) do
      table.insert(dest, floor(pair/16))
      table.insert(dest, pair%16)
    end
    table.insert(result, dest)
  end
  return result
end
function player_state(level_state)
  for r,row in ipairs(level_state) do
    for c,cell in ipairs(row) do
      if cell == CELL_PLAYER or cell == CELL_PLAYER_ON_TARGET then
        return {x=c, y=r}
      end end end end
function draw_level_state()
  for r,row in ipairs(level_state) do
    for c,cell in ipairs(row) do
      draw_sprite(cell, left+(c-1)*side, top+(r-1)*side)
    end end end
function draw_sprite(cell, x,y)
  if cell >= CELL_VACANT then
    color(0,0,0)
    rect('fill', x,y, side,side)
    return
  end
  local sprite = sprites[cell+1]
  for r,row in ipairs(sprite) do
    for c,clr in ipairs(row) do
      color(unpack(clr))
      rect('fill', x+(c-1)*pxside, y+(r-1)*pxside, pxside, pxside)
    end end end
function move_down()
  if player.y >= #level_state then return end
  local src = level_state[player.y][player.x]
  local dest = level_state[player.y+1][player.x]
  if dest == CELL_WALL then return end
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=player.x, y=player.y+1, cell=dest}}
  if dest == CELL_CRATE or dest == CELL_CRATE_ON_TARGET then
    if player.y >= #level_state-1 then return end
    local dest2 = level_state[player.y+2][player.x]
    if dest2 ~= CELL_VACANT and dest2 ~= CELL_TARGET then return end
    table.insert(u, {x=player.x, y=player.y+2, cell=dest2})
    move_crate_to(player.y+2, player.x)
    remove_crate_from(player.y+1, player.x)
  end
  move_player_to(player.y+1, player.x)
  remove_player_from(player.y, player.x)
  player.y = player.y+1
  table.insert(undo_history, u)
end
function move_up()
  if player.y <= 1 then return end
  local src = level_state[player.y][player.x]
  local dest = level_state[player.y-1][player.x]
  if dest == CELL_WALL then return end
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=player.x, y=player.y-1, cell=dest}}
  if dest == CELL_CRATE or dest == CELL_CRATE_ON_TARGET then
    if player.y <= 2 then return end
    local dest2 = level_state[player.y-2][player.x]
    if dest2 ~= CELL_VACANT and dest2 ~= CELL_TARGET then return end
    table.insert(u, {x=player.x, y=player.y-2, cell=dest2})
    move_crate_to(player.y-2, player.x)
    remove_crate_from(player.y-1, player.x)
  end
  move_player_to(player.y-1, player.x)
  remove_player_from(player.y, player.x)
  player.y = player.y-1
  table.insert(undo_history, u)
end
function move_left()
  if player.x <= 1 then return end
  local src = level_state[player.y][player.x]
  local dest = level_state[player.y][player.x-1]
  if dest == CELL_WALL then return end
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=player.x-1, y=player.y, cell=dest}}
  if dest == CELL_CRATE or dest == CELL_CRATE_ON_TARGET then
    if player.x <= 2 then return end
    local dest2 = level_state[player.y][player.x-2]
    if dest2 ~= CELL_VACANT and dest2 ~= CELL_TARGET then return end
    table.insert(u, {x=player.x-2, y=player.y, cell=dest2})
    move_crate_to(player.y, player.x-2)
    remove_crate_from(player.y, player.x-1)
  end
  move_player_to(player.y, player.x-1)
  remove_player_from(player.y, player.x)
  player.x = player.x-1
  table.insert(undo_history, u)
end
function move_right()
  if player.x >= #level_state[1] then return end
  local src = level_state[player.y][player.x]
  local dest = level_state[player.y][player.x+1]
  if dest == CELL_WALL then return end
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=player.x+1, y=player.y, cell=dest}}
  if dest == CELL_CRATE or dest == CELL_CRATE_ON_TARGET then
    if player.x >= #level_state[1]-1 then return end
    local dest2 = level_state[player.y][player.x+2]
    if dest2 ~= CELL_VACANT and dest2 ~= CELL_TARGET then return end
    table.insert(u, {x=player.x+2, y=player.y, cell=dest2})
    move_crate_to(player.y, player.x+2)
    remove_crate_from(player.y, player.x+1)
  end
  move_player_to(player.y, player.x+1)
  remove_player_from(player.y, player.x)
  player.x = player.x+1
  table.insert(undo_history, u)
end
function move_player_to(y, x)
  local old = level_state[y][x]
  if old == CELL_VACANT then
    level_state[y][x] = CELL_PLAYER
  elseif old == CELL_TARGET then
    level_state[y][x] = CELL_PLAYER_ON_TARGET
  else
    error('cannot move player to '..old)
  end
end
function remove_player_from(y, x)
  local src = level_state[y][x]
  if src == CELL_PLAYER then
    level_state[y][x] = CELL_VACANT
  elseif src == CELL_PLAYER_ON_TARGET then
    level_state[y][x] = CELL_TARGET
  end
end
function move_crate_to(y, x)
  local old = level_state[y][x]
  if old == CELL_VACANT then
    level_state[y][x] = CELL_CRATE
  elseif old == CELL_TARGET then
    level_state[y][x] = CELL_CRATE_ON_TARGET
  else
    error('cannot move crate to '..old)
  end
end
function remove_crate_from(y, x)
  local src = level_state[y][x]
  if src == CELL_CRATE then
    level_state[y][x] = CELL_VACANT
  elseif src == CELL_CRATE_ON_TARGET then
    level_state[y][x] = CELL_TARGET
  end
end
function undo_move()
  if undo_state == nil then return end
  for _,sq in ipairs(undo_state) do
    level_state[sq.y][sq.x] = sq.cell
  end
  player = player_state(level_state)
end
function any_state_in_level(needle)
  for r,row in ipairs(level_state) do
    for c,cell in ipairs(row) do
      if cell == needle then
        return true
      end end end end
  local undo_state = table.remove(undo_history)
function move_to_empty_space(y, x)
  local path = unwind_path(find_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
  table.insert(undo_history, u)
end

Insertion in screens/solve at line 1 [13.30]
[13.30]
[13.31]
```
-- simple solver to remove some drudgery
```

File addition: move (----------)

[9.1]

function move_down()
  if player.y >= #level_state then return end
  local src = level_state[player.y][player.x]
  local dest = level_state[player.y+1][player.x]
  if dest == CELL_WALL then return end
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=player.x, y=player.y+1, cell=dest}}
  if dest == CELL_CRATE or dest == CELL_CRATE_ON_TARGET then
    if player.y >= #level_state-1 then return end
    local dest2 = level_state[player.y+2][player.x]
    if dest2 ~= CELL_VACANT and dest2 ~= CELL_TARGET then return end
    table.insert(u, {x=player.x, y=player.y+2, cell=dest2})
    move_crate_to(player.y+2, player.x)
    remove_crate_from(player.y+1, player.x)
  end
  move_player_to(player.y+1, player.x)
  remove_player_from(player.y, player.x)
  player.y = player.y+1
  table.insert(undo_history, u)
end
function move_up()
  if player.y <= 1 then return end
  local src = level_state[player.y][player.x]
  local dest = level_state[player.y-1][player.x]
  if dest == CELL_WALL then return end
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=player.x, y=player.y-1, cell=dest}}
  if dest == CELL_CRATE or dest == CELL_CRATE_ON_TARGET then
    if player.y <= 2 then return end
    local dest2 = level_state[player.y-2][player.x]
    if dest2 ~= CELL_VACANT and dest2 ~= CELL_TARGET then return end
    table.insert(u, {x=player.x, y=player.y-2, cell=dest2})
    move_crate_to(player.y-2, player.x)
    remove_crate_from(player.y-1, player.x)
  end
  move_player_to(player.y-1, player.x)
  remove_player_from(player.y, player.x)
  player.y = player.y-1
  table.insert(undo_history, u)
end
function move_left()
  if player.x <= 1 then return end
  local src = level_state[player.y][player.x]
  local dest = level_state[player.y][player.x-1]
  if dest == CELL_WALL then return end
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=player.x-1, y=player.y, cell=dest}}
  if dest == CELL_CRATE or dest == CELL_CRATE_ON_TARGET then
    if player.x <= 2 then return end
    local dest2 = level_state[player.y][player.x-2]
    if dest2 ~= CELL_VACANT and dest2 ~= CELL_TARGET then return end
    table.insert(u, {x=player.x-2, y=player.y, cell=dest2})
    move_crate_to(player.y, player.x-2)
    remove_crate_from(player.y, player.x-1)
  end
  move_player_to(player.y, player.x-1)
  remove_player_from(player.y, player.x)
  player.x = player.x-1
  table.insert(undo_history, u)
end
function move_right()
  if player.x >= #level_state[1] then return end
  local src = level_state[player.y][player.x]
  local dest = level_state[player.y][player.x+1]
  if dest == CELL_WALL then return end
  local u = {
    {x=player.x, y=player.y, cell=src},
    {x=player.x+1, y=player.y, cell=dest}}
  if dest == CELL_CRATE or dest == CELL_CRATE_ON_TARGET then
    if player.x >= #level_state[1]-1 then return end
    local dest2 = level_state[player.y][player.x+2]
    if dest2 ~= CELL_VACANT and dest2 ~= CELL_TARGET then return end
    table.insert(u, {x=player.x+2, y=player.y, cell=dest2})
    move_crate_to(player.y, player.x+2)
    remove_crate_from(player.y, player.x+1)
  end
  move_player_to(player.y, player.x+1)
  remove_player_from(player.y, player.x)
  player.x = player.x+1
  table.insert(undo_history, u)
end
function move_to_empty_space(y, x)
  local path = unwind_path(find_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
  table.insert(undo_history, u)
end
function move_player_to(y, x)
  local old = level_state[y][x]
  if old == CELL_VACANT then
    level_state[y][x] = CELL_PLAYER
  elseif old == CELL_TARGET then
    level_state[y][x] = CELL_PLAYER_ON_TARGET
  else
    error('cannot move player to '..old)
  end
end
function remove_player_from(y, x)
  local src = level_state[y][x]
  if src == CELL_PLAYER then
    level_state[y][x] = CELL_VACANT
  elseif src == CELL_PLAYER_ON_TARGET then
    level_state[y][x] = CELL_TARGET
  end
end
function move_crate_to(y, x)
  local old = level_state[y][x]
  if old == CELL_VACANT then
    level_state[y][x] = CELL_CRATE
  elseif old == CELL_TARGET then
    level_state[y][x] = CELL_CRATE_ON_TARGET
  else
    error('cannot move crate to '..old)
  end
end
function remove_crate_from(y, x)
  local src = level_state[y][x]
  if src == CELL_CRATE then
    level_state[y][x] = CELL_VACANT
  elseif src == CELL_CRATE_ON_TARGET then
    level_state[y][x] = CELL_TARGET
  end
end
function undo_move()
  local undo_state = table.remove(undo_history)
  if undo_state == nil then return end
  for _,sq in ipairs(undo_state) do
    level_state[sq.y][sq.x] = sq.cell
  end
  player = player_state(level_state)
end

Insertion in screens/main at line 13 [9.6482]

[12.285]

[9.6807]


-- sprites
CELL_PLAYER = 0
CELL_PLAYER_ON_TARGET = 1
CELL_CRATE = 2
CELL_CRATE_ON_TARGET = 3
CELL_TARGET = 4
CELL_WALL = 5
CELL_GRASS = 6  -- vestigial?
CELL_VACANT = 7

Deletion in screens/main at line 28 [9.6482]
∅:D[14.175] → [9.7356:7361]
∅:D[13.1429] → [9.7356:7361]
∅:D[15.528130] → [9.7356:7361]
B:BD[9.7356] → [9.7356:7361]
B:BD[9.7361] → [15.528131:528314]
∅:D[16.40] → [15.528383:528404]
∅:D[17.69] → [15.528383:528404]
∅:D[18.71] → [15.528383:528404]
B:BD[15.528383] → [15.528383:528404]
B:BD[15.528404] → [19.100:117]
B:BD[19.117] → [6.12:34]
∅:D[6.34] → [20.0:19]
∅:D[19.117] → [20.0:19]
B:BD[15.528404] → [20.0:19]
∅:D[20.19] → [15.528404:528422]
∅:D[13.1448] → [15.528404:528422]
B:BD[15.528404] → [15.528404:528422]
B:BD[15.528422] → [10.528486:528589]
∅:D[10.528589] → [17.70:176]
B:BD[15.528422] → [17.70:176]
B:BD[17.176] → [5.0:67]
∅:D[5.67] → [17.238:302]
B:BD[17.238] → [17.238:302]
B:BD[9.7588] → [9.7588:7593]
B:BD[20.25] → [20.25:51]
B:BD[20.51] → [10.528590:528635]
∅:D[10.528635] → [20.95:112]
B:BD[20.95] → [20.95:112]
B:BD[20.112] → [18.130:177]
∅:D[18.177] → [20.154:160]
B:BD[20.154] → [20.154:160]
```
end
function car.draw()
  -- the sprites are pretty dark; a dark background accentuates contrast between their colors
  g.setBackgroundColor(0.4,0.4, 0.4)
  ui_state.button_handlers = {}
  draw_level_state()
  draw_buttons()
  draw_level_number()
  draw_win_state()
  draw_hud()
end
-- some constants for draw_level_number
level_color = {0.8,0.8,0.8}
level_width = App.width('MMM')+10
function draw_level_number()
  local lx, ly = left-level_width, top+10
  if Safe_height > Safe_width then
    lx, ly = (Safe_width - level_width)/2, top-side-Line_height-10
  end
  color(unpack(level_color))
  g.print(curr_level, lx,ly)
end
function draw_win_state()
  if not any_state_in_level(CELL_CRATE) then
    color(0,1,0)
    g.print('success!', left-2*side, top+side)
  end
```

Deletion in screens/main at line 29 [9.6482]

∅:D[15.528975] → [9.8151:8152]

B:BD[9.8151] → [9.8151:8152]

B:BD[9.8152] → [19.118:175]

B:BD[19.175] → [14.176:250]

∅:D[14.250] → [19.234:266]

B:BD[19.234] → [19.234:266]

B:BD[19.266] → [14.251:445]

∅:D[14.445] → [19.468:498]

B:BD[19.468] → [19.468:498]

B:BD[19.498] → [14.446:567]


function draw_buttons()
  local bg = {r=0.4,g=0.2,b=0.4}
  button(ui_state, 'left', {x=0, y=bside, w=bside, h=Safe_height-bside*2,
    bg=bg, onpress1=move_left})
  button(ui_state, 'right', {x=Safe_width-bside, y=bside, w=bside, h=Safe_height-bside*2,
    bg=bg, onpress1=move_right})
  button(ui_state, 'up', {x=bside, y=0, w=Safe_width-bside*2, h=bside,
    bg=bg, onpress1=move_up})
  button(ui_state, 'down', {x=bside, y=Safe_height-bside, w=Safe_width-bside*2, h=bside,
    bg=bg, onpress1=move_down})

Replacement in screens/main at line 30 [9.6482]

B:BD[21.72] → [21.72:94]

B:BD[21.94] → [4.0:48]

∅:D[4.48] → [21.158:422]

B:BD[21.158] → [21.158:422]

B:BD[21.422] → [5.68:87]

∅:D[5.87] → [21.444:906]

B:BD[21.444] → [21.444:906]

B:BD[21.906] → [22.85:109]

B:BD[22.109] → [12.286:314]

∅:D[12.314] → [22.130:165]

B:BD[22.130] → [22.130:165]

B:BD[22.165] → [2.12:141]

  -- level navigation
  local ns, ps = tostring('>>'), tostring('<<')
  local nw, pw = App.width(ns)+10, App.width(ps)+10
  local h = Line_height+10
  local nx,px, y
  if Safe_width > Safe_height then
    px, nx = left-side-pw-10, left+lw*side+side+10
    y = top + lh*side/2
  else
    px, nx = left+side+10, left+lw*side-side-nw-10
    y = top-side-h
  end
  if curr_level > 1 then
    button(ui_state, 'previous level', {x=px, y=y, w=pw, h=h,
      bg=bg, onpress1=previous_level,
      icon=function(p)
        color(unpack(level_color))
        g.print(ps, p.x+5, p.y+5)
      end,
    })
  end
  if curr_level < #levels then
    button(ui_state, 'next level', {x=nx, y=y, w=nw, h=h,
      bg=bg, onpress1=next_level,
      icon=function(p)
        color(unpack(level_color))
        g.print(ns, p.x+5, p.y+5)
      end,
    })
  end
  if #undo_history > 0 then
    local w = App.width('undo')+10
    local ux, uy = left+lw*side+10, top+10
    if Safe_width < Safe_height then
      ux, uy = left+lw*side-w-10, top+lh*side+10

[21.72]

[2.141]

function load_level(level)
  local result = {}
  for _,row in ipairs(level) do
    local dest = {}
    for _,pair in ipairs(row) do
      table.insert(dest, floor(pair/16))
      table.insert(dest, pair%16)

Replacement in screens/main at line 38 [9.6482]

B:BD[2.149] → [2.149:214]

∅:D[2.214] → [22.237:352]

B:BD[22.237] → [22.237:352]

∅:D[22.352] → [21.906:930]

B:BD[21.906] → [21.906:930]

B:BD[21.930] → [23.0:200]

B:BD[23.200] → [7.0:315]

∅:D[7.315] → [23.266:339]

B:BD[23.266] → [23.266:339]

B:BD[23.339] → [7.316:474]

    button(ui_state, 'undo', {x=ux, y=uy, w=w, h=Line_height+10,
      bg=bg, onpress1=undo_move,
      icon=function(p)
        color(0,0,0)
        g.print('undo', p.x+5, p.y+5)
      end,
    })
  end
end
-- ensure we can fit the above layout into the available window area
-- leave 6 tiles worth of margin on all sides for the nav buttons
function car.resize()
  local w,h = Safe_width, Safe_height
  local w1, w2 = landscape_button_offsets()
  local h1, h2 = portrait_button_offsets()
  if Safe_width > Safe_height then
    side = min((w-w1-w2)/(1+lw+1+6), h/(lh+6))  -- leave 1 side between board and buttons
  else
    side = min(w/(lw+6), (h-h1-h2)/(1+lh+1+6))  -- leave 1 side between board and buttons
  end
  pxside = side/num_tile_px
  left = (w-side*lw)/2
  top = (h-side*lh)/2
  if Safe_width > Safe_height then
    bside = min((w-w1-w2-side*(1+lw+1))/2, (h-side*lh)/2)
  else
    bside = min((h-h1-h2-side*(1+lh+1))/2, (w-side*lw)/2)

[2.149]

[7.474]

    table.insert(result, dest)

Replacement in screens/main at line 40 [9.6482]

B:BD[7.480] → [7.480:907]

end
-- space needed for buttons to the left and right
function landscape_button_offsets()
  local ns, ps = tostring('>>'), tostring('<<')
  local nw, pw = App.width(ns)+10, App.width(ps)+10
  return 10+pw+10, 10+nw+10
  -- we assume the level name and undo button will be within this width
end
-- space needed for buttons to the top and bottom
function portrait_button_offsets()
  return 10+Line_height+10, 10+Line_height+10

[7.480]

[19.641]

  return result

Insertion in screens/main at line 87 [9.6482]

[21.1259]


function player_state(level_state)
  for r,row in ipairs(level_state) do
    for c,cell in ipairs(row) do
      if cell == CELL_PLAYER or cell == CELL_PLAYER_ON_TARGET then
        return {x=c, y=r}
      end end end end

File addition: layout (----------)