Lua fixed tile movement issues

Question

I'm recreating Mrs Pacman using Lua, and just recently learned a series of tiles are used for collision and movement; I'm trying to recreate that. Here's the tile-map:

nodemap = {
    {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
    {1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1},
    {1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,1,0,1,1},
    {1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,1,0,1,1},
    {1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1},
    {1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,0,1,1,1,1},
    {1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,0,1,1,1,1},
    {1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,0,1,1,1,1},
    {1,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1},
    {1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1},
    {1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1},
    {1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},
    {1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1},
    {1,1,1,1,0,1,1,1,1,1,0,1,0,0,0,0,0,0,1,0,1,1,1,1,1,0,1,1,1,1},
    {1,1,1,1,0,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1,1},
    {1,1,1,1,0,1,1,0,1,1,0,1,0,0,0,0,0,0,1,0,1,1,0,1,1,0,1,1,1,1},
    {1,1,1,1,0,1,1,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,0,1,1,0,1,1,1,1},
    {1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1},
    {1,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,1},
    {1,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,1},
    {1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1},
    {1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1},
    {1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1},
    {1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1},
    {1,1,0,1,1,1,1,0,1,1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,1,1,0,1,1},
    {1,1,0,1,1,1,1,0,1,1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,1,1,0,1,1},
    {1,1,0,1,1,1,1,0,1,1,0,0,0,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1,1},
    {1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,1,0,1,1},
    {1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,1,0,1,1},
    {1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1},
    {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
}

This creates the maze without error, but the issue I'm having is that Pacman moves smoothly across tiles, without jumping from tile, to tile, to tile... So I have this code to "smoothly" move Pacman:

-- Make Pacmans position consist of a single decimal (because over time a number of 1.899999994 will occur and that's ugly)
mrspacman.x = math.floor(mrspacman.x*10)/10
mrspacman.y = math.floor(mrspacman.y*10)/10

--If an arrowkey was pressed (Think of this as "A new direction was queued")
if (mrspacman.nextDirection) then

    -- If Pacman is in the center of a tile, then
    if (mrspacman.x == math.floor(mrspacman.x)) and (mrspacman.y == math.floor(mrspacman.y)) then

        -- If the tile in front of Pacman is empty, set direction to that
        if (nodemap[mrspacman.y-math2.sin(mrspacman.dir)][mrspacman.x+math2.cos(mrspacman.dir)]~=1) then
            mrspacman.dz = mrspacman.dir

            -- Disable this queue
            mrspacman.nextDirection = false
        end
    end
end

-- If Pacman is NOT in the center of a tile
if (mrspacman.x ~= math.floor(mrspacman.x)) or (mrspacman.y ~= math.floor(mrspacman.y)) then

    -- Constantly move forwards
    mrspacman.x = mrspacman.x + (math2.cos(mrspacman.dz)*mrspacman.speed)
    mrspacman.y = mrspacman.y - (math2.sin(mrspacman.dz)*mrspacman.speed)
else

    -- If the tile in front of Pacman is empty, move to that tile
    if (nodemap[mrspacman.y-math2.sin(mrspacman.dz)][mrspacman.x+math2.cos(mrspacman.dz)] ~= 1) then
        mrspacman.x = mrspacman.x + (math2.cos(mrspacman.dz)*mrspacman.speed)
        mrspacman.y = mrspacman.y - (math2.sin(mrspacman.dz)*mrspacman.speed)
    end
end

• mrspacman.dz = The angle being faced.

• mrspacman.dir = The recorded keypress.

• mrspacman.speed = .1 (Is a decimal to allow for the smooth movement).

Executing this code results in Pacman freezing when a backwards-key was pressed, and its position becoming messed up when rotating in a corner, going through walls... That can be seen here.

How can this be fixed?

UPDATE

I added a table named math2 consisting of the cos and sin fx's (Only will return the values for the 4 cardinal directions):

math2 = {
    cos = function(angle)
        vectors = {1,0,-1,0}
        return vectors[(angle/90)+1]
    end,

    sin = function(angle)
        vectors = {0,1,0,-1}
        return vectors[(angle/90)+1]
    end
}

Answer 1

So the question is quite broad one:

How can this be fixed? The answer is: by debugging your program.

The problem is quite vague and the test case in the video is quite big and unfocused. To understand what's going on you need to look in detail at least at some of the steps of the program. Namely, the problem is that mrspacman can go down through the wall, if tile to the left of the wall is empty. This hints that there might be some wrongness with the code that checks for wall presence.

The code in the question is not complete, so errors may originate from outside of it. Nevertheless, in the last hour I've put together a primitive framework to test the code from question. (it is listed at the end of the answer)

Having toyed around with the code, I now believe that the whole pacman was written not only without a single trigonometric function, but without floating point numbers at all.

The thing with float numbers is that they're ill suited for exact calculations. Some compilers and computing systems will even spit curses on you for doing that.

---

Before the edit, the code in question had expressions with sines and cosines:

math.floor(math.sin(mrspacman.dir*pi/180))

I've now evaluated it on my computer and indeed for values of dir that are 0, 90, 180, 270 it evaluates to 0, 1, 0, -1. But that is on 64bit machine. I'm not sure TI-Nspire can be trusted to yield same precision.

---

During my tests I've run into another problem with floats:

mrspacman.x = math.floor(mrspacman.x*10)/10

would introduce error in the decimal digit: for mrspacman.x equal to 4.3 it would eval to 4.2 causing the pacwoman to freeze. Strangely enough, when evaluated directly in the prompt, it would behave correctly. Anyways, the common implementation of that function adds some bias before flooring: math.floor(mrspacman.x*10+0.5)/10 .

---

Apart from that, there were minor hiccups with axes orientation, which were detected quickly thanks to all of the debug information dumped by framework.

And that's all. The code works (although, I'll just leave this here without more arguments). If the code still does not behave on your device, you'll need to look for problems elsewhere.

Debug code

I've left your variables global as they presumably were in your program and that probably doesn't matter in a single-file script. But in general it is a good practice to make any variable local unless there is a really good reason for otherwise.

nodemap = {--I've used small field for debugging
  {1,1,1,1,1,1,1},
  {1,0,0,0,0,0,1},
  {1,0,1,0,1,1,1},
  {1,0,0,0,1,1,1},
  {1,1,1,1,1,1,1},
}

mrspacman={dz=0,dir=false,x=2,y=2,speed=0.1,nextDirection=false}

local dlog=function(...)--debug function
  print(string.format(...))
end

math2 = {
    cos = function(angle)
        vectors = {1,0,-1,0}--this would be better of by being a local variable
        return vectors[(angle/90)+1]
    end,

    sin = function(angle)
        vectors = {0,1,0,-1}--this too
        return vectors[(angle/90)+1]
    end
}


local graphic_lines={}
for _,line in ipairs(nodemap) do
  local l=table.concat(line):gsub("0"," ")
  table.insert(graphic_lines,l)
end

local time_step=1
function draw()--quick and dirty output to terminal
  print(string.format("\nStep %i",time_step))
  time_step=time_step+1
  local x,y = mrspacman.x,mrspacman.y
  local px,py=math.floor(x+0.5),math.floor(y+0.5)
  for index,line in ipairs(graphic_lines) do
    if index~= py then 
      print(line) 
    else
      print( line:sub(1,px-1) .. "@" .. line:sub(px+1))
    end
  end
  print(string.format('Real position (x,y): (%f , %f)',x,y))
  print(string.format('Current direction: %i',mrspacman.dz))
  if mrspacman.nextDirection then
    print(string.format("Trying to turn at %i",mrspacman.dir or "error"))
  end
end


local inputs={--i've mixed up directions due to my renderer
  w=90,
  a=180,
  s=270,
  d=0,
}
local skips={['']=true,[' ']=true}

function input(macro_input)--read wasd from terminal
  print('your move')
  local key= (macro_input and macro_input()) or io.read();
  if skips[key] then return end
  local dir = inputs[key];
  if not dir then print('wrong key') return end
  mrspacman.dir = dir
  mrspacman.nextDirection=true
end

function sim_step()
dlog('"Smoothing" (%f,%f) through (%f,%f) to (%f,%f)',mrspacman.x,mrspacman.y,mrspacman.x*10,mrspacman.y*10,math.floor(mrspacman.x*10)/10,math.floor(mrspacman.y*10)/10)
dlog('"Fixing smoothing" (%f,%f) through (%f,%f) to (%f,%f)',mrspacman.x,mrspacman.y,(mrspacman.x+0.05)*10,(mrspacman.y+0.05)*10,math.floor((mrspacman.x+0.05)*10)/10,math.floor((mrspacman.y+0.05)*10)/10)

mrspacman.x = math.floor(mrspacman.x*10+.5)/10--these lines are different
mrspacman.y = math.floor(mrspacman.y*10+.5)/10--

--If an arrowkey was pressed (Think of this as "A new direction was queued")
if (mrspacman.nextDirection) then
    dlog("trying to turn")
    -- If Pacman is in the center of a tile, then
    if (mrspacman.x == math.floor(mrspacman.x)) and (mrspacman.y == math.floor(mrspacman.y)) then
        dlog("Pacman is in the center of a tile")
        -- If the tile in front of Pacman is empty, set direction to that
        dlog("lookup dy: %f dx: %f",-math2.sin(mrspacman.dir),math2.cos(mrspacman.dir))
        dlog("lookup y: %f x: %f",mrspacman.y-math2.sin(mrspacman.dir),mrspacman.x+math2.cos(mrspacman.dir))
        dlog(nodemap[mrspacman.y-math2.sin(mrspacman.dir)][mrspacman.x+math2.cos(mrspacman.dir)]==1 and "Its a wall" or "")
        if (nodemap[mrspacman.y-math2.sin(mrspacman.dir)][mrspacman.x+math2.cos(mrspacman.dir)]~=1) then
            dlog("turning")
            mrspacman.dz = mrspacman.dir

            -- Disable this queue
            mrspacman.nextDirection = false
          else
            dlog"not turning"
        end
    end
end

-- If Pacman is NOT in the center of a tile
if (mrspacman.x ~= math.floor(mrspacman.x)) or (mrspacman.y ~= math.floor(mrspacman.y)) then
    dlog("Pacman is NOT in the center of a tile, moving with no collision check")
    -- Constantly move forwards
    dlog("deltaX, deltaY : %f, %f",(math2.cos(mrspacman.dz)*mrspacman.speed),-(math2.sin(mrspacman.dz)*mrspacman.speed))
    dlog("before (%f, %f)",mrspacman.x,mrspacman.y)
    mrspacman.x = mrspacman.x + (math2.cos(mrspacman.dz)*mrspacman.speed)
    mrspacman.y = mrspacman.y - (math2.sin(mrspacman.dz)*mrspacman.speed)
    dlog("after (%f, %f)",mrspacman.x,mrspacman.y)
else
    dlog("moving with collision check")
    -- If the tile in front of Pacman is empty, move to that tile
    if (nodemap[mrspacman.y-math2.sin(mrspacman.dz)][mrspacman.x+math2.cos(mrspacman.dz)] ~= 1) then
        dlog("can move")
        mrspacman.x = mrspacman.x + (math2.cos(mrspacman.dz)*mrspacman.speed)
        mrspacman.y = mrspacman.y - (math2.sin(mrspacman.dz)*mrspacman.speed)
    else
        dlog("hit wall")
    end
end

end


local gen_macro = function(sequence)--function generating predefined set of keypresses
  sequence=sequence or ""
  local step=0
  return function()
    step=step+1
    if (step>sequence:len()) then return end--return to manual control
    return sequence:sub(step,step)
  end
end

local simple_macro= function() return gen_macro("wasd") end--simple sample, "--will do nothing
local horizontal_bend = function()--will bring pacman to bottom left
  local _x10=string.rep(" ",10);
  local sequence=_x10:rep(2).."s".._x10:rep(2).."a".._x10:rep(2)
  return gen_macro(sequence)
end

local angry_monkey=function(length)--gen random sequence of buttons
  length=length or 0
  local keys={"a","s","d","w"," "}
  local seq = {}
  for i=1,length do
    table.insert(seq,keys[math.random(#keys)])
  end
  return gen_macro(table.concat(seq))
end

local macro
--macro=simple_macro()
--macro=horizontal_bend()
--macro = angry_monkey(100)

--dlog=function() end --uncomment this to disable debug

while true do
  draw()
  input(macro)
  sim_step()
--  if time_step>10 then return end
end