🐳chore(工具): 调整docker 文件
parent
f2cbf8041b
commit
f782003d1e
@ -1,15 +0,0 @@
|
||||
kind: pipeline
|
||||
type: docker
|
||||
name: hello-world
|
||||
|
||||
trigger:
|
||||
branch:
|
||||
- master
|
||||
event:
|
||||
- push
|
||||
|
||||
steps:
|
||||
- name: say-hello
|
||||
image: busybox
|
||||
commands:
|
||||
- echo hello-world
|
||||
@ -1,95 +0,0 @@
|
||||
# drone-gitea-on-docker
|
||||
DroneCI and Gitea on Docker
|
||||
|
||||
## Usage
|
||||
|
||||
Set the following in your `boot.sh`:
|
||||
|
||||
```
|
||||
IP_ADDRESS=192.168.0.6 -> either reachable dns or ip address which will be your clone address and ui addresses.
|
||||
GITEA_ADMIN_USER="giteauser" -> will be the user you register with in drone
|
||||
```
|
||||
|
||||
Now boot the stack:
|
||||
|
||||
```
|
||||
$ bash boot.sh
|
||||
```
|
||||
|
||||
*Note*: Theres a [current issue](https://github.com/go-gitea/gitea/issues/7702) where webhooks get fired twice, if you see that just restart gitea with `docker restart gitea`.
|
||||
|
||||
- Head over to: `http://${IP_ADDRESS}:3000/user/settings/applications` and create a new OAuth2 Application and set the Redirect URI to `http://${IP_ADDRESS}:3001/login`
|
||||
|
||||
- Capture the client id and client secret and populate them in the `boot.sh` in `DRONE_GITEA_CLIENT_ID` and `DRONE_GITEA_CLIENT_SECRET` and run `bash boot.sh` again. This will give drone the correct credentials in order to authenticate with gitea.
|
||||
|
||||
- Now when you head over to `http://${IP_ADDRESS}:3001/` you will be asked to authorize the application and you should be able to access drone.
|
||||
|
||||
## Drone CLI
|
||||
|
||||
Install Drone CLI:
|
||||
- https://docs.drone.io/cli/install/
|
||||
|
||||
```
|
||||
$ curl -L https://github.com/drone/drone-cli/releases/latest/download/drone_darwin_amd64.tar.gz | tar zx
|
||||
$ sudo mv drone /usr/local/bin/drone
|
||||
$ chmod +x /usr/local/bin/drone
|
||||
```
|
||||
|
||||
Get your Drone Token:
|
||||
- http://${IP_ADDRESS}:3001/account
|
||||
|
||||
```
|
||||
$ export DRONE_SERVER=http://${IP_ADDRESS}:3001
|
||||
$ export DRONE_TOKEN=one-from-the-account-page
|
||||
drone info
|
||||
```
|
||||
|
||||
## Build your first pipeline
|
||||
|
||||
Create a test repo in gitea:
|
||||
|
||||
|
||||
|
||||
Commit a `.drone.yml` file for drone:
|
||||
|
||||
```
|
||||
$ cat .drone.yml
|
||||
kind: pipeline
|
||||
type: docker
|
||||
name: hello-world
|
||||
|
||||
trigger:
|
||||
branch:
|
||||
- master
|
||||
event:
|
||||
- push
|
||||
|
||||
steps:
|
||||
- name: say-hello
|
||||
image: busybox
|
||||
commands:
|
||||
- echo hello-world
|
||||
```
|
||||
|
||||
Head over to drone and sync your repositories:
|
||||
|
||||
|
||||
|
||||
Activate your repository:
|
||||
|
||||
|
||||
|
||||
Push a commit to master and see your pipeline running:
|
||||
|
||||
|
||||
|
||||
## More Examples
|
||||
|
||||
- https://github.com/ruanbekker/drone-ci-testing
|
||||
- https://github.com/ruanbekker/drone-demo-python-flask
|
||||
- https://github.com/ruanbekker/drone-with-go
|
||||
- https://github.com/ruanbekker/demo-drone-mongodb-tests
|
||||
- https://github.com/ruanbekker/drone-multi-pipeline
|
||||
- https://github.com/ruanbekker/docker-jekyll-drone
|
||||
- [Localstack with Drone and Gitea](https://gist.github.com/ruanbekker/84cb9f0c2a21434ca8381a0c74842d84)
|
||||
- [Drone, Minio, Gitea, Sqlite on Docker Compose](https://gist.github.com/ruanbekker/3847bbf1b961efc568b93ccbf5c6f9f6)
|
||||
@ -1,19 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
export HOSTNAME=$(hostname)
|
||||
export DRONE_VERSION=1.10.1
|
||||
export DRONE_RUNNER_VERSION=1.6.3
|
||||
export GITEA_VERSION=1.13
|
||||
export IP_ADDRESS=127.0.0.1
|
||||
export MINIO_ACCESS_KEY="EXAMPLEKEY"
|
||||
export MINIO_SECRET_KEY="EXAMPLESECRET"
|
||||
export GITEA_ADMIN_USER="example"
|
||||
export DRONE_RPC_SECRET="$(echo ${HOSTNAME} | openssl dgst -md5 -hex)"
|
||||
export DRONE_USER_CREATE="username:${GITEA_ADMIN_USER},machine:false,admin:true,token:${DRONE_RPC_SECRET}"
|
||||
export DRONE_GITEA_CLIENT_ID=""
|
||||
export DRONE_GITEA_CLIENT_SECRET=""
|
||||
docker-compose up -d
|
||||
|
||||
echo ""
|
||||
echo "Gitea: http://${IP_ADDRESS}:3000/"
|
||||
echo "Drone: http://${IP_ADDRESS}:3001/"
|
||||
@ -1,83 +0,0 @@
|
||||
version: '3.6'
|
||||
|
||||
services:
|
||||
gitea:
|
||||
container_name: gitea
|
||||
image: gitea/gitea:${GITEA_VERSION:-1.10.6}
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
# https://docs.gitea.io/en-us/install-with-docker/#environments-variables
|
||||
- APP_NAME="Gitea"
|
||||
- USER_UID=1000
|
||||
- USER_GID=1000
|
||||
- RUN_MODE=prod
|
||||
- DOMAIN=${IP_ADDRESS}
|
||||
- SSH_DOMAIN=${IP_ADDRESS}
|
||||
- HTTP_PORT=3000
|
||||
- ROOT_URL=http://${IP_ADDRESS}:3000
|
||||
- SSH_PORT=222
|
||||
- SSH_LISTEN_PORT=22
|
||||
- DB_TYPE=sqlite3
|
||||
ports:
|
||||
- "3000:3000"
|
||||
- "222:22"
|
||||
networks:
|
||||
- cicd_net
|
||||
volumes:
|
||||
- ./gitea:/data
|
||||
|
||||
drone:
|
||||
container_name: drone
|
||||
image: drone/drone:${DRONE_VERSION:-1.6.4}
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
- gitea
|
||||
environment:
|
||||
# https://docs.drone.io/server/provider/gitea/
|
||||
- DRONE_DATABASE_DRIVER=sqlite3
|
||||
- DRONE_DATABASE_DATASOURCE=/data/database.sqlite
|
||||
- DRONE_GITEA_SERVER=http://${IP_ADDRESS}:3000/
|
||||
- DRONE_GIT_ALWAYS_AUTH=false
|
||||
- DRONE_RPC_SECRET=${DRONE_RPC_SECRET}
|
||||
- DRONE_SERVER_PROTO=http
|
||||
- DRONE_SERVER_HOST=${IP_ADDRESS}:3001
|
||||
- DRONE_TLS_AUTOCERT=false
|
||||
- DRONE_USER_CREATE=${DRONE_USER_CREATE}
|
||||
- DRONE_GITEA_CLIENT_ID=${DRONE_GITEA_CLIENT_ID}
|
||||
- DRONE_GITEA_CLIENT_SECRET=${DRONE_GITEA_CLIENT_SECRET}
|
||||
ports:
|
||||
- "3001:80"
|
||||
- "9001:9000"
|
||||
networks:
|
||||
- cicd_net
|
||||
volumes:
|
||||
- /var/run/docker.sock:/var/run/docker.sock
|
||||
- ./drone:/data
|
||||
|
||||
drone-runner:
|
||||
container_name: drone-runner
|
||||
image: drone/drone-runner-docker:${DRONE_RUNNER_VERSION:-1}
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
- drone
|
||||
environment:
|
||||
# https://docs.drone.io/runner/docker/installation/linux/
|
||||
# https://docs.drone.io/server/metrics/
|
||||
- DRONE_RPC_PROTO=http
|
||||
- DRONE_RPC_HOST=drone
|
||||
- DRONE_RPC_SECRET=${DRONE_RPC_SECRET}
|
||||
- DRONE_RUNNER_NAME="${HOSTNAME}-runner"
|
||||
- DRONE_RUNNER_CAPACITY=2
|
||||
- DRONE_RUNNER_NETWORKS=cicd_net
|
||||
- DRONE_DEBUG=false
|
||||
- DRONE_TRACE=false
|
||||
ports:
|
||||
- "3002:3000"
|
||||
networks:
|
||||
- cicd_net
|
||||
volumes:
|
||||
- /var/run/docker.sock:/var/run/docker.sock
|
||||
|
||||
networks:
|
||||
cicd_net:
|
||||
name: cicd_net
|
||||
@ -0,0 +1,824 @@
|
||||
local bump = {
|
||||
_VERSION = 'bump v3.1.7',
|
||||
_URL = 'https://github.com/kikito/bump.lua',
|
||||
_DESCRIPTION = 'A collision detection library for Lua',
|
||||
}
|
||||
|
||||
------------------------------------------
|
||||
-- Auxiliary functions
|
||||
------------------------------------------
|
||||
local DELTA = 1e-10 -- floating-point margin of error
|
||||
|
||||
local abs, floor, ceil, min, max = math.abs, math.floor, math.ceil, math.min, math.max
|
||||
|
||||
local function sign(x)
|
||||
if x > 0 then
|
||||
return 1
|
||||
end
|
||||
if x == 0 then
|
||||
return 0
|
||||
end
|
||||
return -1
|
||||
end
|
||||
|
||||
local function nearest(x, a, b)
|
||||
if abs(a - x) < abs(b - x) then
|
||||
return a
|
||||
else
|
||||
return b
|
||||
end
|
||||
end
|
||||
|
||||
local function assertType(desiredType, value, name)
|
||||
if type(value) ~= desiredType then
|
||||
error(name .. ' must be a ' .. desiredType .. ', but was ' .. tostring(value) .. '(a ' .. type(value) .. ')')
|
||||
end
|
||||
end
|
||||
|
||||
local function assertIsPositiveNumber(value, name)
|
||||
if type(value) ~= 'number' or value <= 0 then
|
||||
error(name .. ' must be a positive integer, but was ' .. tostring(value) .. '(' .. type(value) .. ')')
|
||||
end
|
||||
end
|
||||
|
||||
local function assertIsRect(x, y, w, h)
|
||||
assertType('number', x, 'x')
|
||||
assertType('number', y, 'y')
|
||||
assertIsPositiveNumber(w, 'w')
|
||||
assertIsPositiveNumber(h, 'h')
|
||||
end
|
||||
|
||||
local defaultFilter = function()
|
||||
return 'slide'
|
||||
end
|
||||
|
||||
------------------------------------------
|
||||
-- Rectangle functions
|
||||
------------------------------------------
|
||||
|
||||
local function rect_getNearestCorner(x, y, w, h, px, py)
|
||||
return nearest(px, x, x + w), nearest(py, y, y + h)
|
||||
end
|
||||
|
||||
-- This is a generalized implementation of the liang-barsky algorithm, which also returns
|
||||
-- the normals of the sides where the segment intersects.
|
||||
-- Returns nil if the segment never touches the rect
|
||||
-- Notice that normals are only guaranteed to be accurate when initially ti1, ti2 == -math.huge, math.huge
|
||||
local function rect_getSegmentIntersectionIndices(x, y, w, h, x1, y1, x2, y2, ti1, ti2)
|
||||
ti1, ti2 = ti1 or 0, ti2 or 1
|
||||
local dx, dy = x2 - x1, y2 - y1
|
||||
local nx, ny
|
||||
local nx1, ny1, nx2, ny2 = 0, 0, 0, 0
|
||||
local p, q, r
|
||||
|
||||
for side = 1, 4 do
|
||||
if side == 1 then
|
||||
nx, ny, p, q = -1, 0, -dx, x1 - x -- left
|
||||
elseif side == 2 then
|
||||
nx, ny, p, q = 1, 0, dx, x + w - x1 -- right
|
||||
elseif side == 3 then
|
||||
nx, ny, p, q = 0, -1, -dy, y1 - y -- top
|
||||
else
|
||||
nx, ny, p, q = 0, 1, dy, y + h - y1 -- bottom
|
||||
end
|
||||
|
||||
if p == 0 then
|
||||
if q <= 0 then
|
||||
return nil
|
||||
end
|
||||
else
|
||||
r = q / p
|
||||
if p < 0 then
|
||||
if r > ti2 then
|
||||
return nil
|
||||
elseif r > ti1 then
|
||||
ti1, nx1, ny1 = r, nx, ny
|
||||
end
|
||||
else -- p > 0
|
||||
if r < ti1 then
|
||||
return nil
|
||||
elseif r < ti2 then
|
||||
ti2, nx2, ny2 = r, nx, ny
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return ti1, ti2, nx1, ny1, nx2, ny2
|
||||
end
|
||||
|
||||
-- Calculates the minkowsky difference between 2 rects, which is another rect
|
||||
local function rect_getDiff(x1, y1, w1, h1, x2, y2, w2, h2)
|
||||
return x2 - x1 - w1, y2 - y1 - h1, w1 + w2, h1 + h2
|
||||
end
|
||||
|
||||
local function rect_containsPoint(x, y, w, h, px, py)
|
||||
return px - x > DELTA and py - y > DELTA and x + w - px > DELTA and y + h - py > DELTA
|
||||
end
|
||||
|
||||
local function rect_isIntersecting(x1, y1, w1, h1, x2, y2, w2, h2)
|
||||
return x1 < x2 + w2 and x2 < x1 + w1 and y1 < y2 + h2 and y2 < y1 + h1
|
||||
end
|
||||
|
||||
local function rect_getSquareDistance(x1, y1, w1, h1, x2, y2, w2, h2)
|
||||
local dx = x1 - x2 + (w1 - w2) / 2
|
||||
local dy = y1 - y2 + (h1 - h2) / 2
|
||||
return dx * dx + dy * dy
|
||||
end
|
||||
|
||||
local function rect_detectCollision(x1, y1, w1, h1, x2, y2, w2, h2, goalX, goalY)
|
||||
goalX = goalX or x1
|
||||
goalY = goalY or y1
|
||||
|
||||
local dx, dy = goalX - x1, goalY - y1
|
||||
local x, y, w, h = rect_getDiff(x1, y1, w1, h1, x2, y2, w2, h2)
|
||||
|
||||
local overlaps, ti, nx, ny
|
||||
|
||||
if rect_containsPoint(x, y, w, h, 0, 0) then -- item was intersecting other
|
||||
local px, py = rect_getNearestCorner(x, y, w, h, 0, 0)
|
||||
local wi, hi = min(w1, abs(px)), min(h1, abs(py)) -- area of intersection
|
||||
ti = -wi * hi -- ti is the negative area of intersection
|
||||
overlaps = true
|
||||
else
|
||||
local ti1, ti2, nx1, ny1 = rect_getSegmentIntersectionIndices(x, y, w, h, 0, 0, dx, dy, -math.huge, math.huge)
|
||||
|
||||
-- item tunnels into other
|
||||
if ti1 and ti1 < 1 and (abs(ti1 - ti2) >= DELTA) -- special case for rect going through another rect's corner
|
||||
and (0 < ti1 + DELTA or 0 == ti1 and ti2 > 0) then
|
||||
ti, nx, ny = ti1, nx1, ny1
|
||||
overlaps = false
|
||||
end
|
||||
end
|
||||
|
||||
if not ti then
|
||||
return
|
||||
end
|
||||
|
||||
local tx, ty
|
||||
|
||||
if overlaps then
|
||||
if dx == 0 and dy == 0 then
|
||||
-- intersecting and not moving - use minimum displacement vector
|
||||
local px, py = rect_getNearestCorner(x, y, w, h, 0, 0)
|
||||
if abs(px) < abs(py) then
|
||||
py = 0
|
||||
else
|
||||
px = 0
|
||||
end
|
||||
nx, ny = sign(px), sign(py)
|
||||
tx, ty = x1 + px, y1 + py
|
||||
else
|
||||
-- intersecting and moving - move in the opposite direction
|
||||
local ti1, _
|
||||
ti1, _, nx, ny = rect_getSegmentIntersectionIndices(x, y, w, h, 0, 0, dx, dy, -math.huge, 1)
|
||||
if not ti1 then
|
||||
return
|
||||
end
|
||||
tx, ty = x1 + dx * ti1, y1 + dy * ti1
|
||||
end
|
||||
else -- tunnel
|
||||
tx, ty = x1 + dx * ti, y1 + dy * ti
|
||||
end
|
||||
|
||||
return {
|
||||
overlaps = overlaps,
|
||||
ti = ti,
|
||||
move = {
|
||||
x = dx,
|
||||
y = dy,
|
||||
},
|
||||
normal = {
|
||||
x = nx,
|
||||
y = ny,
|
||||
},
|
||||
touch = {
|
||||
x = tx,
|
||||
y = ty,
|
||||
},
|
||||
itemRect = {
|
||||
x = x1,
|
||||
y = y1,
|
||||
w = w1,
|
||||
h = h1,
|
||||
},
|
||||
otherRect = {
|
||||
x = x2,
|
||||
y = y2,
|
||||
w = w2,
|
||||
h = h2,
|
||||
},
|
||||
}
|
||||
end
|
||||
|
||||
------------------------------------------
|
||||
-- Grid functions
|
||||
------------------------------------------
|
||||
|
||||
local function grid_toWorld(cellSize, cx, cy)
|
||||
return (cx - 1) * cellSize, (cy - 1) * cellSize
|
||||
end
|
||||
|
||||
local function grid_toCell(cellSize, x, y)
|
||||
return floor(x / cellSize) + 1, floor(y / cellSize) + 1
|
||||
end
|
||||
|
||||
-- grid_traverse* functions are based on "A Fast Voxel Traversal Algorithm for Ray Tracing",
|
||||
-- by John Amanides and Andrew Woo - http://www.cse.yorku.ca/~amana/research/grid.pdf
|
||||
-- It has been modified to include both cells when the ray "touches a grid corner",
|
||||
-- and with a different exit condition
|
||||
|
||||
local function grid_traverse_initStep(cellSize, ct, t1, t2)
|
||||
local v = t2 - t1
|
||||
if v > 0 then
|
||||
return 1, cellSize / v, ((ct + v) * cellSize - t1) / v
|
||||
elseif v < 0 then
|
||||
return -1, -cellSize / v, ((ct + v - 1) * cellSize - t1) / v
|
||||
else
|
||||
return 0, math.huge, math.huge
|
||||
end
|
||||
end
|
||||
|
||||
local function grid_traverse(cellSize, x1, y1, x2, y2, f)
|
||||
local cx1, cy1 = grid_toCell(cellSize, x1, y1)
|
||||
local cx2, cy2 = grid_toCell(cellSize, x2, y2)
|
||||
local stepX, dx, tx = grid_traverse_initStep(cellSize, cx1, x1, x2)
|
||||
local stepY, dy, ty = grid_traverse_initStep(cellSize, cy1, y1, y2)
|
||||
local cx, cy = cx1, cy1
|
||||
|
||||
f(cx, cy)
|
||||
|
||||
-- The default implementation had an infinite loop problem when
|
||||
-- approaching the last cell in some occassions. We finish iterating
|
||||
-- when we are *next* to the last cell
|
||||
while abs(cx - cx2) + abs(cy - cy2) > 1 do
|
||||
if tx < ty then
|
||||
tx, cx = tx + dx, cx + stepX
|
||||
f(cx, cy)
|
||||
else
|
||||
-- Addition: include both cells when going through corners
|
||||
if tx == ty then
|
||||
f(cx + stepX, cy)
|
||||
end
|
||||
ty, cy = ty + dy, cy + stepY
|
||||
f(cx, cy)
|
||||
end
|
||||
end
|
||||
|
||||
-- If we have not arrived to the last cell, use it
|
||||
if cx ~= cx2 or cy ~= cy2 then
|
||||
f(cx2, cy2)
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
local function grid_toCellRect(cellSize, x, y, w, h)
|
||||
local cx, cy = grid_toCell(cellSize, x, y)
|
||||
local cr, cb = ceil((x + w) / cellSize), ceil((y + h) / cellSize)
|
||||
return cx, cy, cr - cx + 1, cb - cy + 1
|
||||
end
|
||||
|
||||
------------------------------------------
|
||||
-- Responses
|
||||
------------------------------------------
|
||||
|
||||
local touch = function(world, col, x, y, w, h, goalX, goalY, filter)
|
||||
return col.touch.x, col.touch.y, {}, 0
|
||||
end
|
||||
|
||||
local cross = function(world, col, x, y, w, h, goalX, goalY, filter)
|
||||
local cols, len = world:project(col.item, x, y, w, h, goalX, goalY, filter)
|
||||
return goalX, goalY, cols, len
|
||||
end
|
||||
|
||||
local slide = function(world, col, x, y, w, h, goalX, goalY, filter)
|
||||
goalX = goalX or x
|
||||
goalY = goalY or y
|
||||
|
||||
local tch, move = col.touch, col.move
|
||||
if move.x ~= 0 or move.y ~= 0 then
|
||||
if col.normal.x ~= 0 then
|
||||
goalX = tch.x
|
||||
else
|
||||
goalY = tch.y
|
||||
end
|
||||
end
|
||||
|
||||
col.slide = {
|
||||
x = goalX,
|
||||
y = goalY,
|
||||
}
|
||||
|
||||
x, y = tch.x, tch.y
|
||||
local cols, len = world:project(col.item, x, y, w, h, goalX, goalY, filter)
|
||||
return goalX, goalY, cols, len
|
||||
end
|
||||
|
||||
local bounce = function(world, col, x, y, w, h, goalX, goalY, filter)
|
||||
goalX = goalX or x
|
||||
goalY = goalY or y
|
||||
|
||||
local tch, move = col.touch, col.move
|
||||
local tx, ty = tch.x, tch.y
|
||||
|
||||
local bx, by = tx, ty
|
||||
|
||||
if move.x ~= 0 or move.y ~= 0 then
|
||||
local bnx, bny = goalX - tx, goalY - ty
|
||||
if col.normal.x == 0 then
|
||||
bny = -bny
|
||||
else
|
||||
bnx = -bnx
|
||||
end
|
||||
bx, by = tx + bnx, ty + bny
|
||||
end
|
||||
|
||||
col.bounce = {
|
||||
x = bx,
|
||||
y = by,
|
||||
}
|
||||
x, y = tch.x, tch.y
|
||||
goalX, goalY = bx, by
|
||||
|
||||
local cols, len = world:project(col.item, x, y, w, h, goalX, goalY, filter)
|
||||
return goalX, goalY, cols, len
|
||||
end
|
||||
|
||||
------------------------------------------
|
||||
-- World
|
||||
------------------------------------------
|
||||
|
||||
local World = {}
|
||||
local World_mt = {
|
||||
__index = World,
|
||||
}
|
||||
|
||||
-- Private functions and methods
|
||||
|
||||
local function sortByWeight(a, b)
|
||||
return a.weight < b.weight
|
||||
end
|
||||
|
||||
local function sortByTiAndDistance(a, b)
|
||||
if a.ti == b.ti then
|
||||
local ir, ar, br = a.itemRect, a.otherRect, b.otherRect
|
||||
local ad = rect_getSquareDistance(ir.x, ir.y, ir.w, ir.h, ar.x, ar.y, ar.w, ar.h)
|
||||
local bd = rect_getSquareDistance(ir.x, ir.y, ir.w, ir.h, br.x, br.y, br.w, br.h)
|
||||
return ad < bd
|
||||
end
|
||||
return a.ti < b.ti
|
||||
end
|
||||
|
||||
local function addItemToCell(self, item, cx, cy)
|
||||
self.rows[cy] = self.rows[cy] or setmetatable({}, {
|
||||
__mode = 'v',
|
||||
})
|
||||
local row = self.rows[cy]
|
||||
row[cx] = row[cx] or {
|
||||
itemCount = 0,
|
||||
x = cx,
|
||||
y = cy,
|
||||
items = setmetatable({}, {
|
||||
__mode = 'k',
|
||||
}),
|
||||
}
|
||||
local cell = row[cx]
|
||||
self.nonEmptyCells[cell] = true
|
||||
if not cell.items[item] then
|
||||
cell.items[item] = true
|
||||
cell.itemCount = cell.itemCount + 1
|
||||
end
|
||||
end
|
||||
|
||||
local function removeItemFromCell(self, item, cx, cy)
|
||||
local row = self.rows[cy]
|
||||
if not row or not row[cx] or not row[cx].items[item] then
|
||||
return false
|
||||
end
|
||||
|
||||
local cell = row[cx]
|
||||
cell.items[item] = nil
|
||||
cell.itemCount = cell.itemCount - 1
|
||||
if cell.itemCount == 0 then
|
||||
self.nonEmptyCells[cell] = nil
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
local function getDictItemsInCellRect(self, cl, ct, cw, ch)
|
||||
local items_dict = {}
|
||||
for cy = ct, ct + ch - 1 do
|
||||
local row = self.rows[cy]
|
||||
if row then
|
||||
for cx = cl, cl + cw - 1 do
|
||||
local cell = row[cx]
|
||||
if cell and cell.itemCount > 0 then -- no cell.itemCount > 1 because tunneling
|
||||
for item, _ in pairs(cell.items) do
|
||||
items_dict[item] = true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return items_dict
|
||||
end
|
||||
|
||||
local function getCellsTouchedBySegment(self, x1, y1, x2, y2)
|
||||
|
||||
local cells, cellsLen, visited = {}, 0, {}
|
||||
|
||||
grid_traverse(self.cellSize, x1, y1, x2, y2, function(cx, cy)
|
||||
local row = self.rows[cy]
|
||||
if not row then
|
||||
return
|
||||
end
|
||||
local cell = row[cx]
|
||||
if not cell or visited[cell] then
|
||||
return
|
||||
end
|
||||
|
||||
visited[cell] = true
|
||||
cellsLen = cellsLen + 1
|
||||
cells[cellsLen] = cell
|
||||
end)
|
||||
|
||||
return cells, cellsLen
|
||||
end
|
||||
|
||||
local function getInfoAboutItemsTouchedBySegment(self, x1, y1, x2, y2, filter)
|
||||
local cells, len = getCellsTouchedBySegment(self, x1, y1, x2, y2)
|
||||
local cell, rect, l, t, w, h, ti1, ti2, tii0, tii1
|
||||
local visited, itemInfo, itemInfoLen = {}, {}, 0
|
||||
for i = 1, len do
|
||||
cell = cells[i]
|
||||
for item in pairs(cell.items) do
|
||||
if not visited[item] then
|
||||
visited[item] = true
|
||||
if (not filter or filter(item)) then
|
||||
rect = self.rects[item]
|
||||
l, t, w, h = rect.x, rect.y, rect.w, rect.h
|
||||
|
||||
ti1, ti2 = rect_getSegmentIntersectionIndices(l, t, w, h, x1, y1, x2, y2, 0, 1)
|
||||
if ti1 and ((0 < ti1 and ti1 < 1) or (0 < ti2 and ti2 < 1)) then
|
||||
-- the sorting is according to the t of an infinite line, not the segment
|
||||
tii0, tii1 = rect_getSegmentIntersectionIndices(l, t, w, h, x1, y1, x2, y2, -math.huge,
|
||||
math.huge)
|
||||
itemInfoLen = itemInfoLen + 1
|
||||
itemInfo[itemInfoLen] = {
|
||||
item = item,
|
||||
ti1 = ti1,
|
||||
ti2 = ti2,
|
||||
weight = min(tii0, tii1),
|
||||
}
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
table.sort(itemInfo, sortByWeight)
|
||||
return itemInfo, itemInfoLen
|
||||
end
|
||||
|
||||
local function getResponseByName(self, name)
|
||||
local response = self.responses[name]
|
||||
if not response then
|
||||
error(('Unknown collision type: %s (%s)'):format(name, type(name)))
|
||||
end
|
||||
return response
|
||||
end
|
||||
|
||||
-- Misc Public Methods
|
||||
|
||||
function World:addResponse(name, response)
|
||||
self.responses[name] = response
|
||||
end
|
||||
|
||||
function World:project(item, x, y, w, h, goalX, goalY, filter)
|
||||
assertIsRect(x, y, w, h)
|
||||
|
||||
goalX = goalX or x
|
||||
goalY = goalY or y
|
||||
filter = filter or defaultFilter
|
||||
|
||||
local collisions, len = {}, 0
|
||||
|
||||
local visited = {}
|
||||
if item ~= nil then
|
||||
visited[item] = true
|
||||
end
|
||||
|
||||
-- This could probably be done with less cells using a polygon raster over the cells instead of a
|
||||
-- bounding rect of the whole movement. Conditional to building a queryPolygon method
|
||||
local tl, tt = min(goalX, x), min(goalY, y)
|
||||
local tr, tb = max(goalX + w, x + w), max(goalY + h, y + h)
|
||||
local tw, th = tr - tl, tb - tt
|
||||
|
||||
local cl, ct, cw, ch = grid_toCellRect(self.cellSize, tl, tt, tw, th)
|
||||
|
||||
local dictItemsInCellRect = getDictItemsInCellRect(self, cl, ct, cw, ch)
|
||||
|
||||
for other, _ in pairs(dictItemsInCellRect) do
|
||||
if not visited[other] then
|
||||
visited[other] = true
|
||||
|
||||
local responseName = filter(item, other)
|
||||
if responseName then
|
||||
local ox, oy, ow, oh = self:getRect(other)
|
||||
local col = rect_detectCollision(x, y, w, h, ox, oy, ow, oh, goalX, goalY)
|
||||
|
||||
if col then
|
||||
col.other = other
|
||||
col.item = item
|
||||
col.type = responseName
|
||||
|
||||
len = len + 1
|
||||
collisions[len] = col
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
table.sort(collisions, sortByTiAndDistance)
|
||||
|
||||
return collisions, len
|
||||
end
|
||||
|
||||
function World:countCells()
|
||||
local count = 0
|
||||
for _, row in pairs(self.rows) do
|
||||
for _, _ in pairs(row) do
|
||||
count = count + 1
|
||||
end
|
||||
end
|
||||
return count
|
||||
end
|
||||
|
||||
function World:hasItem(item)
|
||||
return not not self.rects[item]
|
||||
end
|
||||
|
||||
function World:getItems()
|
||||
local items, len = {}, 0
|
||||
for item, _ in pairs(self.rects) do
|
||||
len = len + 1
|
||||
items[len] = item
|
||||
end
|
||||
return items, len
|
||||
end
|
||||
|
||||
function World:countItems()
|
||||
local len = 0
|
||||
for _ in pairs(self.rects) do
|
||||
len = len + 1
|
||||
end
|
||||
return len
|
||||
end
|
||||
|
||||
function World:getRect(item)
|
||||
local rect = self.rects[item]
|
||||
if not rect then
|
||||
error('Item ' .. tostring(item) ..
|
||||
' must be added to the world before getting its rect. Use world:add(item, x,y,w,h) to add it first.')
|
||||
end
|
||||
return rect.x, rect.y, rect.w, rect.h
|
||||
end
|
||||
|
||||
function World:toWorld(cx, cy)
|
||||
return grid_toWorld(self.cellSize, cx, cy)
|
||||
end
|
||||
|
||||
function World:toCell(x, y)
|
||||
return grid_toCell(self.cellSize, x, y)
|
||||
end
|
||||
|
||||
--- Query methods
|
||||
|
||||
function World:queryRect(x, y, w, h, filter)
|
||||
|
||||
assertIsRect(x, y, w, h)
|
||||
|
||||
local cl, ct, cw, ch = grid_toCellRect(self.cellSize, x, y, w, h)
|
||||
local dictItemsInCellRect = getDictItemsInCellRect(self, cl, ct, cw, ch)
|
||||
|
||||
local items, len = {}, 0
|
||||
|
||||
local rect
|
||||
for item, _ in pairs(dictItemsInCellRect) do
|
||||
rect = self.rects[item]
|
||||
if (not filter or filter(item)) and rect_isIntersecting(x, y, w, h, rect.x, rect.y, rect.w, rect.h) then
|
||||
len = len + 1
|
||||
items[len] = item
|
||||
end
|
||||
end
|
||||
|
||||
return items, len
|
||||
end
|
||||
|
||||
function World:queryPoint(x, y, filter)
|
||||
local cx, cy = self:toCell(x, y)
|
||||
local dictItemsInCellRect = getDictItemsInCellRect(self, cx, cy, 1, 1)
|
||||
|
||||
local items, len = {}, 0
|
||||
|
||||
local rect
|
||||
for item, _ in pairs(dictItemsInCellRect) do
|
||||
rect = self.rects[item]
|
||||
if (not filter or filter(item)) and rect_containsPoint(rect.x, rect.y, rect.w, rect.h, x, y) then
|
||||
len = len + 1
|
||||
items[len] = item
|
||||
end
|
||||
end
|
||||
|
||||
return items, len
|
||||
end
|
||||
|
||||
function World:querySegment(x1, y1, x2, y2, filter)
|
||||
local itemInfo, len = getInfoAboutItemsTouchedBySegment(self, x1, y1, x2, y2, filter)
|
||||
local items = {}
|
||||
for i = 1, len do
|
||||
items[i] = itemInfo[i].item
|
||||
end
|
||||
return items, len
|
||||
end
|
||||
|
||||
function World:querySegmentWithCoords(x1, y1, x2, y2, filter)
|
||||
local itemInfo, len = getInfoAboutItemsTouchedBySegment(self, x1, y1, x2, y2, filter)
|
||||
local dx, dy = x2 - x1, y2 - y1
|
||||
local info, ti1, ti2
|
||||
for i = 1, len do
|
||||
info = itemInfo[i]
|
||||
ti1 = info.ti1
|
||||
ti2 = info.ti2
|
||||
|
||||
info.weight = nil
|
||||
info.x1 = x1 + dx * ti1
|
||||
info.y1 = y1 + dy * ti1
|
||||
info.x2 = x1 + dx * ti2
|
||||
info.y2 = y1 + dy * ti2
|
||||
end
|
||||
return itemInfo, len
|
||||
end
|
||||
|
||||
--- Main methods
|
||||
|
||||
function World:add(item, x, y, w, h)
|
||||
local rect = self.rects[item]
|
||||
if rect then
|
||||
error('Item ' .. tostring(item) .. ' added to the world twice.')
|
||||
end
|
||||
assertIsRect(x, y, w, h)
|
||||
|
||||
self.rects[item] = {
|
||||
x = x,
|
||||
y = y,
|
||||
w = w,
|
||||
h = h,
|
||||
}
|
||||
|
||||
local cl, ct, cw, ch = grid_toCellRect(self.cellSize, x, y, w, h)
|
||||
for cy = ct, ct + ch - 1 do
|
||||
for cx = cl, cl + cw - 1 do
|
||||
addItemToCell(self, item, cx, cy)
|
||||
end
|
||||
end
|
||||
|
||||
return item
|
||||
end
|
||||
|
||||
function World:remove(item)
|
||||
local x, y, w, h = self:getRect(item)
|
||||
|
||||
self.rects[item] = nil
|
||||
local cl, ct, cw, ch = grid_toCellRect(self.cellSize, x, y, w, h)
|
||||
for cy = ct, ct + ch - 1 do
|
||||
for cx = cl, cl + cw - 1 do
|
||||
removeItemFromCell(self, item, cx, cy)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function World:update(item, x2, y2, w2, h2)
|
||||
local x1, y1, w1, h1 = self:getRect(item)
|
||||
w2, h2 = w2 or w1, h2 or h1
|
||||
assertIsRect(x2, y2, w2, h2)
|
||||
|
||||
if x1 ~= x2 or y1 ~= y2 or w1 ~= w2 or h1 ~= h2 then
|
||||
|
||||
local cellSize = self.cellSize
|
||||
local cl1, ct1, cw1, ch1 = grid_toCellRect(cellSize, x1, y1, w1, h1)
|
||||
local cl2, ct2, cw2, ch2 = grid_toCellRect(cellSize, x2, y2, w2, h2)
|
||||
|
||||
if cl1 ~= cl2 or ct1 ~= ct2 or cw1 ~= cw2 or ch1 ~= ch2 then
|
||||
|
||||
local cr1, cb1 = cl1 + cw1 - 1, ct1 + ch1 - 1
|
||||
local cr2, cb2 = cl2 + cw2 - 1, ct2 + ch2 - 1
|
||||
local cyOut
|
||||
|
||||
for cy = ct1, cb1 do
|
||||
cyOut = cy < ct2 or cy > cb2
|
||||
for cx = cl1, cr1 do
|
||||
if cyOut or cx < cl2 or cx > cr2 then
|
||||
removeItemFromCell(self, item, cx, cy)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
for cy = ct2, cb2 do
|
||||
cyOut = cy < ct1 or cy > cb1
|
||||
for cx = cl2, cr2 do
|
||||
if cyOut or cx < cl1 or cx > cr1 then
|
||||
addItemToCell(self, item, cx, cy)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
local rect = self.rects[item]
|
||||
rect.x, rect.y, rect.w, rect.h = x2, y2, w2, h2
|
||||
|
||||
end
|
||||
end
|
||||
|
||||
function World:move(item, goalX, goalY, filter)
|
||||
local actualX, actualY, cols, len = self:check(item, goalX, goalY, filter)
|
||||
|
||||
self:update(item, actualX, actualY)
|
||||
|
||||
return actualX, actualY, cols, len
|
||||
end
|
||||
|
||||
function World:check(item, goalX, goalY, filter)
|
||||
filter = filter or defaultFilter
|
||||
|
||||
local visited = {
|
||||
[item] = true,
|
||||
}
|
||||
local visitedFilter = function(itm, other)
|
||||
if visited[other] then
|
||||
return false
|
||||
end
|
||||
return filter(itm, other)
|
||||
end
|
||||
|
||||
local cols, len = {}, 0
|
||||
|
||||
local x, y, w, h = self:getRect(item)
|
||||
|
||||
local projected_cols, projected_len = self:project(item, x, y, w, h, goalX, goalY, visitedFilter)
|
||||
|
||||
while projected_len > 0 do
|
||||
local col = projected_cols[1]
|
||||
len = len + 1
|
||||
cols[len] = col
|
||||
|
||||
visited[col.other] = true
|
||||
|
||||
local response = getResponseByName(self, col.type)
|
||||
|
||||
goalX, goalY, projected_cols, projected_len = response(self, col, x, y, w, h, goalX, goalY, visitedFilter)
|
||||
end
|
||||
|
||||
return goalX, goalY, cols, len
|
||||
end
|
||||
|
||||
-- Public library functions
|
||||
|
||||
bump.newWorld = function(cellSize)
|
||||
cellSize = cellSize or 64
|
||||
assertIsPositiveNumber(cellSize, 'cellSize')
|
||||
local world = setmetatable({
|
||||
cellSize = cellSize,
|
||||
rects = {},
|
||||
rows = {},
|
||||
nonEmptyCells = {},
|
||||
responses = {},
|
||||
}, World_mt)
|
||||
|
||||
world:addResponse('touch', touch)
|
||||
world:addResponse('cross', cross)
|
||||
world:addResponse('slide', slide)
|
||||
world:addResponse('bounce', bounce)
|
||||
|
||||
return world
|
||||
end
|
||||
|
||||
bump.rect = {
|
||||
getNearestCorner = rect_getNearestCorner,
|
||||
getSegmentIntersectionIndices = rect_getSegmentIntersectionIndices,
|
||||
getDiff = rect_getDiff,
|
||||
containsPoint = rect_containsPoint,
|
||||
isIntersecting = rect_isIntersecting,
|
||||
getSquareDistance = rect_getSquareDistance,
|
||||
detectCollision = rect_detectCollision,
|
||||
}
|
||||
|
||||
bump.responses = {
|
||||
touch = touch,
|
||||
cross = cross,
|
||||
slide = slide,
|
||||
bounce = bounce,
|
||||
}
|
||||
|
||||
return bump
|
||||
@ -0,0 +1,326 @@
|
||||
-- https://github.com/bakpakin/corope
|
||||
local setmetatable = setmetatable
|
||||
local create = coroutine.create
|
||||
local status = coroutine.status
|
||||
local resume = coroutine.resume
|
||||
local yield = coroutine.yield
|
||||
local running = coroutine.running
|
||||
local type = type
|
||||
local select = select
|
||||
local assert = assert
|
||||
local unpack = unpack or table.unpack
|
||||
|
||||
-- Object definitions
|
||||
|
||||
local Bundle = {}
|
||||
local Bundle_mt = {
|
||||
__index = Bundle,
|
||||
}
|
||||
|
||||
local Rope = {}
|
||||
local Rope_mt = {
|
||||
__index = Rope,
|
||||
}
|
||||
|
||||
local function newBundle(options)
|
||||
options = options or {}
|
||||
return setmetatable({
|
||||
ropes = {}, -- Active threads
|
||||
signals = {}, -- Signal listeners
|
||||
time = 0,
|
||||
errhand = options.errhand or print,
|
||||
}, Bundle_mt)
|
||||
end
|
||||
|
||||
local function newRope(fn, ...)
|
||||
return setmetatable({
|
||||
thread = create(fn),
|
||||
primer = {
|
||||
args = {...},
|
||||
n = select('#', ...),
|
||||
},
|
||||
}, Rope_mt)
|
||||
end
|
||||
|
||||
-- Bundle implementation
|
||||
|
||||
-- TODO: Should ropes be allowed to change bundles?
|
||||
function Bundle:suspend(rope)
|
||||
assert(rope.bundle == self, 'rope does not belong to this bundle')
|
||||
assert(not rope.paused, 'cannot suspend already suspended rope')
|
||||
local ts = self.ropes
|
||||
local index = rope.index
|
||||
rope.paused = true
|
||||
ts[index] = ts[#ts]
|
||||
ts[index].index = index
|
||||
ts[#ts] = nil
|
||||
end
|
||||
|
||||
function Bundle:resume(rope)
|
||||
assert(rope.bundle == self, 'rope does not belong to this bundle')
|
||||
assert(rope.paused, 'cannot resume active rope')
|
||||
local ts = self.ropes
|
||||
local newIndex = #ts + 1
|
||||
ts[newIndex] = rope
|
||||
rope.index = newIndex
|
||||
rope.paused = nil
|
||||
end
|
||||
|
||||
function Bundle:update(dseconds)
|
||||
local ropes = self.ropes
|
||||
local i = 1
|
||||
while i <= #ropes do
|
||||
local rope = ropes[i]
|
||||
local t = rope.thread
|
||||
local stat, err
|
||||
if rope.primer then
|
||||
local n = rope.primer.n
|
||||
local args = rope.primer.args
|
||||
rope.primer = nil
|
||||
stat, err = resume(t, rope, unpack(args, 1, n))
|
||||
else
|
||||
stat, err = resume(t, dseconds, rope.signal)
|
||||
end
|
||||
if not stat then
|
||||
local errhand = rope.errhand or self.errhand
|
||||
errhand(err)
|
||||
end
|
||||
if status(t) == 'dead' then -- rope has finished
|
||||
ropes[i] = ropes[#ropes]
|
||||
ropes[i].index = i
|
||||
ropes[#ropes] = nil
|
||||
else
|
||||
i = i + 1
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function Bundle:rope(fn, ...)
|
||||
local ropes = self.ropes
|
||||
local index = #ropes + 1
|
||||
local rope = newRope(fn, ...)
|
||||
rope.index = index
|
||||
rope.bundle = self
|
||||
ropes[index] = rope
|
||||
return rope
|
||||
end
|
||||
Bundle_mt.__call = Bundle.rope
|
||||
|
||||
-- Rope implmentation
|
||||
|
||||
local timeUnitToSeconds = {
|
||||
s = 1,
|
||||
sec = 1,
|
||||
seconds = 1,
|
||||
second = 1,
|
||||
ms = 0.001,
|
||||
milliseconds = 0.0001,
|
||||
millisecond = 0.0001,
|
||||
min = 60,
|
||||
min = 60,
|
||||
mn = 60,
|
||||
minutes = 60,
|
||||
minute = 60,
|
||||
h = 3600,
|
||||
hs = 3600,
|
||||
hours = 3600,
|
||||
hour = 3600,
|
||||
}
|
||||
|
||||
local timeUnitFrames = {
|
||||
f = true,
|
||||
fs = true,
|
||||
frames = true,
|
||||
frame = true,
|
||||
}
|
||||
|
||||
local function checkCorrectCoroutine(rope)
|
||||
if running() ~= rope.thread then
|
||||
error('rope function called outside of dispatch function or inside coroutine', 3)
|
||||
end
|
||||
end
|
||||
|
||||
function Rope:wait(time)
|
||||
checkCorrectCoroutine(self)
|
||||
if time == nil then
|
||||
return yield()
|
||||
end
|
||||
local tp = type(time)
|
||||
if tp == 'number' then
|
||||
while (time > 0) do
|
||||
time = time - yield()
|
||||
end
|
||||
elseif tp == 'string' then
|
||||
local numstr, unit = time:match('^(.-)(%a*)$')
|
||||
local num = tonumber(numstr) or 1
|
||||
if timeUnitFrames[unit] then
|
||||
for i = 1, num do
|
||||
yield()
|
||||
end
|
||||
else
|
||||
local time = num * (timeUnitToSeconds[unit] or 1)
|
||||
while (time > 0) do
|
||||
time = time - yield()
|
||||
end
|
||||
end
|
||||
else
|
||||
local f = time
|
||||
local time = 0
|
||||
while not f(time) do
|
||||
time = time + yield()
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- Generate ease functions - https://github.com/rxi/flux/
|
||||
local easeFunctions = {}
|
||||
do
|
||||
local expressions = {
|
||||
quad = "p * p",
|
||||
cubic = "p * p * p",
|
||||
quart = "p * p * p * p",
|
||||
quint = "p * p * p * p * p",
|
||||
expo = "2 ^ (10 * (p - 1))",
|
||||
sine = "-math.cos(p * (math.pi * .5)) + 1",
|
||||
circ = "-(math.sqrt(1 - (p * p)) - 1)",
|
||||
back = "p * p * (2.7 * p - 1.7)",
|
||||
elastic = "-(2^(10 * (p - 1)) * math.sin((p - 1.075) * (math.pi * 2) / .3))",
|
||||
}
|
||||
|
||||
local function makeEaseFunction(str, expr)
|
||||
local load = loadstring or load
|
||||
return load("return function(p) " .. str:gsub("%$e", expr) .. " end")()
|
||||
end
|
||||
|
||||
local function generateEase(name, expression)
|
||||
easeFunctions[name] = makeEaseFunction("return $e", expression)
|
||||
easeFunctions[name .. "in"] = easeFunctions[name]
|
||||
easeFunctions[name .. "out"] = makeEaseFunction([[
|
||||
p = 1 - p
|
||||
return 1 - ($e)
|
||||
]], expression)
|
||||
easeFunctions[name .. "inout"] = makeEaseFunction([[
|
||||
p = p * 2
|
||||
if p < 1 then
|
||||
return .5 * ($e)
|
||||
else
|
||||
p = 2 - p
|
||||
return .5 * (1 - ($e)) + .5
|
||||
end
|
||||
]], expression)
|
||||
end
|
||||
|
||||
for k, v in pairs(expressions) do
|
||||
generateEase(k, v)
|
||||
end
|
||||
easeFunctions['linear'] = makeEaseFunction('return $e', 'p')
|
||||
end
|
||||
|
||||
function Rope:tween(options)
|
||||
checkCorrectCoroutine(self)
|
||||
local object = options.object
|
||||
local key = options.key
|
||||
local to = options.to
|
||||
local ease = options.ease or 'linear'
|
||||
local timenumstr, timeunit = options.time:match('^(.-)(%a*)$')
|
||||
local timenum = tonumber(timenumstr) or 1
|
||||
local from = options.from or object[key]
|
||||
local scale = to - from
|
||||
ease = easeFunctions[ease] or ease
|
||||
assert(type(ease) == 'function' or type(ease) == 'table',
|
||||
'expected valid name of callable object for easing function')
|
||||
if timeUnitFrames[timeunit] then
|
||||
local t = 0
|
||||
local dt = 1 / timenum
|
||||
for frame = 1, timenum do
|
||||
object[key] = from + scale * ease(t)
|
||||
t = t + dt
|
||||
yield()
|
||||
end
|
||||
else
|
||||
object[key] = to
|
||||
local tscale = 1 / (timenum * (timeUnitToSeconds[timeunit] or 1))
|
||||
local t = 0
|
||||
while t < 1 do
|
||||
object[key] = from + scale * ease(t)
|
||||
local dt = yield()
|
||||
t = t + tscale * dt
|
||||
end
|
||||
end
|
||||
object[key] = to
|
||||
end
|
||||
|
||||
function Rope:tweenFork(options)
|
||||
return self.bundle(Rope.tween, options)
|
||||
end
|
||||
|
||||
function Rope:fork(fn, ...)
|
||||
checkCorrectCoroutine(self)
|
||||
return self.bundle(fn, ...)
|
||||
end
|
||||
|
||||
function Rope:listen(name)
|
||||
checkCorrectCoroutine(self)
|
||||
local bundle = self.bundle
|
||||
local signals = bundle.signals
|
||||
local slist = signals[name]
|
||||
bundle:suspend(self)
|
||||
if not slist then
|
||||
slist = {}
|
||||
signals[name] = slist
|
||||
end
|
||||
slist[#slist + 1] = self
|
||||
local dt, sig = yield()
|
||||
return sig
|
||||
end
|
||||
|
||||
function Rope:signal(name, data)
|
||||
checkCorrectCoroutine(self)
|
||||
local bundle = self.bundle
|
||||
local signals = bundle.signals
|
||||
local slist = signals[name]
|
||||
if slist then
|
||||
for i = 1, #slist do
|
||||
local rope = slist[i]
|
||||
bundle:resume(rope)
|
||||
rope.signal = data
|
||||
end
|
||||
signals[name] = nil
|
||||
end
|
||||
end
|
||||
|
||||
function Rope:parallel(...)
|
||||
checkCorrectCoroutine(self)
|
||||
local bundle = self.bundle
|
||||
local n = select('#', ...)
|
||||
local ropes = {} -- also used as signal
|
||||
local function onDone(rope)
|
||||
local pindex = rope.pindex
|
||||
ropes[pindex] = ropes[#ropes]
|
||||
ropes[pindex].pindex = pindex
|
||||
ropes[#ropes] = nil
|
||||
if #ropes == 0 then
|
||||
rope:signal(ropes, false) -- no error
|
||||
end
|
||||
end
|
||||
for i = 1, n do
|
||||
local fn = select(i, ...)
|
||||
local function wrappedfn(r)
|
||||
fn(r)
|
||||
onDone(r)
|
||||
end
|
||||
local rope = bundle(wrappedfn)
|
||||
local function errhand(err)
|
||||
for i = 1, #ropes do
|
||||
bundle:suspend(ropes[i])
|
||||
end
|
||||
rope:signal(ropes, err) -- we errored out
|
||||
end
|
||||
rope.errhand = errhand
|
||||
rope.pindex = i
|
||||
ropes[#ropes + 1] = rope
|
||||
end
|
||||
return self:listen(ropes)
|
||||
end
|
||||
|
||||
return newBundle
|
||||
@ -0,0 +1,725 @@
|
||||
-- https://github.com/nenofite/mm
|
||||
|
||||
|
||||
-- Terminal color (and formatting) codes.
|
||||
local C = {
|
||||
e = '\27[0m', -- reset
|
||||
|
||||
-- Text attributes.
|
||||
br = '\27[1m', -- bright
|
||||
di = '\27[2m', -- dim
|
||||
it = '\27[3m', -- italics
|
||||
un = '\27[4m', -- underscore
|
||||
bl = '\27[5m', -- blink
|
||||
re = '\27[7m', -- reverse
|
||||
hi = '\27[8m', -- hidden
|
||||
|
||||
-- Text colors.
|
||||
k = '\27[30m', -- black
|
||||
r = '\27[31m', -- red
|
||||
g = '\27[32m', -- green
|
||||
y = '\27[33m', -- yellow
|
||||
b = '\27[34m', -- blue
|
||||
m = '\27[35m', -- magenta
|
||||
c = '\27[36m', -- cyan
|
||||
w = '\27[37m', -- white
|
||||
|
||||
-- Background colors.
|
||||
_k = '\27[40m', -- black
|
||||
_r = '\27[41m', -- red
|
||||
_g = '\27[42m', -- green
|
||||
_y = '\27[43m', -- yellow
|
||||
_b = '\27[44m', -- blue
|
||||
_m = '\27[45m', -- magenta
|
||||
_c = '\27[46m', -- cyan
|
||||
_w = '\27[47m', -- white
|
||||
}
|
||||
|
||||
-- If we're on Windows, set all colors to empty strings so we don't spam the
|
||||
-- output with meaningless escape codes.
|
||||
local ON_WINDOWS = string.find(package.path, '\\') ~= nil
|
||||
if ON_WINDOWS then
|
||||
for k, v in pairs(C) do
|
||||
C[k] = ''
|
||||
end
|
||||
end
|
||||
|
||||
local METATABLE = {
|
||||
"<metatable>",
|
||||
colors = C.it .. C.y,
|
||||
}
|
||||
local INDENT = " "
|
||||
|
||||
-- The default sequence separator.
|
||||
local SEP = " "
|
||||
|
||||
-- The open and close brackets can be any piece (notably, a sequence with
|
||||
-- colors). The separator must be a plain string.
|
||||
local BOPEN, BSEP, BCLOSE = 1, 2, 3
|
||||
|
||||
-- The default frame brackets and separator.
|
||||
local BRACKETS = {{
|
||||
"{",
|
||||
colors = C.br,
|
||||
}, ",", {
|
||||
"}",
|
||||
colors = C.br,
|
||||
}}
|
||||
|
||||
local STR_HALF = 30
|
||||
local MAX_STR_LEN = STR_HALF * 2
|
||||
|
||||
-- Names to use for named references. The order is important; these are aligned
|
||||
-- with the colors in `NAME_COLORS`.
|
||||
local NAMES = {"Cherry", "Apple", "Lemon", "Blueberry", "Jam", "Cream", "Rhubarb", "Lime", "Butter", "Grape",
|
||||
"Pomegranate", "Sugar", "Cinnamon", "Avocado", "Honey"}
|
||||
|
||||
-- Colors to use for named references. Don't use black nor white.
|
||||
local NAME_COLORS = {C.r, C.g, C.y, C.b, C.m, C.c}
|
||||
|
||||
-- Reserved Lua keywords as a convenient look-up table.
|
||||
local RESERVED = {
|
||||
['and'] = true,
|
||||
['break'] = true,
|
||||
['do'] = true,
|
||||
['else'] = true,
|
||||
['elseif'] = true,
|
||||
['end'] = true,
|
||||
['false'] = true,
|
||||
['for'] = true,
|
||||
['function'] = true,
|
||||
['goto'] = true,
|
||||
['if'] = true,
|
||||
['in'] = true,
|
||||
['local'] = true,
|
||||
['nil'] = true,
|
||||
['not'] = true,
|
||||
['or'] = true,
|
||||
['repeat'] = true,
|
||||
['return'] = true,
|
||||
['then'] = true,
|
||||
['true'] = true,
|
||||
['until'] = true,
|
||||
['while'] = true,
|
||||
}
|
||||
|
||||
--
|
||||
-- Namers
|
||||
--
|
||||
|
||||
local function new_namer()
|
||||
local index = 1
|
||||
local suffix = 1
|
||||
local color_index = 1
|
||||
|
||||
return function()
|
||||
-- Pick the name.
|
||||
local result = NAMES[index]
|
||||
if suffix > 1 then
|
||||
result = result .. " " .. tostring(suffix)
|
||||
end
|
||||
|
||||
index = index + 1
|
||||
if index > #NAMES then
|
||||
index = 1
|
||||
suffix = suffix + 1
|
||||
end
|
||||
|
||||
-- Pick the color.
|
||||
local color = NAME_COLORS[color_index]
|
||||
|
||||
color_index = color_index + 1
|
||||
if color_index > #NAME_COLORS then
|
||||
color_index = 1
|
||||
end
|
||||
|
||||
return {
|
||||
result,
|
||||
colors = C.un .. color,
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
--
|
||||
-- Context
|
||||
--
|
||||
|
||||
local function new_context()
|
||||
return {
|
||||
occur = {},
|
||||
named = {},
|
||||
next_name = new_namer(),
|
||||
|
||||
prev_indent = '',
|
||||
next_indent = INDENT,
|
||||
line_len = 0,
|
||||
max_width = 78,
|
||||
|
||||
result = '',
|
||||
}
|
||||
end
|
||||
|
||||
--
|
||||
-- Translating into pieces
|
||||
--
|
||||
|
||||
-- Translaters take any Lua value and create pieces to represent them.
|
||||
--
|
||||
-- Some values should only be serialized once, both to prevent cycles and to
|
||||
-- prevent redundancy. Or in other cases, these values cannot be serialized
|
||||
-- (such as functions) but if they appear multiple times we want to express
|
||||
-- that they are the same.
|
||||
--
|
||||
-- When a translater encounters such a value for the first time, it is
|
||||
-- registered in the context in `occur`. The value is wrapped in a plain table
|
||||
-- with the `id` field pointing to the original value. If the value is
|
||||
-- serializable, such as a table, then the the `def` field contains the piece
|
||||
-- to display. If it is unserializable or it is not the first time this value
|
||||
-- has occurred, the `def` field is nil.
|
||||
--
|
||||
-- In the cleaning stage, these `id` fields are replaced with their names. If a
|
||||
-- `def` field is present, then a sequence is generated to define the name with
|
||||
-- the piece.
|
||||
|
||||
local translaters = {}
|
||||
local translate, ident_friendly
|
||||
|
||||
function translate(val, ctx)
|
||||
-- Try to find a type-specific translater.
|
||||
local by_type = translaters[type(val)]
|
||||
|
||||
if by_type then
|
||||
-- If there is a type-specific translater, call it.
|
||||
return by_type(val, ctx)
|
||||
end
|
||||
|
||||
-- Otherwise perform the default translation.
|
||||
|
||||
-- Check whether we've already encountered this value.
|
||||
if ctx.occur[val] then
|
||||
-- We have; give it a name if we haven't already.
|
||||
if not ctx.named[val] then
|
||||
ctx.named[val] = ctx.next_name()
|
||||
end
|
||||
|
||||
-- Return the value as a reference.
|
||||
return {
|
||||
id = val,
|
||||
}
|
||||
else
|
||||
-- We haven't; mark it as encountered.
|
||||
ctx.occur[val] = true
|
||||
|
||||
-- Return the value as a definition.
|
||||
return {
|
||||
id = val,
|
||||
def = tostring(val),
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
translaters['function'] = function(val, ctx)
|
||||
-- Check whether we've already encountered this function.
|
||||
if ctx.occur[val] then
|
||||
-- We have; give it a name if we haven't already.
|
||||
if not ctx.named[val] then
|
||||
ctx.named[val] = ctx.next_name()
|
||||
end
|
||||
else
|
||||
-- We haven't; mark it as encountered.
|
||||
ctx.occur[val] = true
|
||||
end
|
||||
|
||||
-- Return the unserialized function.
|
||||
return {
|
||||
id = val,
|
||||
}
|
||||
end
|
||||
|
||||
function translaters.table(val, ctx)
|
||||
-- Check whether we've already encountered this table.
|
||||
if ctx.occur[val] then
|
||||
-- We have; give it a name if we haven't already.
|
||||
if not ctx.named[val] then
|
||||
ctx.named[val] = ctx.next_name()
|
||||
end
|
||||
|
||||
-- Return the unserialized table.
|
||||
return {
|
||||
id = val,
|
||||
}
|
||||
else
|
||||
-- We haven't; mark it as encountered.
|
||||
ctx.occur[val] = true
|
||||
|
||||
-- Construct the frame for this table.
|
||||
local result = {
|
||||
bracket = BRACKETS,
|
||||
}
|
||||
|
||||
-- The equals-sign between key and value.
|
||||
local eq = {
|
||||
"=",
|
||||
colors = C.di,
|
||||
}
|
||||
|
||||
-- Represent the metatable, if present.
|
||||
local mt = getmetatable(val)
|
||||
if mt then
|
||||
-- Translate the metatable.
|
||||
mt = translate(mt, ctx)
|
||||
table.insert(result, {METATABLE, eq, mt})
|
||||
end
|
||||
|
||||
-- Represent the contents.
|
||||
for k, v in pairs(val) do
|
||||
-- If it is a string key which can be represented without quotes, leave
|
||||
-- it plain.
|
||||
if ident_friendly(k) then
|
||||
-- Leave the key as it is.
|
||||
k = {
|
||||
k,
|
||||
colors = C.m,
|
||||
}
|
||||
else
|
||||
-- Otherwise translate the key.
|
||||
k = translate(k, ctx)
|
||||
end
|
||||
|
||||
-- Translate the value.
|
||||
v = translate(v, ctx)
|
||||
|
||||
table.insert(result, {k, eq, v})
|
||||
end
|
||||
|
||||
-- Wrap the result with its id.
|
||||
return {
|
||||
id = val,
|
||||
def = result,
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
function translaters.string(val, ctx)
|
||||
if #val <= MAX_STR_LEN then
|
||||
-- The string is short enough; display it all.
|
||||
local a = string.format('%q', val)
|
||||
a = string.gsub(a, '\n', 'n')
|
||||
|
||||
return {
|
||||
a,
|
||||
colors = C.g,
|
||||
}
|
||||
else
|
||||
-- The string is too long. Only show the start and end.
|
||||
local a = string.format('%q', string.sub(val, 1, STR_HALF))
|
||||
a = string.gsub(a, '\n', 'n')
|
||||
local b = string.format('%q', string.sub(val, -STR_HALF))
|
||||
b = string.gsub(b, '\n', 'n')
|
||||
|
||||
return {
|
||||
a,
|
||||
{
|
||||
"...",
|
||||
colors = C.di,
|
||||
},
|
||||
b,
|
||||
colors = C.g,
|
||||
sep = '',
|
||||
tight = true,
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
function translaters.number(val, ctx)
|
||||
return {
|
||||
tostring(val),
|
||||
colors = C.m .. C.br,
|
||||
}
|
||||
end
|
||||
|
||||
-- Check whether a value can be represented as a Lua identifier, without the
|
||||
-- need for quotes or translation.
|
||||
--
|
||||
-- If the value is not a string, this immediately returns false. Otherwise, the
|
||||
-- string must be a valid Lua name: a sequence of letters, digits, and
|
||||
-- underscores that doesn't start with a digit and isn't a reserved keyword.
|
||||
--
|
||||
-- See http://www.lua.org/manual/5.3/manual.html#3.1
|
||||
function ident_friendly(val)
|
||||
-- The value must be a string.
|
||||
if type(val) ~= 'string' then
|
||||
return false
|
||||
end
|
||||
|
||||
if string.find(val, '^[_%a][_%a%d]*$') then
|
||||
-- The value is a Lua name; check if it is reserved.
|
||||
if RESERVED[val] then
|
||||
-- The value is a resreved keyword.
|
||||
return false
|
||||
else
|
||||
-- The value is a valid name.
|
||||
return true
|
||||
end
|
||||
else
|
||||
-- The value is not a Lua name.
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
--
|
||||
-- Cleaning pieces
|
||||
--
|
||||
|
||||
local function clean(piece, ctx)
|
||||
if type(piece) == 'table' then
|
||||
-- Check if it's an id reference.
|
||||
if piece.id then
|
||||
local name = ctx.named[piece.id]
|
||||
local def = piece.def
|
||||
|
||||
-- Check whether it has been given a name.
|
||||
if name then
|
||||
local header = {
|
||||
"<",
|
||||
type(piece.id),
|
||||
" ",
|
||||
name,
|
||||
">",
|
||||
colors = C.it,
|
||||
sep = '',
|
||||
tight = true,
|
||||
}
|
||||
-- Named. Check whether the reference has a definition.
|
||||
if def then
|
||||
-- Create a sequence defining the name to the definition.
|
||||
return {header, {
|
||||
"is",
|
||||
colors = C.di,
|
||||
}, clean(piece.def, ctx)}
|
||||
else
|
||||
-- Show just the name.
|
||||
return header
|
||||
end
|
||||
else
|
||||
-- No name. Check whether the reference has a definition.
|
||||
if def then
|
||||
-- Display the definition without any header.
|
||||
return clean(piece.def, ctx)
|
||||
else
|
||||
-- Display just the type.
|
||||
return {
|
||||
"<",
|
||||
type(piece.id),
|
||||
">",
|
||||
colors = C.it,
|
||||
sep = '',
|
||||
tight = true,
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
-- Check if it's a frame.
|
||||
elseif piece.bracket then
|
||||
-- Clean each child.
|
||||
for i, child in ipairs(piece) do
|
||||
piece[i] = clean(child, ctx)
|
||||
end
|
||||
return piece
|
||||
|
||||
-- Otherwise it's a sequence.
|
||||
else
|
||||
-- Clean each child.
|
||||
for i, child in ipairs(piece) do
|
||||
piece[i] = clean(child, ctx)
|
||||
end
|
||||
return piece
|
||||
end
|
||||
else
|
||||
-- It's a plain value, not a table; no cleaning is needed.
|
||||
return piece
|
||||
end
|
||||
end
|
||||
|
||||
--
|
||||
-- Displaying pieces
|
||||
--
|
||||
|
||||
-- Pieces are either frames (with brackets), sequences (no brackets), or
|
||||
-- strings.
|
||||
|
||||
-- Frames are displayed either short-form as { a = 1 } or long-form as
|
||||
-- {
|
||||
-- a = 1
|
||||
-- }.
|
||||
|
||||
-- Declare all the local functions first, so they can refer to each other.
|
||||
local min_len, display, display_frame, display_sequence, display_string, display_frame_short, display_frame_long,
|
||||
newline, newline_no_indent, write, write_nolength, space_here, space_newline
|
||||
|
||||
-- Dispatch based on the piece's type.
|
||||
function display(piece, ctx)
|
||||
if type(piece) == 'string' then
|
||||
-- String.
|
||||
return display_string(piece, ctx)
|
||||
elseif piece.bracket then
|
||||
-- Frame.
|
||||
return display_frame(piece, ctx)
|
||||
else
|
||||
-- Sequence.
|
||||
return display_sequence(piece, ctx)
|
||||
end
|
||||
end
|
||||
|
||||
-- Display a frame.
|
||||
function display_frame(frame, ctx)
|
||||
if #frame == 0 then
|
||||
-- If the frame is empty, just display the brackets.
|
||||
local str = {
|
||||
frame.bracket[BOPEN],
|
||||
frame.bracket[BCLOSE],
|
||||
sep = '',
|
||||
tight = true,
|
||||
}
|
||||
return display(str, ctx)
|
||||
end
|
||||
|
||||
local ml = min_len(frame)
|
||||
|
||||
-- Try to fit the frame short-form on this line.
|
||||
if ml <= space_here(ctx) then
|
||||
return display_frame_short(frame, ctx)
|
||||
|
||||
-- Otherwise try to fit it short-form on the next line.
|
||||
elseif ml <= space_newline(ctx) then
|
||||
newline(ctx)
|
||||
return display_frame_short(frame, ctx)
|
||||
|
||||
-- Otherwise display it long-form.
|
||||
else
|
||||
return display_frame_long(frame, ctx)
|
||||
end
|
||||
end
|
||||
|
||||
function display_frame_short(frame, ctx)
|
||||
-- Short-form frames never wrap onto new lines, so we don't need to do any
|
||||
-- length checking (it's already been done for us).
|
||||
|
||||
-- Write the open bracket.
|
||||
display(frame.bracket[BOPEN], ctx)
|
||||
write(" ", ctx)
|
||||
|
||||
-- Display the first child.
|
||||
display(frame[1], ctx)
|
||||
|
||||
-- Display the remaining children.
|
||||
for i = 2, #frame do
|
||||
local child = frame[i]
|
||||
|
||||
-- Write the separator.
|
||||
write(frame.bracket[BSEP], ctx)
|
||||
write(" ", ctx)
|
||||
|
||||
-- Display the child.
|
||||
display(child, ctx)
|
||||
end
|
||||
|
||||
-- Write the close bracket.
|
||||
write(" ", ctx)
|
||||
display(frame.bracket[BCLOSE], ctx)
|
||||
end
|
||||
|
||||
function display_frame_long(frame, ctx)
|
||||
-- Remember the original value of next_indent.
|
||||
local old_old_indent = ctx.prev_indent
|
||||
local old_indent = ctx.next_indent
|
||||
|
||||
-- Display the open bracket.
|
||||
display(frame.bracket[BOPEN], ctx)
|
||||
|
||||
-- Increase the indentation.
|
||||
ctx.prev_indent = old_indent
|
||||
ctx.next_indent = old_indent .. INDENT
|
||||
|
||||
-- For all but the last child...
|
||||
for i = 1, #frame - 1 do
|
||||
local child = frame[i]
|
||||
|
||||
-- Start a new line with old indentation.
|
||||
newline_no_indent(ctx)
|
||||
write(old_indent, ctx)
|
||||
|
||||
-- Display the child.
|
||||
display(child, ctx)
|
||||
|
||||
-- Write the separator.
|
||||
write(frame.bracket[BSEP], ctx)
|
||||
end
|
||||
|
||||
-- For the last child...
|
||||
do
|
||||
local child = frame[#frame]
|
||||
|
||||
-- Start a new line with old indentation.
|
||||
newline_no_indent(ctx)
|
||||
write(old_indent, ctx)
|
||||
|
||||
-- Display the child.
|
||||
display(child, ctx)
|
||||
-- No separator.
|
||||
end
|
||||
|
||||
-- Write the close bracket.
|
||||
newline_no_indent(ctx)
|
||||
write(old_old_indent, ctx)
|
||||
display(frame.bracket[BCLOSE], ctx)
|
||||
|
||||
-- Return to the old indentation.
|
||||
ctx.prev_indent = old_old_indent
|
||||
ctx.next_indent = old_indent
|
||||
end
|
||||
|
||||
function display_sequence(piece, ctx)
|
||||
if #piece > 0 then
|
||||
-- Check if this is a tight sequence.
|
||||
if piece.tight then
|
||||
-- Try to fit the entire sequence on one line.
|
||||
local ml = min_len(piece, ctx)
|
||||
|
||||
-- If it won't fit here, but it would fit on the next line, then write it
|
||||
-- on the next line; otherwise, write it here.
|
||||
if ml > space_here(ctx) and ml <= space_newline(ctx) then
|
||||
newline(ctx)
|
||||
end
|
||||
end
|
||||
|
||||
-- Apply the colors, if given.
|
||||
if piece.colors then
|
||||
write_nolength(piece.colors, ctx)
|
||||
end
|
||||
|
||||
-- Display the first child.
|
||||
display(piece[1], ctx)
|
||||
|
||||
-- For each following children:
|
||||
for i = 2, #piece do
|
||||
local child = piece[i]
|
||||
|
||||
-- Apply the colors, if given.
|
||||
if piece.colors then
|
||||
write_nolength(piece.colors, ctx)
|
||||
end
|
||||
|
||||
-- Write a separator.
|
||||
write(piece.sep or SEP, ctx)
|
||||
|
||||
-- Then display the child.
|
||||
display(child, ctx)
|
||||
end
|
||||
|
||||
-- Reset the colors.
|
||||
if piece.colors then
|
||||
write_nolength(C.e, ctx)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function display_string(piece, ctx)
|
||||
local ml = min_len(piece)
|
||||
|
||||
-- If it won't fit here, but it would fit on the next line, then write it on
|
||||
-- the next line; otherwise, write it here.
|
||||
if ml > space_here(ctx) and ml <= space_newline(ctx) then
|
||||
newline(ctx)
|
||||
end
|
||||
|
||||
write(piece, ctx)
|
||||
end
|
||||
|
||||
-- The minimum length to display this piece, if it is placed all on one line.
|
||||
function min_len(piece, ctx)
|
||||
-- For strings, simply return their length.
|
||||
if type(piece) == 'string' then
|
||||
return #piece
|
||||
end
|
||||
|
||||
-- Otherwise, we have some calculations to do.
|
||||
local result = 0
|
||||
|
||||
if piece.bracket then
|
||||
-- This is a frame.
|
||||
|
||||
-- If it's an empty frame, just the open and close brackets.
|
||||
if #piece == 0 then
|
||||
return min_len(piece.bracket[BOPEN]) + min_len(piece.bracket[BCLOSE])
|
||||
end
|
||||
|
||||
-- Open and close brackets, plus a space for each.
|
||||
result = result + min_len(piece.bracket[BOPEN]) + min_len(piece.bracket[BCLOSE]) + 2
|
||||
|
||||
-- A separator between each item, plus a space for each.
|
||||
result = result + (#piece - 1) * (#piece.bracket[BSEP] + 1)
|
||||
else
|
||||
-- This is a sequence.
|
||||
|
||||
-- If it's an empty sequence, then nothing.
|
||||
if #piece == 0 then
|
||||
return 0
|
||||
end
|
||||
|
||||
-- A single separator between each item.
|
||||
result = result + (#piece - 1) * #(piece.sep or SEP)
|
||||
end
|
||||
|
||||
-- For both frames and sequences:
|
||||
-- Find the minimum length of each child.
|
||||
for _, child in ipairs(piece) do
|
||||
result = result + min_len(child, ctx)
|
||||
end
|
||||
|
||||
return result
|
||||
end
|
||||
|
||||
function newline(ctx)
|
||||
ctx.result = ctx.result .. "\n"
|
||||
ctx.line_len = 0
|
||||
write(ctx.next_indent, ctx)
|
||||
end
|
||||
|
||||
function newline_no_indent(ctx)
|
||||
ctx.result = ctx.result .. "\n"
|
||||
ctx.line_len = 0
|
||||
end
|
||||
|
||||
function write(str, ctx)
|
||||
ctx.result = ctx.result .. str
|
||||
ctx.line_len = ctx.line_len + #str
|
||||
end
|
||||
|
||||
function write_nolength(str, ctx)
|
||||
ctx.result = ctx.result .. str
|
||||
end
|
||||
|
||||
function space_here(ctx)
|
||||
return math.max(0, ctx.max_width - ctx.line_len)
|
||||
end
|
||||
|
||||
function space_newline(ctx)
|
||||
return math.max(0, ctx.max_width - #ctx.next_indent)
|
||||
end
|
||||
|
||||
--
|
||||
-- Main function
|
||||
--
|
||||
|
||||
return function(val)
|
||||
if val == nil then
|
||||
print(nil)
|
||||
else
|
||||
local ctx = new_context()
|
||||
local piece = translate(val, ctx)
|
||||
piece = clean(piece, ctx)
|
||||
display(piece, ctx)
|
||||
print(C.e .. ctx.result .. C.e)
|
||||
end
|
||||
end
|
||||
@ -0,0 +1,177 @@
|
||||
--
|
||||
-- https://github.com/rxi/shash
|
||||
--
|
||||
--
|
||||
local shash = {
|
||||
_version = "0.1.1",
|
||||
}
|
||||
shash.__index = shash
|
||||
|
||||
function shash.new(cellsize)
|
||||
local self = setmetatable({}, shash)
|
||||
cellsize = cellsize or 64
|
||||
self.cellsize = cellsize
|
||||
self.tablepool = {}
|
||||
self.cells = {}
|
||||
self.entities = {}
|
||||
return self
|
||||
end
|
||||
|
||||
local function coord_to_key(x, y)
|
||||
return x + y * 1e7
|
||||
end
|
||||
|
||||
local function cell_position(cellsize, x, y)
|
||||
return math.floor(x / cellsize), math.floor(y / cellsize)
|
||||
end
|
||||
|
||||
local function each_overlapping_cell(self, e, fn, ...)
|
||||
local cellsize = self.cellsize
|
||||
local sx, sy = cell_position(cellsize, e[1], e[2])
|
||||
local ex, ey = cell_position(cellsize, e[3], e[4])
|
||||
for y = sy, ey do
|
||||
for x = sx, ex do
|
||||
local idx = coord_to_key(x, y)
|
||||
fn(self, idx, ...)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local function add_entity_to_cell(self, idx, e)
|
||||
if not self.cells[idx] then
|
||||
self.cells[idx] = {e}
|
||||
else
|
||||
table.insert(self.cells[idx], e)
|
||||
end
|
||||
end
|
||||
|
||||
local function remove_entity_from_cell(self, idx, e)
|
||||
local t = self.cells[idx]
|
||||
local n = #t
|
||||
-- Only one entity? Remove entity from cell and remove cell
|
||||
if n == 1 then
|
||||
self.cells[idx] = nil
|
||||
return
|
||||
end
|
||||
-- Find and swap-remove entity
|
||||
for i, v in ipairs(t) do
|
||||
if v == e then
|
||||
t[i] = t[n]
|
||||
t[n] = nil
|
||||
return
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function shash:add(obj, x, y, w, h)
|
||||
-- Create entity. The table is used as an array as this offers a noticable
|
||||
-- performance increase on LuaJIT; the indices are as follows:
|
||||
-- [1] = left, [2] = top, [3] = right, [4] = bottom, [5] = object
|
||||
local e = {x, y, x + w, y + h, obj}
|
||||
-- Add to main entities table
|
||||
self.entities[obj] = e
|
||||
-- Add to cells
|
||||
each_overlapping_cell(self, e, add_entity_to_cell, e)
|
||||
end
|
||||
|
||||
function shash:remove(obj)
|
||||
-- Get entity of obj
|
||||
local e = self.entities[obj]
|
||||
-- Remove from main entities table
|
||||
self.entities[obj] = nil
|
||||
-- Remove from cells
|
||||
each_overlapping_cell(self, e, remove_entity_from_cell, e)
|
||||
end
|
||||
|
||||
function shash:update(obj, x, y, w, h)
|
||||
-- Get entity from obj
|
||||
local e = self.entities[obj]
|
||||
-- No width/height specified? Get width/height from existing bounding box
|
||||
w = w or e[3] - e[1]
|
||||
h = h or e[4] - e[2]
|
||||
-- Check the entity has actually changed cell-position, if it hasn't we don't
|
||||
-- need to touch the cells at all
|
||||
local cellsize = self.cellsize
|
||||
local ax1, ay1 = cell_position(cellsize, e[1], e[2])
|
||||
local ax2, ay2 = cell_position(cellsize, e[3], e[4])
|
||||
local bx1, by1 = cell_position(cellsize, x, y)
|
||||
local bx2, by2 = cell_position(cellsize, x + w, y + h)
|
||||
local dirty = ax1 ~= bx1 or ay1 ~= by1 or ax2 ~= bx2 or ay2 ~= by2
|
||||
-- Remove from old cells
|
||||
if dirty then
|
||||
each_overlapping_cell(self, e, remove_entity_from_cell, e)
|
||||
end
|
||||
-- Update entity
|
||||
e[1], e[2], e[3], e[4] = x, y, x + w, y + h
|
||||
-- Add to new cells
|
||||
if dirty then
|
||||
each_overlapping_cell(self, e, add_entity_to_cell, e)
|
||||
end
|
||||
end
|
||||
|
||||
function shash:clear()
|
||||
-- Clear all cells and entities
|
||||
for k in pairs(self.cells) do
|
||||
self.cells[k] = nil
|
||||
end
|
||||
for k in pairs(self.entities) do
|
||||
self.entities[k] = nil
|
||||
end
|
||||
end
|
||||
|
||||
local function overlaps(e1, e2)
|
||||
return e1[3] > e2[1] and e1[1] < e2[3] and e1[4] > e2[2] and e1[2] < e2[4]
|
||||
end
|
||||
|
||||
local function each_overlapping_in_cell(self, idx, e, set, fn, ...)
|
||||
local t = self.cells[idx]
|
||||
if not t then
|
||||
return
|
||||
end
|
||||
for i, v in ipairs(t) do
|
||||
if e ~= v and overlaps(e, v) and not set[v] then
|
||||
fn(v[5], ...)
|
||||
set[v] = true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local function each_overlapping_entity(self, e, fn, ...)
|
||||
-- Init set for keeping track of which entities have already been handled
|
||||
local set = table.remove(self.tablepool) or {}
|
||||
-- Do overlap checks
|
||||
each_overlapping_cell(self, e, each_overlapping_in_cell, e, set, fn, ...)
|
||||
-- Clear set and return to pool
|
||||
for v in pairs(set) do
|
||||
set[v] = nil
|
||||
end
|
||||
table.insert(self.tablepool, set)
|
||||
end
|
||||
|
||||
function shash:each(x, y, w, h, fn, ...)
|
||||
local e = self.entities[x]
|
||||
if e then
|
||||
-- Got object, use its entity
|
||||
each_overlapping_entity(self, e, y, w, h, fn, ...)
|
||||
else
|
||||
-- Got bounding box, make temporary entity
|
||||
each_overlapping_entity(self, {x, y, x + w, y + h}, fn, ...)
|
||||
end
|
||||
end
|
||||
|
||||
function shash:info(opt, ...)
|
||||
if opt == "cells" or opt == "entities" then
|
||||
local n = 0
|
||||
for _ in pairs(self[opt]) do
|
||||
n = n + 1
|
||||
end
|
||||
return n
|
||||
end
|
||||
if opt == "cell" then
|
||||
local t = self.cells[coord_to_key(...)]
|
||||
return t and #t or 0
|
||||
end
|
||||
error(string.format("invalid opt '%s'", opt))
|
||||
end
|
||||
|
||||
return shash
|
||||
@ -0,0 +1,138 @@
|
||||
------------------
|
||||
-- *treap.lua*, a simple treap data structure implemented in Lua.
|
||||
-- Source on [Github](http://github.com/Yonaba/treap.lua)
|
||||
-- Private definitions
|
||||
local random = math.random
|
||||
|
||||
-- Performs right rotation on node y
|
||||
local function rightRotate(y)
|
||||
local x = y.left
|
||||
local tail = x.right
|
||||
x.right = y
|
||||
y.left = tail
|
||||
return x
|
||||
end
|
||||
|
||||
-- Performs left rotation on node x
|
||||
local function leftRotate(x)
|
||||
local y = x.right
|
||||
local tail = y.left
|
||||
y.left = x
|
||||
x.right = tail
|
||||
return y
|
||||
end
|
||||
|
||||
------------------------------- Module functions ------------------------------
|
||||
|
||||
--- Creates a treap node.
|
||||
-- @name node
|
||||
-- @param key a key
|
||||
-- @param[opt] priority a numeric priority for the given key. Defaults to random value.
|
||||
-- @return a node
|
||||
local function newTreap(key, priority)
|
||||
return {
|
||||
key = key,
|
||||
priority = priority or random(),
|
||||
left = nil,
|
||||
right = nil,
|
||||
}
|
||||
end
|
||||
|
||||
--- Finds a key in the treap
|
||||
-- @name find
|
||||
-- @param root a root node in the treap
|
||||
-- @param key a key
|
||||
-- @return a node (or nil)
|
||||
local function find(root, key)
|
||||
if root == nil or root.key == key then
|
||||
return root
|
||||
end
|
||||
if root.key < key then
|
||||
return find(root.right, key)
|
||||
end
|
||||
return find(root.left, key)
|
||||
end
|
||||
|
||||
--- Inserts a key in the treap
|
||||
-- @name insert
|
||||
-- @param root a root node in the treap
|
||||
-- @param key a key
|
||||
-- @return the root node
|
||||
local function insert(root, key, priority)
|
||||
if root == nil then
|
||||
return newTreap(key, priority)
|
||||
end
|
||||
if key <= root.key then
|
||||
root.left = insert(root.left, key)
|
||||
if root.left.priority > root.priority then
|
||||
root = rightRotate(root)
|
||||
end
|
||||
else
|
||||
root.right = insert(root.right, key)
|
||||
if root.right.priority > root.priority then
|
||||
root = leftRotate(root)
|
||||
end
|
||||
end
|
||||
return root
|
||||
end
|
||||
|
||||
--- Deletes a key in the treap
|
||||
-- @name delete
|
||||
-- @param root a root node in the treap
|
||||
-- @param key a key
|
||||
-- @return the root node
|
||||
local function delete(root, key)
|
||||
if root == nil then
|
||||
return root
|
||||
end
|
||||
if key < root.key then
|
||||
root.left = delete(root.left, key)
|
||||
elseif key > root.key then
|
||||
root.right = delete(root.right, key)
|
||||
elseif root.left == nil then
|
||||
root = root.right
|
||||
elseif root.right == nil then
|
||||
root = root.left
|
||||
elseif root.left.priority < root.right.priority then
|
||||
root = leftRotate(root)
|
||||
root.left = delete(root.left, key)
|
||||
else
|
||||
root = rightRotate(root)
|
||||
root.right = delete(root.right, key)
|
||||
end
|
||||
return root
|
||||
end
|
||||
|
||||
--- In-order traversal. It maps `f (node, ...)` on every node along the traversal.
|
||||
-- @name inorder
|
||||
-- @param root a root node in the treap
|
||||
-- @param f a function, defined as `f (node, ...)`
|
||||
-- @param[opt] ... optional arguments to `f`
|
||||
local function inorder(root, f, ...)
|
||||
if root == nil then
|
||||
return
|
||||
end
|
||||
inorder(root.left, f, ...)
|
||||
f(root, ...)
|
||||
inorder(root.right, f, ...)
|
||||
end
|
||||
|
||||
--- Returns the treap size.
|
||||
-- @name size
|
||||
-- @param root a root node in the treap
|
||||
local function size(root)
|
||||
local n = 0
|
||||
inorder(root, function()
|
||||
n = n + 1
|
||||
end)
|
||||
return n
|
||||
end
|
||||
|
||||
return {
|
||||
new = newTreap,
|
||||
insert = insert,
|
||||
delete = delete,
|
||||
find = find,
|
||||
inorder = inorder,
|
||||
size = size,
|
||||
}
|
||||
Loading…
Reference in New Issue