mirror/aseprite
1
0
Fork 0
mirror of https://github.com/aseprite/aseprite.git synced 2025-03-30 04:20:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update tilemap tests with recent changes in the impl

Browse Source
This commit is contained in:
David Capello 2020-10-30 16:36:49 -03:00
parent 475b81b78c
commit e3a2403501
1 changed files with 161 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

318
scripts/tilemap.lua
View File

@ -13,8 +13,8 @@ local rgba = app.pixelColor.rgba
-- Check constants
assert(TilemapMode.PIXELS == 0)
assert(TilemapMode.TILES == 1)
assert(TilesetMode.MANUAL == 0)
assert(TilesetMode.AUTO == 1)
assert(TilesetMode.AUTO == 0)
assert(TilesetMode.MANUAL == 1)
assert(TilesetMode.STACK == 2)
----------------------------------------------------------------------
@ -56,15 +56,15 @@ do
assert(spr.tilesets[1] == tilemapLay.tileset)
local tileset = tilemapLay.tileset
assert(#tileset == 1) -- one tile
assert(#tileset == 2) -- empty tile + our tile
tilemapCel.position = Point(2, 2)
assert(tilemapCel.bounds == Rectangle(2, 2, 16, 16))
assert(#tileset == 1)
assert(#tileset == 2)
assert(tilemapCel.image.width == 1)
assert(tilemapCel.image.height == 1)
assert(tilemapCel.image:getPixel(0, 0) == 0)
assert(tilemapCel.image:getPixel(0, 0) == 1)
----------------------------------------------------------------------
-- Draw a second pixel with locked mode (new tiles are not generated)
@ -78,7 +78,7 @@ do
points={ Point(0, 0) }}
assert(tilemapCel.bounds == Rectangle(2, 2, 16, 16))
assert(#tileset == 1)
assert(#tileset == 2)
----------------------------------------------------------------------
-- Draw pixels generating new tiles
@ -93,11 +93,11 @@ do
assert(tilemapCel.bounds == Rectangle(-14, -14, 32, 32))
assert(#tileset == 3)
assert(not tileset:getTile(0):isEmpty())
assert(tileset:getTile(0):isEmpty())
assert(not tileset:getTile(1):isEmpty())
assert(tileset:getTile(2):isEmpty())
expect_img(tilemapCel.image, { 1, 2,
2, 0 })
assert(not tileset:getTile(2):isEmpty())
expect_img(tilemapCel.image, { 2, 0,
0, 1 })
app.useTool{
tool='pencil',
@ -109,9 +109,9 @@ do
assert(tilemapCel.bounds == Rectangle(-14, -14, 48, 48))
assert(#tilemapLay.tileset == 4)
assert(not tileset:getTile(3):isEmpty())
expect_img(tilemapCel.image, { 1, 2, 2,
2, 0, 2,
2, 2, 3 })
expect_img(tilemapCel.image, { 2, 0, 0,
0, 1, 0,
0, 0, 3 })
end
----------------------------------------------------------------------
@ -140,67 +140,64 @@ do
local cel = tm.cels[1]
expect_eq(2, #ts)
expect_img(cel.image, { 0,1,1,1,
1,0,1,1,
1,1,0,1,
1,1,1,0 })
expect_img(cel.image, { 1,0,0,0,
0,1,0,0,
0,0,1,0,
0,0,0,1 })
app.useTool{
tool='pencil',
color=Color{ index=0 },
color=Color{ index=1 },
tilemapMode=TilemapMode.TILES,
tilesetMode=TilesetMode.STACK,
points={ Point(0, 16) }} -- y=16 is the first pixel of 3rd row of tiles
cel = tm.cels[1]
expect_img(cel.image, { 0,1,1,1,
1,0,1,1,
0,1,0,1,
1,1,1,0 })
expect_img(cel.image, { 1,0,0,0,
0,1,0,0,
1,0,1,0,
0,0,0,1 })
app.useTool{
tool='pencil',
color=Color{ index=0 },
color=Color{ index=1 },
tilemapMode=TilemapMode.TILES,
tilesetMode=TilesetMode.STACK,
points={ Point(0, 0), Point(16, 0) }} -- x=16 is the first pixel of 3rd column of tiles
cel = tm.cels[1]
expect_img(cel.image, { 0,0,0,1,
1,0,1,1,
0,1,0,1,
1,1,1,0 })
expect_img(cel.image, { 1,1,1,0,
0,1,0,0,
1,0,1,0,
0,0,0,1 })
-- Move layer origin to 10, 8
cel.position = { 10, 8 }
expect_eq(Point{ 10, 8 }, cel.position)
app.useTool{
tool='pencil',
color=Color{ index=1 },
color=Color{ index=0 },
tilemapMode=TilemapMode.TILES,
tilesetMode=TilesetMode.STACK,
points={ { 10, 8 }, { 18, 16 } }} -- {10,8} is the first existent tile in the tilemap
-- these are tiles 2,1 and 3,2
cel = tm.cels[1]
expect_img(cel.image, { 1,0,0,1,
1,1,1,1,
0,1,0,1,
1,1,1,0 })
expect_img(cel.image, { 0,1,1,0,
0,0,0,0,
1,0,1,0,
0,0,0,1 })
app.useTool{
tool='pencil',
color=Color{ index=0 },
color=Color{ index=1 },
tilemapMode=TilemapMode.TILES,
tilesetMode=TilesetMode.STACK,
points={ Point(1, 7), Point(2, 8) }} -- Tile 0,0 and 1,1
-- TODO add a constant for the empty tile
local e = tonumber("ffffffff", 16) -- empty tile (0xffffffff)
cel = tm.cels[1]
expect_img(cel.image, { 0,e, e,e,e,e,
e,0, 1,0,0,1,
e,e, 1,1,1,1,
e,e, 0,1,0,1,
e,e, 1,1,1,0 })
expect_img(cel.image, { 1,0, 0,0,0,0,
0,1, 0,1,1,0,
0,0, 0,0,0,0,
0,0, 1,0,1,0,
0,0, 0,0,0,1 })
end
@ -223,7 +220,7 @@ do
assert(tilemapCel.bounds == Rectangle(0, 0, 16, 16))
local tileset = tilemapLay.tileset
assert(#tileset == 1) -- one tile
assert(#tileset == 2) -- empty tile + our tile
tilemapCel.position = Point(-1, -1)
assert(tilemapCel.bounds == Rectangle(-1, -1, 16, 16))
@ -236,9 +233,9 @@ do
points={ Point(0, 0) }}
assert(tilemapCel.bounds == Rectangle(-1, -1, 16, 16))
assert(#tileset == 2)
assert(#tileset == 3)
local img = tileset:getTile(1)
local img = tileset:getTile(2)
assert(img:getPixel(0, 0) == rgba(0, 255, 0, 255))
assert(img:getPixel(1, 0) == rgba(0, 0, 0, 0))
@ -298,142 +295,149 @@ do
points={ Point(0, 0), Point(31, 31) }}
local ts = tilemapLay.tileset
assert(#ts == 4)
assert(#ts == 5)
local imgs = { ts:getTile(0),
ts:getTile(1),
local imgs = { ts:getTile(1),
ts:getTile(2),
ts:getTile(3) }
ts:getTile(3),
ts:getTile(4) }
-- No op = move tile 0 before the tile 0, result=0,1,2,3
app.range.tiles = { 0 }
app.command.MoveTiles{ before=0 }
expect_eq(imgs[0+1], ts:getTile(0))
expect_eq(imgs[1+1], ts:getTile(1))
expect_eq(imgs[2+1], ts:getTile(2))
expect_eq(imgs[3+1], ts:getTile(3))
expect_eq(1, #app.range.tiles)
expect_eq(0, app.range.tiles[1])
-- Move tile 1 before tile 0, result=1,0,2,3
-- No op = move tile 1 before the tile 1, result=0,1,2,3,4
app.range.tiles = { 1 }
app.command.MoveTiles{ before=0 }
expect_eq(imgs[1+1], ts:getTile(0))
expect_eq(imgs[0+1], ts:getTile(1))
expect_eq(imgs[2+1], ts:getTile(2))
expect_eq(imgs[3+1], ts:getTile(3))
app.command.MoveTiles{ before=1 }
expect_eq(imgs[1], ts:getTile(1))
expect_eq(imgs[2], ts:getTile(2))
expect_eq(imgs[3], ts:getTile(3))
expect_eq(imgs[4], ts:getTile(4))
expect_eq(1, #app.range.tiles)
expect_eq(0, app.range.tiles[1])
app.undo()
-- Move tiles 0 and 1 before 3, result=2,0,1,3
app.range.tiles = { 0, 1 }
app.command.MoveTiles({ before=3 })
expect_eq(imgs[2+1], ts:getTile(0))
expect_eq(imgs[0+1], ts:getTile(1))
expect_eq(imgs[1+1], ts:getTile(2))
expect_eq(imgs[3+1], ts:getTile(3))
expect_eq(2, #app.range.tiles)
expect_eq(1, app.range.tiles[1])
expect_eq(2, app.range.tiles[2])
app.undo()
-- Move tiles 0 and 2 before 2, result=1,0,2,3
app.range.tiles = { 0, 2 }
app.command.MoveTiles({ before=2 })
expect_eq(imgs[1+1], ts:getTile(0))
expect_eq(imgs[0+1], ts:getTile(1))
expect_eq(imgs[2+1], ts:getTile(2))
expect_eq(imgs[3+1], ts:getTile(3))
expect_eq(2, #app.range.tiles)
-- Move tile 2 before tile 1, result=0,2,1,3,4
app.range.tiles = { 2 }
app.command.MoveTiles{ before=1 }
expect_eq(imgs[2], ts:getTile(1))
expect_eq(imgs[1], ts:getTile(2))
expect_eq(imgs[3], ts:getTile(3))
expect_eq(imgs[4], ts:getTile(4))
expect_eq(1, #app.range.tiles)
expect_eq(1, app.range.tiles[1])
expect_eq(2, app.range.tiles[2])
app.undo()
-- Copy tiles 0 before 0, result=0,0,1,2,3
app.range.tiles = { 0 }
app.command.CopyTiles({ before=0 })
expect_eq(1, #app.range.tiles)
expect_eq(0, app.range.tiles[1])
expect_eq(5, #ts)
assert(ts:getTile(0):isEqual(imgs[0+1]))
assert(ts:getTile(1):isEqual(imgs[0+1]))
assert(ts:getTile(2):isEqual(imgs[1+1]))
assert(ts:getTile(3):isEqual(imgs[2+1]))
assert(ts:getTile(4):isEqual(imgs[3+1]))
-- Move tiles 1 and 2 before 4, result=0,3,1,2,4
app.range.tiles = { 1, 2 }
app.command.MoveTiles({ before=4 })
expect_eq(imgs[3], ts:getTile(1))
expect_eq(imgs[1], ts:getTile(2))
expect_eq(imgs[2], ts:getTile(3))
expect_eq(imgs[4], ts:getTile(4))
expect_eq(2, #app.range.tiles)
expect_eq(2, app.range.tiles[1])
expect_eq(3, app.range.tiles[2])
app.undo()
-- Copy tiles 0 before 3, result=0,1,2,0,3
app.range.tiles = { 0 }
app.command.CopyTiles({ before=3 })
expect_eq(1, #app.range.tiles)
expect_eq(3, app.range.tiles[1])
expect_eq(5, #ts)
assert(ts:getTile(0):isEqual(imgs[0+1]))
assert(ts:getTile(1):isEqual(imgs[1+1]))
assert(ts:getTile(2):isEqual(imgs[2+1]))
assert(ts:getTile(3):isEqual(imgs[0+1]))
assert(ts:getTile(4):isEqual(imgs[3+1]))
app.undo()
-- Copy tiles 0, 1, and 3, before 4, result=0,1,2,3,0,1,3
app.range.tiles = { 0, 1, 3 }
app.command.CopyTiles({ before=4 })
assert(ts:getTile(0):isEqual(imgs[0+1]))
assert(ts:getTile(1):isEqual(imgs[1+1]))
assert(ts:getTile(2):isEqual(imgs[2+1]))
assert(ts:getTile(3):isEqual(imgs[3+1]))
assert(ts:getTile(4):isEqual(imgs[0+1]))
assert(ts:getTile(5):isEqual(imgs[1+1]))
assert(ts:getTile(6):isEqual(imgs[3+1]))
app.undo()
-- Copy tiles 1, and 3, before 0, result=1,3,0,1,2,3
-- Move tiles 1 and 3 before 3, result=0,2,1,3,4
app.range.tiles = { 1, 3 }
app.command.CopyTiles({ before=0 })
assert(ts:getTile(0):isEqual(imgs[1+1]))
assert(ts:getTile(1):isEqual(imgs[3+1]))
assert(ts:getTile(2):isEqual(imgs[0+1]))
assert(ts:getTile(3):isEqual(imgs[1+1]))
assert(ts:getTile(4):isEqual(imgs[2+1]))
assert(ts:getTile(5):isEqual(imgs[3+1]))
app.command.MoveTiles({ before=3 })
expect_eq(imgs[2], ts:getTile(1))
expect_eq(imgs[1], ts:getTile(2))
expect_eq(imgs[3], ts:getTile(3))
expect_eq(imgs[4], ts:getTile(4))
expect_eq(2, #app.range.tiles)
expect_eq(2, app.range.tiles[1])
expect_eq(3, app.range.tiles[2])
app.undo()
-- Copy tiles 0, and 3, before 7, result=0,1,2,3,0,3
app.range.tiles = { 0, 3 }
-- Copy tiles 1 before 1, result=0,1,1,2,3,4
app.range.tiles = { 1 }
app.command.CopyTiles({ before=1 })
expect_eq(1, #app.range.tiles)
expect_eq(1, app.range.tiles[1])
expect_eq(6, #ts)
assert(ts:getTile(0):isEmpty())
assert(ts:getTile(1):isEqual(imgs[1]))
assert(ts:getTile(2):isEqual(imgs[1]))
assert(ts:getTile(3):isEqual(imgs[2]))
assert(ts:getTile(4):isEqual(imgs[3]))
assert(ts:getTile(5):isEqual(imgs[4]))
app.undo()
-- Copy tiles 1 before 4, result=0,1,2,3,1,4
app.range.tiles = { 1 }
app.command.CopyTiles({ before=4 })
assert(ts:getTile(0):isEqual(imgs[0+1]))
assert(ts:getTile(1):isEqual(imgs[1+1]))
assert(ts:getTile(2):isEqual(imgs[2+1]))
assert(ts:getTile(3):isEqual(imgs[3+1]))
assert(ts:getTile(4):isEqual(imgs[0+1]))
assert(ts:getTile(5):isEqual(imgs[3+1]))
expect_eq(1, #app.range.tiles)
expect_eq(4, app.range.tiles[1])
expect_eq(6, #ts)
assert(ts:getTile(0):isEmpty())
assert(ts:getTile(1):isEqual(imgs[1]))
assert(ts:getTile(2):isEqual(imgs[2]))
assert(ts:getTile(3):isEqual(imgs[3]))
assert(ts:getTile(4):isEqual(imgs[1]))
assert(ts:getTile(5):isEqual(imgs[4]))
app.undo()
-- Copy tiles 0, and 3, before 7, result=0,1,2,3,-,0,3
app.range.tiles = { 0, 3 }
-- Copy tiles 1, 2, and 4, before 5, result=0,1,2,3,4,1,2,4
app.range.tiles = { 1, 2, 4 }
app.command.CopyTiles({ before=5 })
assert(ts:getTile(0):isEqual(imgs[0+1]))
assert(ts:getTile(1):isEqual(imgs[1+1]))
assert(ts:getTile(2):isEqual(imgs[2+1]))
assert(ts:getTile(3):isEqual(imgs[3+1]))
assert(ts:getTile(4):isPlain())
assert(ts:getTile(5):isEqual(imgs[0+1]))
assert(ts:getTile(6):isEqual(imgs[3+1]))
assert(ts:getTile(0):isEmpty())
assert(ts:getTile(1):isEqual(imgs[1]))
assert(ts:getTile(2):isEqual(imgs[2]))
assert(ts:getTile(3):isEqual(imgs[3]))
assert(ts:getTile(4):isEqual(imgs[4]))
assert(ts:getTile(5):isEqual(imgs[1]))
assert(ts:getTile(6):isEqual(imgs[2]))
assert(ts:getTile(7):isEqual(imgs[4]))
app.undo()
-- Copy tiles 2, and 3, before 7, result=0,1,2,3,-,-,-,2,3
app.range.tiles = { 2, 3 }
app.command.CopyTiles({ before=7 })
assert(ts:getTile(0):isEqual(imgs[0+1]))
assert(ts:getTile(1):isEqual(imgs[1+1]))
assert(ts:getTile(2):isEqual(imgs[2+1]))
assert(ts:getTile(3):isEqual(imgs[3+1]))
assert(ts:getTile(4):isPlain())
-- Copy tiles 2, and 4, before 1, result=0,2,4,1,2,3,4
app.range.tiles = { 2, 4 }
app.command.CopyTiles({ before=1 })
assert(ts:getTile(0):isEmpty())
assert(ts:getTile(1):isEqual(imgs[2]))
assert(ts:getTile(2):isEqual(imgs[4]))
assert(ts:getTile(3):isEqual(imgs[1]))
assert(ts:getTile(4):isEqual(imgs[2]))
assert(ts:getTile(5):isEqual(imgs[3]))
assert(ts:getTile(6):isEqual(imgs[4]))
app.undo()
-- Copy tiles 1, and 4, before 5, result=0,1,2,3,4,1,4
app.range.tiles = { 1, 4 }
app.command.CopyTiles({ before=5 })
assert(ts:getTile(0):isEmpty())
assert(ts:getTile(1):isEqual(imgs[1]))
assert(ts:getTile(2):isEqual(imgs[2]))
assert(ts:getTile(3):isEqual(imgs[3]))
assert(ts:getTile(4):isEqual(imgs[4]))
assert(ts:getTile(5):isEqual(imgs[1]))
assert(ts:getTile(6):isEqual(imgs[4]))
app.undo()
-- Copy tiles 1, and 4, before 6, result=0,1,2,3,4,-,1,4
app.range.tiles = { 1, 4 }
app.command.CopyTiles({ before=6 })
assert(ts:getTile(0):isEmpty())
assert(ts:getTile(1):isEqual(imgs[1]))
assert(ts:getTile(2):isEqual(imgs[2]))
assert(ts:getTile(3):isEqual(imgs[3]))
assert(ts:getTile(4):isEqual(imgs[4]))
assert(ts:getTile(5):isEmpty())
assert(ts:getTile(6):isEqual(imgs[1]))
assert(ts:getTile(7):isEqual(imgs[4]))
app.undo()
-- Copy tiles 3, and 4, before 8, result=0,1,2,3,4,-,-,-,3,4
app.range.tiles = { 3, 4 }
app.command.CopyTiles({ before=8 })
assert(ts:getTile(0):isEmpty())
assert(ts:getTile(1):isEqual(imgs[1]))
assert(ts:getTile(2):isEqual(imgs[2]))
assert(ts:getTile(3):isEqual(imgs[3]))
assert(ts:getTile(4):isEqual(imgs[4]))
assert(ts:getTile(5):isPlain())
assert(ts:getTile(6):isPlain())
assert(ts:getTile(7):isEqual(imgs[2+1]))
assert(ts:getTile(8):isEqual(imgs[3+1]))
assert(ts:getTile(7):isPlain())
assert(ts:getTile(8):isEqual(imgs[3]))
assert(ts:getTile(9):isEqual(imgs[4]))
app.undo()
end