I’m working on an update to Froggy Went A Hoppin’ and want to make some things generic that I hardcoded in the first version. One of those is being able to see the “neighbors” of a given lily pad in the pond. For example, in the following level map:

1,1,0,4,1,0,1,1,0,4,1,

1,2,1,2,0,1,1,2,1,2,0,

1,1,0,1,1,0,1,1,0,1,1,

2,0,1,1,0,2,2,0,1,1,0,

1,1,0,4,1,0,1,1,0,4,1,

1,2,1,2,0,1,1,2,1,2,0,

1,1,0,1,1,0,1,1,0,1,1

…I wanted to know which lily pads were next to (left, right, up, down, and diagonal) any specified lily pad. *(Note: I don’t want to know the values of those locations, I want to know the indexes into that grid — if I have that I can get the value, set it, etc.)*

I ended up with this code:

`--==============================================================`

-- pass in a lily pad number and get back a

-- table containing all the neighbors for

-- that lily pad.

```
```local numCols = 11

local numRows = 7

local function getNeighbors(padNum)

local neighbors = {}

local function inLeftColumn()

return ((padNum-1) % numCols) == 0

end

local function inRightColumn()

return (padNum % numCols) == 0

end

local inLeft = inLeftColumn()

local inRight = inRightColumn()

-- number above, above left/right

if padNum > numCols then

neighbors[#neighbors+1] = padNum - numCols

if not inLeft then

neighbors[#neighbors+1] = padNum - numCols - 1

end

if not inRight then

neighbors[#neighbors+1] = padNum - numCols + 1

end

end

` -- number below & below left/right`

if padNum <= (numCols * (numRows-1)) then
neighbors[#neighbors+1] = padNum + numCols -- number below
if not inLeft then
neighbors[#neighbors+1] = padNum + numCols - 1
end
if not inRight then
neighbors[#neighbors+1] = padNum + numCols + 1
end
end
-- number to right
if not inRight then
neighbors[#neighbors+1] = padNum + 1
end
-- number to left
if not inLeft then
neighbors[#neighbors+1] = padNum - 1
end
return neighbors
end

If I pass a 1 into that function (using a grid that's 11 wide by 7 tall) I get back a table containing 2, 12, and 13 -- the neighbors for that location. If I pass in 12, I get back a table containing 1, 2, 13, 23, 24.

I was hoping to find a "clever" way to find the neighbors, but that's what I've ended up with for now. I've only tested it with a couple different sized grids, but I think it should work for just about any.

Thanks to Mark in beautiful West Wellow — he pointed me in the right direction for the modulo thing I was thinking of. So the two functions toward the top now look like this:

So much nicer. Just the one line in each function.

Just for the sake of history, this is what they looked like before Mark stepped in.

It worked, but wasn’t optimal. 😉