Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
addc24b60c | ||
|
|
46113fc833 | ||
|
|
34cc6c7481 | ||
|
|
401181824c | ||
|
|
0770c94f84 | ||
|
|
df26351d07 | ||
|
|
98851c8ddd | ||
|
|
c4c7563c20 | ||
|
|
22da143027 | ||
|
|
a3a87aa868 | ||
|
|
9f7f8896f3 | ||
|
|
6e53534df7 | ||
|
|
63367ececb | ||
|
|
e9c6684b40 |
No files matched your search
@@ -0,0 +1,114 @@
|
||||
name: Game updates
|
||||
|
||||
# Arcade follows its games by itself. When a game package (Shovey, Apfelwurm)
|
||||
# publishes a GitHub release, this pins Arcade to that release, adds the
|
||||
# game's notes to Arcade's changelog, builds and checks the collection,
|
||||
# commits the new Arcade version and attaches its catalog and game archive to
|
||||
# the node-arcade-VERSION release. Inner Breeze's node follower then signs
|
||||
# that release and publishes it to Waozi's node, where Arcade downloads games.
|
||||
on:
|
||||
schedule:
|
||||
- cron: '7,22,37,52 * * * *'
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
contents: write
|
||||
|
||||
concurrency:
|
||||
group: arcade-node-release
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
follow:
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
defaults:
|
||||
run:
|
||||
working-directory: waozixyz/arcade
|
||||
steps:
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
|
||||
with:
|
||||
path: waozixyz/arcade
|
||||
- name: Pin the latest game releases
|
||||
id: pin
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
run: |
|
||||
python3 scripts/follow-game-releases.py pin
|
||||
if git diff --quiet -- ziran.lock; then
|
||||
echo "changed=false" >> "$GITHUB_OUTPUT"
|
||||
echo "Arcade already pins every game's latest release."
|
||||
exit 0
|
||||
fi
|
||||
echo "changed=true" >> "$GITHUB_OUTPUT"
|
||||
python3 - <<'PY' >> "$GITHUB_OUTPUT"
|
||||
import json
|
||||
lock = json.load(open('ziran.lock'))
|
||||
shovey = lock['root']['dependencies']['shovey']
|
||||
print('toolchain=' + lock['toolchain']['commit'])
|
||||
print('shovey=' + next(p['commit'] for p in lock['packages'] if p['id'] == shovey))
|
||||
PY
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
|
||||
if: steps.pin.outputs.changed == 'true'
|
||||
with:
|
||||
repository: ziranlang/ziran
|
||||
ref: ${{ steps.pin.outputs.toolchain }}
|
||||
path: ziranlang/ziran
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
|
||||
if: steps.pin.outputs.changed == 'true'
|
||||
with:
|
||||
repository: waozixyz/shovey
|
||||
ref: ${{ steps.pin.outputs.shovey }}
|
||||
path: waozixyz/shovey
|
||||
- name: Install build dependencies
|
||||
if: steps.pin.outputs.changed == 'true'
|
||||
working-directory: .
|
||||
run: sh ziranlang/ziran/scripts/ci_packages.sh build-essential python3-pil python3-cryptography
|
||||
- name: Build the locked toolchain and fetch packages
|
||||
if: steps.pin.outputs.changed == 'true'
|
||||
run: |
|
||||
make -j2 -C ../../ziranlang/ziran
|
||||
echo "$GITHUB_WORKSPACE/ziranlang/ziran/build/bin" >> "$GITHUB_PATH"
|
||||
# The game is generated in its own checkout at the pinned release.
|
||||
printf '[overrides]\nshovey = "../shovey"\nziran = "../../ziranlang/ziran"\n' > ziran.local.toml
|
||||
../../ziranlang/ziran/build/bin/ziran fetch
|
||||
- name: Write the Arcade release
|
||||
id: release
|
||||
if: steps.pin.outputs.changed == 'true'
|
||||
run: |
|
||||
python3 scripts/follow-game-releases.py changelog --ziran ../../ziranlang/ziran/build/bin/ziran
|
||||
sh update_version.sh
|
||||
python3 scripts/follow-game-releases.py art
|
||||
echo "version=$(cat VERSION)" >> "$GITHUB_OUTPUT"
|
||||
head -12 CHANGELOG.md
|
||||
- name: Build and check the collection
|
||||
if: steps.pin.outputs.changed == 'true'
|
||||
run: |
|
||||
make -C ../shovey levels landscape
|
||||
make collection
|
||||
python3 tests/collection_test.py
|
||||
python3 tests/publisher_test.py
|
||||
- name: Commit the release
|
||||
id: commit
|
||||
if: steps.pin.outputs.changed == 'true'
|
||||
env:
|
||||
VERSION: ${{ steps.release.outputs.version }}
|
||||
run: |
|
||||
git config user.name Waozi
|
||||
git config user.email [email protected]
|
||||
git add ziran.lock CHANGELOG.md VERSION apps/versions.json assets/arcade/library
|
||||
git commit -q -m "Release Arcade $VERSION with the latest game releases"
|
||||
git push origin HEAD:master
|
||||
echo "sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
|
||||
- name: Attach the checked catalog and game archive
|
||||
if: steps.pin.outputs.changed == 'true'
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
VERSION: ${{ steps.release.outputs.version }}
|
||||
SHA: ${{ steps.commit.outputs.sha }}
|
||||
run: |
|
||||
set -eu
|
||||
gh release create "node-arcade-$VERSION" build/node-apps/arcade.zx build/node-apps/arcade.games.tar build/games/wurm.zx \
|
||||
--target "$SHA" --title "Arcade $VERSION" \
|
||||
--notes 'Arcade downloads the selected game separately and preserves earned progress.'
|
||||
echo "Arcade $VERSION is ready for the node: sha256 $(sha256sum build/node-apps/arcade.zx | cut -d' ' -f1)"
|
||||
@@ -69,7 +69,24 @@ jobs:
|
||||
make collection
|
||||
python3 tests/collection_test.py
|
||||
python3 tests/publisher_test.py
|
||||
# The candidate's digest, so a local check can compare the exact bytes.
|
||||
sha256sum build/node-apps/arcade.zx
|
||||
echo "$EXPECTED_SHA256 build/node-apps/arcade.zx" | sha256sum --check --strict
|
||||
# When the digest is not the expected one, keep the candidate for a local
|
||||
# check; nothing is published.
|
||||
- name: Keep the unpublished candidate
|
||||
if: failure()
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: arcade-candidate
|
||||
path: |
|
||||
waozixyz/arcade/build/node-apps/arcade.zx
|
||||
waozixyz/arcade/build/node-apps/arcade.json
|
||||
waozixyz/arcade/build/node-apps/arcade.games.tar
|
||||
waozixyz/arcade/build/games/wurm.zx
|
||||
waozixyz/arcade/build/apps-ui/apps.zx
|
||||
if-no-files-found: ignore
|
||||
retention-days: 1
|
||||
- name: Publish the checked catalog and game archive
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
name: Website
|
||||
|
||||
# https://arcade.waozi.xyz runs Arcade in the browser: the latest published
|
||||
# arcade.zx, the same one Inner Breeze downloads, with Arcade's own host
|
||||
# compiled to WebAssembly. Every push to master and every Arcade release,
|
||||
# manual or automatic, rebuilds and publishes it.
|
||||
on:
|
||||
push:
|
||||
branches: [master]
|
||||
workflow_run:
|
||||
workflows: [Arcade node release, Game updates]
|
||||
types: [completed]
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
# A running build finishes; only the newest waiting one follows it.
|
||||
concurrency:
|
||||
group: arcade-site
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
build:
|
||||
if: github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success'
|
||||
runs-on: ubuntu-24.04
|
||||
timeout-minutes: 45
|
||||
defaults:
|
||||
run:
|
||||
working-directory: waozixyz/arcade
|
||||
steps:
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
|
||||
with:
|
||||
path: waozixyz/arcade
|
||||
ref: master
|
||||
fetch-depth: 0
|
||||
- name: Read the locked toolchain
|
||||
id: toolchain
|
||||
run: |
|
||||
python3 -c 'import json,os; open(os.environ["GITHUB_OUTPUT"],"a").write("commit="+json.load(open("ziran.lock"))["toolchain"]["commit"]+"\n")'
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
|
||||
with:
|
||||
repository: ziranlang/ziran
|
||||
ref: ${{ steps.toolchain.outputs.commit }}
|
||||
path: ziranlang/ziran
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: 22
|
||||
- name: Install build dependencies
|
||||
working-directory: .
|
||||
run: sh ziranlang/ziran/scripts/ci_packages.sh build-essential cmake pkg-config
|
||||
- uses: mymindstorm/setup-emsdk@v14
|
||||
with:
|
||||
version: '6.0.6'
|
||||
actions-cache-folder: emsdk-cache
|
||||
- name: Build the locked toolchain and fetch packages
|
||||
run: |
|
||||
make -j2 -C ../../ziranlang/ziran
|
||||
echo "$GITHUB_WORKSPACE/ziranlang/ziran/build/bin" >> "$GITHUB_PATH"
|
||||
printf '[overrides]\nziran = "../../ziranlang/ziran"\n' > ziran.local.toml
|
||||
../../ziranlang/ziran/build/bin/ziran fetch
|
||||
- name: Download the published Arcade
|
||||
id: published
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
run: |
|
||||
tag=$(gh release list --repo waozixyz/arcade --limit 50 --json tagName,isDraft \
|
||||
-q '[.[] | select(.isDraft | not) | .tagName | select(startswith("node-arcade-"))][0]')
|
||||
test -n "$tag"
|
||||
mkdir -p build/published
|
||||
gh release download "$tag" --repo waozixyz/arcade --pattern arcade.zx --dir build/published
|
||||
# The Apps library that release packs, by the digest its own commit trusts.
|
||||
git show "$tag:apps-controller.sha256" > build/published/apps-controller.sha256
|
||||
echo "version=${tag#node-arcade-}" >> "$GITHUB_OUTPUT"
|
||||
- name: Build the browser edition
|
||||
run: |
|
||||
python3 scripts/build-entity.py
|
||||
python3 scripts/build-apps.py --output build/apps-ui
|
||||
python3 scripts/build-web.py --bundle build/published/arcade.zx \
|
||||
--controller-sha256 "$(cat build/published/apps-controller.sha256)" \
|
||||
--version '${{ steps.published.outputs.version }}'
|
||||
rm -f build/web-site/runtime.html
|
||||
- name: Open Arcade in a private browser
|
||||
run: |
|
||||
export CHROMIUM="$(command -v google-chrome || command -v chromium)"
|
||||
env -u DISPLAY -u WAYLAND_DISPLAY -u XAUTHORITY -u DBUS_SESSION_BUS_ADDRESS node tests/web_site_test.mjs build/web-site
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: arcade-site
|
||||
path: waozixyz/arcade/build/web-site
|
||||
retention-days: 1
|
||||
|
||||
deploy:
|
||||
needs: build
|
||||
runs-on: ubuntu-24.04
|
||||
timeout-minutes: 10
|
||||
environment:
|
||||
name: cloudflare-pages
|
||||
url: https://arcade.waozi.xyz
|
||||
steps:
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
|
||||
with:
|
||||
ref: master
|
||||
- uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: arcade-site
|
||||
path: build/web-site
|
||||
- name: Prepare the Pages project
|
||||
env:
|
||||
CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
|
||||
CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
|
||||
run: python3 scripts/cloudflare-site.py prepare
|
||||
- name: Deploy to Cloudflare Pages
|
||||
uses: cloudflare/wrangler-action@v3
|
||||
with:
|
||||
apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
|
||||
accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
|
||||
command: pages deploy build/web-site --project-name=arcade --branch=master --commit-hash=${{ github.sha }}
|
||||
- name: Connect arcade.waozi.xyz
|
||||
env:
|
||||
CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
|
||||
CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
|
||||
run: python3 scripts/cloudflare-site.py connect
|
||||
@@ -1,5 +1,25 @@
|
||||
# Arcade changelog
|
||||
|
||||
## 0.7.80
|
||||
|
||||
- Keep games covered until their first board is ready and keep complete pictures visible while animation sprites load.
|
||||
- Shovey’s secret chest reopens for unclaimed Dew and shows an empty chest after a confirmed claim.
|
||||
|
||||
## 0.7.79
|
||||
|
||||
- On phones the library shows small covers, two or three in a row.
|
||||
|
||||
## 0.7.78
|
||||
|
||||
- Download Arcade itself in under one megabyte: it lists the games, and their covers and each game arrive separately when you need them.
|
||||
- Covers show only the game art; the download dialog shows the size.
|
||||
- Shovey Editor downloads as a small add-on that reuses Shovey’s game.
|
||||
|
||||
## 0.7.77
|
||||
|
||||
- Apfelwurm 0.1.4: Press Play and go straight into the game: no stage or level select. Play every level in order through all five landscapes, earning lives as your score grows; a game over starts again from level 1.
|
||||
- Apfelwurm 0.1.4: Continue your run from the start of the level you reached; existing stage progress continues from your first uncleared level.
|
||||
|
||||
## 0.7.76
|
||||
|
||||
- Install Shovey Editor as an add-on and reuse Shovey’s art and sounds.
|
||||
|
||||
@@ -63,6 +63,7 @@ test: all
|
||||
sh tests/chess_engine_zi_test.sh '$(ZIRAN)'
|
||||
sh tests/chess_app_test.sh '$(ZIRAN)'
|
||||
python3 tests/sound_test.py
|
||||
sh tests/collection_loading_test.sh
|
||||
|
||||
chess-engine-test:
|
||||
sh tests/chess_engine_zi_test.sh '$(ZIRAN)'
|
||||
@@ -110,6 +111,7 @@ install-arcade: collection build/entity.zx build/arcade
|
||||
install -m 0755 build/arcade '$(LIB_DIR)/arcade.new'
|
||||
mv -f '$(LIB_DIR)/arcade.new' '$(LIB_DIR)/arcade'
|
||||
install -m 0644 build/entity.zx build/arcade.zx build/arcade.json '$(LIB_DIR)/'
|
||||
install -m 0644 '$(APPS_BUNDLE)' '$(LIB_DIR)/apps.zx'
|
||||
ln -sfn '$(LIB_DIR)/arcade' '$(BIN_DIR)/arcade'
|
||||
install -m 0644 packaging/xyz.waozi.arcade.desktop '$(DATA_DIR)/applications/'
|
||||
|
||||
@@ -122,6 +124,7 @@ install: all install-arcade
|
||||
install -m 0755 build/shovey '$(LIB_DIR)/shovey.new'
|
||||
mv -f '$(LIB_DIR)/shovey.new' '$(LIB_DIR)/shovey'
|
||||
install -m 0644 build/entity.zx build/arcade.zx build/arcade.json build/shovey.zx build/shovey.json '$(LIB_DIR)/'
|
||||
install -m 0644 '$(APPS_BUNDLE)' '$(LIB_DIR)/apps.zx'
|
||||
ln -sfn '$(LIB_DIR)/arcade' '$(BIN_DIR)/arcade'
|
||||
ln -sfn '$(LIB_DIR)/shovey' '$(BIN_DIR)/shovey'
|
||||
mkdir -p '$(DATA_DIR)/icons/hicolor/256x256/apps'
|
||||
|
||||
@@ -11,7 +11,7 @@ existing saved games remain available for a later return.
|
||||
Each edition has a separate save and earned unlocks. Unlocked puzzles show
|
||||
their whole board; locked puzzles keep their lock until earned.
|
||||
|
||||
Arcade carries only its catalog and covers first. Each game
|
||||
The published Arcade carries only its catalog, well under one megabyte. Its host supplies the shared Apps controller (Inner Breeze its own, standalone Arcade the `apps.zx` installed beside it), and the covers and previews download once as one separate art bundle: small copies of each game's art in `assets/arcade/library/` (`python3 scripts/library-art.py` refreshes them when a game's art changes; the build stops until it does). Inner Breeze needs host interface 35 for it. Each game
|
||||
downloads when opened, with its existing identity and saved progress. This
|
||||
catalog requires Inner Breeze host API 34. Downloaded games work offline;
|
||||
standalone Shovey keeps its complete offline collection. Apfelwurm comes from
|
||||
@@ -81,6 +81,22 @@ bundle, so Inbe supplies its existing profile and account. Inbe retains its
|
||||
existing game sync and friend games. Arcade and Inbe keep separate
|
||||
saved games; this version does not migrate or synchronize games between them.
|
||||
|
||||
## Website
|
||||
|
||||
https://arcade.waozi.xyz runs Arcade in the browser: the latest published
|
||||
`arcade.zx`, the same collection Inner Breeze downloads, with Arcade's own host
|
||||
(`src/web/runtime.zi`) compiled to WebAssembly by Entity's web build. Games
|
||||
download from the node when someone opens them; saves stay in the browser.
|
||||
`.github/workflows/site.yml` rebuilds and publishes it after every push to
|
||||
master and every Arcade release, after `tests/web_site_test.mjs` opens the
|
||||
library in a private browser. `scripts/cloudflare-site.py` creates the Pages
|
||||
project and connects the domain with the repository's `CLOUDFLARE_API_TOKEN`
|
||||
and `CLOUDFLARE_ACCOUNT_ID` secrets.
|
||||
|
||||
Build it locally from this checkout's collection with `make collection`,
|
||||
`python3 scripts/build-entity.py` and `python3 scripts/build-web.py`, then serve
|
||||
`build/web-site`.
|
||||
|
||||
## Build and run
|
||||
|
||||
Dependencies are Git repositories pinned in `ziran.lock`. The toolchain
|
||||
|
||||
@@ -1 +1 @@
|
||||
5490a8e61f5fa218e813b6e3d78bece6198d2ed935c42fc77b7d5e4aeed9bfe3
|
||||
a99851fc40d67a8ca820841722ce2ddde5ca51844e0778c4762681570c488289
|
||||
@@ -13,8 +13,8 @@
|
||||
"shovey": {
|
||||
"id": "arcade.shovey",
|
||||
"title": "Shovey",
|
||||
"version": "0.6.148",
|
||||
"sequence": 156,
|
||||
"version": "0.6.149",
|
||||
"sequence": 157,
|
||||
"host_api": 12
|
||||
},
|
||||
"shovey-island": {
|
||||
@@ -27,22 +27,22 @@
|
||||
"shovey-editor": {
|
||||
"id": "arcade.shovey-editor",
|
||||
"title": "Shovey Editor",
|
||||
"version": "0.2.140",
|
||||
"sequence": 142,
|
||||
"version": "0.2.141",
|
||||
"sequence": 143,
|
||||
"host_api": 12
|
||||
},
|
||||
"arcade": {
|
||||
"id": "inbe.arcade",
|
||||
"title": "Arcade",
|
||||
"version": "0.7.76",
|
||||
"sequence": 155,
|
||||
"host_api": 33
|
||||
"version": "0.7.80",
|
||||
"sequence": 159,
|
||||
"host_api": 35
|
||||
},
|
||||
"wurm": {
|
||||
"id": "xyz.waozi.wurm",
|
||||
"title": "Apfelwurm",
|
||||
"version": "0.1.2",
|
||||
"sequence": 2,
|
||||
"version": "0.1.4",
|
||||
"sequence": 3,
|
||||
"host_api": 12
|
||||
}
|
||||
}
|
||||
|
||||
|
After Width: | Height: | Size: 368 KiB |
|
After Width: | Height: | Size: 59 KiB |
|
After Width: | Height: | Size: 376 KiB |
|
After Width: | Height: | Size: 12 KiB |
|
After Width: | Height: | Size: 345 KiB |
|
After Width: | Height: | Size: 48 KiB |
|
After Width: | Height: | Size: 332 KiB |
|
After Width: | Height: | Size: 5.4 KiB |
@@ -0,0 +1,35 @@
|
||||
{
|
||||
"shovey-editor-landscape": {
|
||||
"source_sha256": "7b1eae4209ede14807806a4cbce1e2bf7a14d342e75c89042958a524cf60d67e"
|
||||
},
|
||||
"shovey-editor-logo": {
|
||||
"source_sha256": "5417341ed432c49d4ce1df45e5e6bf7e07e11a81face45cb93d7cc9fa976f7a5"
|
||||
},
|
||||
"shovey-editor-portrait": {
|
||||
"source_sha256": "bf0bbeb15249f3d73c1b410e9737f7fd207310dcb5f28b7c3ce45401b77c8f9e"
|
||||
},
|
||||
"shovey-editor-preview": {
|
||||
"source_sha256": "1846b823110fffe82a3dbb319960ce768eefc16699d507d48b8608151eaff430"
|
||||
},
|
||||
"shovey-landscape": {
|
||||
"source_sha256": "40c01eb8300e4c5db52b2d75373e17cdaf7f68140c33c0a225613fc174660747"
|
||||
},
|
||||
"shovey-logo": {
|
||||
"source_sha256": "e47781aa3328f68077589f95d813e9c2e6fff10ebd62a9d003773bb2c2f7a092"
|
||||
},
|
||||
"shovey-portrait": {
|
||||
"source_sha256": "ddcbf989eab5971157d8cdc73494ed03660bb4c7a7679543248f45be260777e3"
|
||||
},
|
||||
"shovey-preview": {
|
||||
"source_sha256": "b1f2e5662cb96f2f5062cb0e5a8cd8ede153173ebc32ad17e26b404f3baf5924"
|
||||
},
|
||||
"wurm-landscape": {
|
||||
"source_sha256": "472773b7c106325e12777a81a29209496e22e0853782ca76955b6587824b1b30"
|
||||
},
|
||||
"wurm-portrait": {
|
||||
"source_sha256": "e8962c969f554567d598eb0b54db5836f7f1ed7462619463040c6cc2887a5a47"
|
||||
},
|
||||
"wurm-preview": {
|
||||
"source_sha256": "472773b7c106325e12777a81a29209496e22e0853782ca76955b6587824b1b30"
|
||||
}
|
||||
}
|
||||
|
After Width: | Height: | Size: 561 KiB |
|
After Width: | Height: | Size: 497 KiB |
|
After Width: | Height: | Size: 110 KiB |
@@ -87,7 +87,15 @@ Host API numbers alone do not prove compatibility: the intended host must
|
||||
also understand the bundle's VM format. Test each platform and oldest host
|
||||
version a release is intended to support. An unsupported VM format requires
|
||||
a compatible build or a host update; never relabel a package to bypass it.
|
||||
Passing checks prepares a release; the owner still approves publication.
|
||||
Passing checks prepares a release.
|
||||
|
||||
Game releases reach Arcade players automatically. Every fifteen minutes the
|
||||
Game updates workflow compares each game package's latest published GitHub
|
||||
release with Arcade's pin (`scripts/follow-game-releases.py`). For a newer
|
||||
version it pins that release, adds the game's notes as a new Arcade version,
|
||||
builds and checks the collection, commits it and attaches the catalog to the
|
||||
`node-arcade-VERSION` release. Inner Breeze's Node app follower then signs
|
||||
that release and publishes it to Waozi's node.
|
||||
|
||||
Chess 1.1.0 requires host API 12. Public Inbe 2.1.34 supplies API 11 and
|
||||
predates installable Chess apps, so it is outside the declared range. The
|
||||
|
||||
@@ -21,6 +21,18 @@ def digest(path):
|
||||
return hashlib.sha256(path.read_bytes()).hexdigest()
|
||||
|
||||
|
||||
def library_art(root, name, key, source):
|
||||
"""Arcade's committed small copy of a game's art (scripts/library-art.py).
|
||||
The library shows art, the games download separately: never pack the
|
||||
packages' full-size images, and never pack a copy of outdated art."""
|
||||
library = Path(root) / "assets/arcade/library"
|
||||
sources = json.loads((library / "sources.json").read_text())
|
||||
copy = f"{name}-{key}"
|
||||
if sources.get(copy, {}).get("source_sha256") != hashlib.sha256(source).hexdigest():
|
||||
raise ValueError(f"{copy} art changed; run scripts/library-art.py")
|
||||
return (library / f"{copy}.png").read_bytes()
|
||||
|
||||
|
||||
def stage(root, controller, expected_controller_digest, output):
|
||||
"""Validate before replacing a previously staged collection. Returns the
|
||||
catalog and each game package with the IDs of its packed apps."""
|
||||
@@ -64,6 +76,7 @@ def stage(root, controller, expected_controller_digest, output):
|
||||
bundle_bytes, preview_bytes = bundle.read_bytes(), preview.read_bytes()
|
||||
if not bundle_bytes or not preview_bytes:
|
||||
raise ValueError("Game bundles and previews must be built first")
|
||||
preview_bytes = library_art(root, name, "preview", preview_bytes)
|
||||
total += len(bundle_bytes) + len(preview_bytes)
|
||||
child = dict(
|
||||
id=identifier, title=game["title"],
|
||||
@@ -73,6 +86,9 @@ def stage(root, controller, expected_controller_digest, output):
|
||||
bytes=len(bundle_bytes),
|
||||
preview=f"assets/arcade/previews/{name}.png",
|
||||
icon=f"assets/arcade/previews/{name}.png")
|
||||
# A thin add-on links its required games' verified code as libraries.
|
||||
if app.get('shared_code'):
|
||||
child['shared_code'] = True
|
||||
if app.get('requires'):
|
||||
shared = json.loads((root / 'build/games' / (name + '-resources.json')).read_text())
|
||||
if shared['dependencies'] != app['requires']:
|
||||
@@ -90,7 +106,7 @@ def stage(root, controller, expected_controller_digest, output):
|
||||
relative = Path(cover[key])
|
||||
if relative.is_absolute() or ".." in relative.parts or relative.suffix != ".png":
|
||||
raise ValueError("Invalid cover asset path")
|
||||
contents = (app["source"] / relative).read_bytes()
|
||||
contents = library_art(root, name, key, (app["source"] / relative).read_bytes())
|
||||
destination = Path("arcade/covers") / f"{name}-{key}.png"
|
||||
packed_cover[key] = "assets/" + destination.as_posix()
|
||||
copies.append((contents, destination))
|
||||
@@ -122,11 +138,14 @@ def stage(root, controller, expected_controller_digest, output):
|
||||
return catalog, packages[1:]
|
||||
|
||||
|
||||
def stage_downloads(catalog, source, output, games):
|
||||
"""Keep Arcade's catalog and art together; serve each game separately.
|
||||
def stage_downloads(catalog, source, output, games, art):
|
||||
"""Keep only Arcade's catalog; serve each game and the library art separately.
|
||||
|
||||
The full staging directory is also used by standalone players, which
|
||||
keep their bundled games. Validate every game before replacing outputs.
|
||||
The published Arcade is a launcher: the host supplies the shared Apps
|
||||
controller, and the games' covers and previews go to ART for one separate
|
||||
download. The full staging directory is also used by standalone players,
|
||||
which keep their bundled games, art and controller. Validate every game
|
||||
before replacing outputs.
|
||||
"""
|
||||
payloads = {}
|
||||
for child in catalog["children"]:
|
||||
@@ -134,17 +153,38 @@ def stage_downloads(catalog, source, output, games):
|
||||
if hashlib.sha256(data).hexdigest() != child["sha256"]:
|
||||
raise ValueError("Game differs from the collection's declared digest")
|
||||
payloads[child["sha256"]] = data
|
||||
for directory in (output, games):
|
||||
for directory in (output, games, art):
|
||||
if directory.exists():
|
||||
shutil.rmtree(directory)
|
||||
shutil.copytree(source, output)
|
||||
games.mkdir(parents=True)
|
||||
(output / catalog["harness"]).unlink()
|
||||
for child in catalog["children"]:
|
||||
(output / child["bundle"]).unlink()
|
||||
pictures = [child["preview"]] + [path for key, path in child.get("cover", {}).items()
|
||||
if key in ("portrait", "landscape", "logo")]
|
||||
for relative in pictures:
|
||||
if not (output / relative).exists():
|
||||
continue
|
||||
destination = art / relative
|
||||
destination.parent.mkdir(parents=True, exist_ok=True)
|
||||
shutil.move(output / relative, destination)
|
||||
for digest, data in payloads.items():
|
||||
(games / (digest + ".zx")).write_bytes(data)
|
||||
|
||||
|
||||
def add_art(output, games, art_bundle):
|
||||
"""Publish the art bundle beside the games and name it in the catalog."""
|
||||
data = art_bundle.read_bytes()
|
||||
digest = hashlib.sha256(data).hexdigest()
|
||||
(games / (digest + ".zx")).write_bytes(data)
|
||||
path = output / "assets/apps/catalog.json"
|
||||
catalog = json.loads(path.read_text())
|
||||
catalog["art"] = dict(sha256=digest, bytes=len(data))
|
||||
path.write_text(json.dumps(catalog, indent=2) + "\n")
|
||||
return catalog["art"]
|
||||
|
||||
|
||||
def archive_downloads(games, archive):
|
||||
"""The release asset contains only the immutable game payloads."""
|
||||
with tarfile.open(archive, "w") as output:
|
||||
@@ -204,18 +244,24 @@ def main():
|
||||
sha256=digest(ROOT / f"build/{name}.zx"), apps_sha256=args.apps_sha256,
|
||||
children=children, source_mode="project")
|
||||
(ROOT / f"build/{name}.json").write_text(json.dumps(metadata, indent=2) + "\n")
|
||||
# Arcade carries the catalog and artwork. Standalone players keep their
|
||||
# offline games; Arcade downloads exactly the game the person selects.
|
||||
# Arcade carries only its catalog. Standalone players keep their offline
|
||||
# games; Arcade downloads the library art once and exactly the game the
|
||||
# person selects.
|
||||
node_apps = ROOT / "build/node-apps"
|
||||
catalog_assets = node_apps / "arcade-catalog"
|
||||
game_downloads = node_apps / "arcade.games"
|
||||
stage_downloads(catalog, output, catalog_assets, game_downloads)
|
||||
art_assets = node_apps / "arcade-art"
|
||||
stage_downloads(catalog, output, catalog_assets, game_downloads, art_assets)
|
||||
bundle("art.zi", "art:Main", art_assets / "assets", node_apps / "arcade-art.zx")
|
||||
art = add_art(catalog_assets, game_downloads, node_apps / "arcade-art.zx")
|
||||
archive_downloads(game_downloads, node_apps / "arcade.games.tar")
|
||||
bundle("collection.zi", "collection:Main", catalog_assets / "assets", node_apps / "arcade.zx")
|
||||
shutil.copyfile(node_apps / "arcade.zx", ROOT / "build/arcade.zx")
|
||||
# The desktop host supplies its controller from beside the collection.
|
||||
shutil.copyfile(args.apps_bundle, ROOT / "build/apps.zx")
|
||||
receipt = dict(id=catalog["id"], version=(ROOT / "VERSION").read_text().strip(),
|
||||
sha256=digest(ROOT / "build/arcade.zx"),
|
||||
apps_sha256=args.apps_sha256, children=catalog["children"],
|
||||
apps_sha256=args.apps_sha256, children=catalog["children"], art=art,
|
||||
source_mode="project")
|
||||
(output / "receipt.json").write_text(json.dumps(receipt, indent=2) + "\n")
|
||||
(ROOT / "build/arcade.json").write_text(json.dumps(receipt, indent=2) + "\n")
|
||||
|
||||
@@ -49,6 +49,7 @@ def build(ziran, lock_flags):
|
||||
crypto = dependency("crypto", daochi_client)
|
||||
entries = []
|
||||
apps = dependency_order(declared_apps(ROOT, ziran, lock_flags))
|
||||
by_id = {app['descriptor']['id']: app for app in apps}
|
||||
for app in apps:
|
||||
source, manifest, descriptor = app["source"], app["manifest"], app["descriptor"]
|
||||
if descriptor["kind"] != "game" or "arcade" not in descriptor["harnesses"]:
|
||||
@@ -140,6 +141,10 @@ def build(ziran, lock_flags):
|
||||
"--module-path", "daochi_client=" + str(daochi_client),
|
||||
"--module-path", "crypto=" + str(crypto / "src"),
|
||||
*[flag for name in defines for flag in ('--define', name)],
|
||||
*[flag for entry in app['library_entries'] for flag in ('--retain', entry)],
|
||||
*[flag for dependency_id in app['requires'] if app['shared_code']
|
||||
for flag in ('--library', str(ROOT / 'build/games' /
|
||||
(by_id[dependency_id]['descriptor']['name'] + '.zx')))],
|
||||
"--define", "KRYON_HOSTED_UI", "--asset-dir", "assets=" + str(staged / "assets"),
|
||||
"--entry", descriptor["entry"], "-o", str(bundle),
|
||||
str(source / descriptor["source"])], cwd=ROOT, check=True)
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Build Arcade's browser edition into build/web-site.
|
||||
|
||||
The page runs a collection, by default this checkout's build/node-apps/arcade.zx;
|
||||
the website passes the published one Inner Breeze downloads. Arcade's own host
|
||||
is compiled to WebAssembly with the account Profile. The receipt names the
|
||||
collection's digest and the Apps library it trusts. Arcade's own copy of that
|
||||
library goes beside it for collections that do not pack one.
|
||||
"""
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
ZIRAN = str(ROOT / 'scripts/ziran.sh')
|
||||
|
||||
|
||||
def package(name):
|
||||
flags = [] if (ROOT / 'ziran.local.toml').exists() else ['--locked']
|
||||
return Path(subprocess.check_output([ZIRAN, 'pkg', 'path', name, *flags], cwd=ROOT, text=True).strip())
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--bundle', type=Path, default=ROOT / 'build/node-apps/arcade.zx')
|
||||
parser.add_argument('--controller-sha256', default=(ROOT / 'apps-controller.sha256').read_text().strip())
|
||||
parser.add_argument('--version', default=(ROOT / 'VERSION').read_text().strip())
|
||||
parser.add_argument('--profile', type=Path, default=ROOT / 'build/entity.zx')
|
||||
parser.add_argument('--controller', type=Path, default=ROOT / 'build/apps-ui/apps.zx')
|
||||
parser.add_argument('--output', type=Path, default=ROOT / 'build/web-site')
|
||||
args = parser.parse_args()
|
||||
bundle = args.bundle.resolve()
|
||||
receipt = dict(id='inbe.arcade', version=args.version,
|
||||
sha256=hashlib.sha256(bundle.read_bytes()).hexdigest(),
|
||||
apps_sha256=args.controller_sha256)
|
||||
work = ROOT / 'build/web'
|
||||
work.mkdir(parents=True, exist_ok=True)
|
||||
env = {**os.environ, 'ZIRAN': str(package('ziran') / 'build/bin/ziran')}
|
||||
subprocess.run([sys.executable, str(package('entity') / 'scripts/build-web.py'),
|
||||
'--bundle', str(bundle), '--profile', str(args.profile.resolve()),
|
||||
'--output', str(work / 'runtime.html'),
|
||||
'--entry', 'runtime:main', '--source', 'src/web/runtime.zi'], cwd=ROOT, env=env, check=True)
|
||||
output = args.output.resolve()
|
||||
if output.exists():
|
||||
shutil.rmtree(output)
|
||||
shutil.copytree(ROOT / 'site', output)
|
||||
for name in ('runtime.js', 'runtime.wasm', 'runtime.data'):
|
||||
shutil.copyfile(work / name, output / name)
|
||||
(output / 'arcade.json').write_text(json.dumps(receipt, indent=2) + '\n')
|
||||
# Only the library the receipt trusts; the host refuses any other.
|
||||
controller = args.controller.read_bytes() if args.controller.is_file() else b''
|
||||
if hashlib.sha256(controller).hexdigest() == args.controller_sha256:
|
||||
(output / 'apps.zx').write_bytes(controller)
|
||||
else:
|
||||
print('No matching Apps controller beside the collection; it must pack its own')
|
||||
print(f'Arcade {args.version} for the browser in {output}')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,74 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Keep Arcade's Cloudflare Pages project and arcade.waozi.xyz in place.
|
||||
|
||||
`prepare` creates the `arcade` Pages project when it is missing, before the
|
||||
first deployment. `connect` adds arcade.waozi.xyz to the project and points
|
||||
its DNS at the project. Both are safe to repeat on every deployment. They read
|
||||
CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID and never print the token.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
PROJECT = 'arcade'
|
||||
DOMAIN = 'arcade.waozi.xyz'
|
||||
ZONE = 'waozi.xyz'
|
||||
|
||||
|
||||
def api(method, path, body=None):
|
||||
request = urllib.request.Request('https://api.cloudflare.com/client/v4' + path, method=method,
|
||||
data=None if body is None else json.dumps(body).encode(),
|
||||
headers={'Authorization': 'Bearer ' + os.environ['CLOUDFLARE_API_TOKEN'], 'Content-Type': 'application/json'})
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=40) as response:
|
||||
return response.status, json.load(response)
|
||||
except urllib.error.HTTPError as error:
|
||||
return error.code, json.loads(error.read() or b'{}')
|
||||
|
||||
|
||||
def result(method, path, body=None):
|
||||
status, data = api(method, path, body)
|
||||
if not data.get('success'):
|
||||
raise SystemExit(f'Cloudflare {method} {path} failed ({status}): {data.get("errors")}')
|
||||
return data['result']
|
||||
|
||||
|
||||
def prepare(account):
|
||||
status, data = api('GET', f'/accounts/{account}/pages/projects/{PROJECT}')
|
||||
if data.get('success'):
|
||||
print(f'Pages project {PROJECT} exists.')
|
||||
return
|
||||
if status != 404:
|
||||
raise SystemExit(f'Could not read Pages project {PROJECT} ({status}): {data.get("errors")}')
|
||||
result('POST', f'/accounts/{account}/pages/projects', {'name': PROJECT, 'production_branch': 'master'})
|
||||
print(f'Created Pages project {PROJECT}.')
|
||||
|
||||
|
||||
def connect(account):
|
||||
project = result('GET', f'/accounts/{account}/pages/projects/{PROJECT}')
|
||||
domains = result('GET', f'/accounts/{account}/pages/projects/{PROJECT}/domains')
|
||||
if not any(domain['name'] == DOMAIN for domain in domains):
|
||||
result('POST', f'/accounts/{account}/pages/projects/{PROJECT}/domains', {'name': DOMAIN})
|
||||
print(f'Added {DOMAIN} to Pages project {PROJECT}.')
|
||||
zones = result('GET', f'/zones?name={ZONE}')
|
||||
if len(zones) != 1:
|
||||
raise SystemExit(f'Expected one {ZONE} zone, found {len(zones)}')
|
||||
zone = zones[0]['id']
|
||||
records = result('GET', f'/zones/{zone}/dns_records?name={DOMAIN}')
|
||||
if not records:
|
||||
result('POST', f'/zones/{zone}/dns_records',
|
||||
{'type': 'CNAME', 'name': DOMAIN, 'content': project['subdomain'], 'proxied': True, 'ttl': 1})
|
||||
print(f'Pointed {DOMAIN} at {project["subdomain"]}.')
|
||||
elif not (len(records) == 1 and records[0]['type'] == 'CNAME' and records[0]['content'] == project['subdomain']):
|
||||
# Never overwrite a record someone else made.
|
||||
raise SystemExit(f'{DOMAIN} already has DNS records that do not point at {project["subdomain"]}')
|
||||
print(f'{DOMAIN} serves Pages project {PROJECT}.')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if len(sys.argv) != 2 or sys.argv[1] not in {'prepare', 'connect'}:
|
||||
raise SystemExit('Usage: cloudflare-site.py prepare|connect')
|
||||
account = os.environ['CLOUDFLARE_ACCOUNT_ID']
|
||||
{'prepare': prepare, 'connect': connect}[sys.argv[1]](account)
|
||||
@@ -0,0 +1,160 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Follow the published releases of Arcade's game packages.
|
||||
|
||||
`pin` moves each game package in ziran.lock to the commit of its repository's
|
||||
latest published GitHub release, when that commit is ahead of the current pin.
|
||||
Only the game's own entry changes: its dependencies keep Arcade's pins, so the
|
||||
games build against the same Kryon and Apps as Arcade. The ids and layout are
|
||||
the ones `ziran lock` writes. The updates are recorded in build/game-updates.json.
|
||||
|
||||
`changelog` adds an Arcade release entry naming each updated game with the
|
||||
notes of its newest release, for update_version.sh to synchronize.
|
||||
|
||||
`art` remakes the library's small copies of game art (scripts/library-art.py)
|
||||
only when a game's art changed, so unchanged copies keep their bytes.
|
||||
"""
|
||||
import argparse
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import json
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
UPDATES = ROOT / 'build/game-updates.json'
|
||||
|
||||
|
||||
def package_id(url, commit):
|
||||
"""The id `ziran lock` gives a source at a commit (PkgSourceId)."""
|
||||
return 'p' + hashlib.sha256((url + '\n' + commit).encode()).hexdigest()[:16]
|
||||
|
||||
|
||||
def write_lock(lock):
|
||||
"""The lock as Ziran writes it: sorted keys, one-line maps, packages kept
|
||||
in their order."""
|
||||
def value(item):
|
||||
if isinstance(item, dict):
|
||||
return '{' + ', '.join(json.dumps(k) + ': ' + json.dumps(item[k]) for k in sorted(item)) + '}'
|
||||
return json.dumps(item)
|
||||
|
||||
def block(item, indent):
|
||||
pad = ' ' * indent
|
||||
fields = [pad + ' ' + json.dumps(k) + ': ' + value(item[k]) for k in sorted(item)]
|
||||
return pad + '{\n' + ',\n'.join(fields) + '\n' + pad + '}'
|
||||
|
||||
text = '{\n "format": ' + json.dumps(lock['format']) + ',\n "packages": [\n'
|
||||
text += ',\n'.join(block(item, 4) for item in lock['packages']) + '\n ],\n'
|
||||
text += ' "root": ' + block(lock['root'], 2).lstrip() + ',\n'
|
||||
text += ' "toolchain": ' + block(lock['toolchain'], 2).lstrip() + '\n}\n'
|
||||
return text
|
||||
|
||||
|
||||
def gh(*args):
|
||||
return subprocess.check_output(['gh', *args], text=True).strip()
|
||||
|
||||
|
||||
def repository(url):
|
||||
match = re.fullmatch(r'https://github\.com/([A-Za-z0-9._-]+/[A-Za-z0-9._-]+?)(\.git)?', url)
|
||||
if not match:
|
||||
raise SystemExit(f'Not a GitHub package: {url}')
|
||||
return match[1]
|
||||
|
||||
|
||||
def pin():
|
||||
lock_path = ROOT / 'ziran.lock'
|
||||
lock = json.loads(lock_path.read_text())
|
||||
if write_lock(lock) != lock_path.read_text():
|
||||
raise SystemExit('ziran.lock is not in the layout ziran lock writes')
|
||||
names = json.loads((ROOT / 'games.json').read_text())['packages']
|
||||
ledger = json.loads((ROOT / 'apps/versions.json').read_text())['node_apps']
|
||||
updates = []
|
||||
for name in names:
|
||||
old_id = lock['root']['dependencies'][name]
|
||||
entry = next(item for item in lock['packages'] if item['id'] == old_id)
|
||||
repo = repository(entry['url'])
|
||||
tag = gh('release', 'view', '--repo', repo, '--json', 'tagName', '--jq', '.tagName')
|
||||
commit = gh('api', f'repos/{repo}/commits/{tag}', '--jq', '.sha')
|
||||
if commit == entry['commit']:
|
||||
continue
|
||||
# A later tag of the version Arcade already ships is not a new release.
|
||||
if name in ledger and ledger[name]['version'] == tag.removeprefix('v'):
|
||||
continue
|
||||
# Never move back: the release must contain the pinned commit.
|
||||
status = gh('api', f'repos/{repo}/compare/{entry["commit"]}...{commit}', '--jq', '.status')
|
||||
if status != 'ahead':
|
||||
print(f'{name}: release {tag} is {status} of the pinned {entry["commit"][:12]}; kept')
|
||||
continue
|
||||
new_id = package_id(entry['url'], commit)
|
||||
entry['commit'] = commit
|
||||
entry['id'] = new_id
|
||||
for owner in [lock['root'], *lock['packages']]:
|
||||
for alias, target in owner['dependencies'].items():
|
||||
if target == old_id:
|
||||
owner['dependencies'][alias] = new_id
|
||||
updates.append({'name': name, 'repository': repo, 'tag': tag, 'commit': commit})
|
||||
print(f'{name}: {repo} {tag} ({commit[:12]})')
|
||||
lock_path.write_text(write_lock(lock))
|
||||
UPDATES.parent.mkdir(parents=True, exist_ok=True)
|
||||
UPDATES.write_text(json.dumps(updates, indent=2) + '\n')
|
||||
|
||||
|
||||
def newest_notes(changelog):
|
||||
"""The bullets of a changelog's newest numeric release."""
|
||||
text = changelog.read_text()
|
||||
heading = re.search(r'^## \[?(\d+\.\d+\.\d+)\]?.*$', text, re.M)
|
||||
if heading is None:
|
||||
raise SystemExit(f'{changelog} needs a numeric release entry')
|
||||
following = re.search(r'^## ', text[heading.end():], re.M)
|
||||
section = text[heading.end():heading.end() + following.start()] if following else text[heading.end():]
|
||||
notes = [line[2:].strip() for line in section.splitlines() if line.startswith('- ')]
|
||||
return heading[1], notes
|
||||
|
||||
|
||||
def changelog(ziran):
|
||||
updates = json.loads(UPDATES.read_text())
|
||||
if not updates:
|
||||
return
|
||||
lines = []
|
||||
for update in updates:
|
||||
source = Path(subprocess.check_output([ziran, 'pkg', 'path', update['name']], cwd=ROOT, text=True).strip())
|
||||
declaration = json.loads((source / 'apps.json').read_text())
|
||||
# The package's first app is the game itself; its changelog sits beside its catalog.
|
||||
manifest = source / declaration['apps'][0]['manifest']
|
||||
version, notes = newest_notes(manifest.with_name('CHANGELOG.md'))
|
||||
title = declaration['title']
|
||||
lines += [f'- {title} {version}: {note}' for note in notes] or [f'- {title} {version}.']
|
||||
path = ROOT / 'CHANGELOG.md'
|
||||
text = path.read_text()
|
||||
current = re.search(r'^## (\d+)\.(\d+)\.(\d+)\s*$', text, re.M)
|
||||
if current is None:
|
||||
raise SystemExit('CHANGELOG.md needs a numeric release entry')
|
||||
version = f'{current[1]}.{current[2]}.{int(current[3]) + 1}'
|
||||
entry = f'## {version}\n\n' + '\n'.join(lines) + '\n\n'
|
||||
path.write_text(text[:current.start()] + entry + text[current.start():])
|
||||
print(f'Arcade {version}')
|
||||
|
||||
|
||||
def art():
|
||||
sys.path.insert(0, str(ROOT / 'scripts'))
|
||||
spec = importlib.util.spec_from_file_location('library_art', ROOT / 'scripts/library-art.py')
|
||||
library = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(library)
|
||||
recorded = json.loads((library.LIBRARY / 'sources.json').read_text())
|
||||
current = {f'{name}-{key}': hashlib.sha256(data).hexdigest() for name, key, data in library.art()}
|
||||
if {copy: item['source_sha256'] for copy, item in recorded.items()} != current:
|
||||
library.main()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('command', choices=['pin', 'changelog', 'art'])
|
||||
parser.add_argument('--ziran', default=str(ROOT / 'scripts/ziran.sh'))
|
||||
args = parser.parse_args()
|
||||
if args.command == 'pin':
|
||||
pin()
|
||||
elif args.command == 'changelog':
|
||||
changelog(args.ziran)
|
||||
else:
|
||||
art()
|
||||
@@ -5,10 +5,11 @@ for an app the library opens from a full-screen cover, that cover's art,
|
||||
caption and action. games.json names the game packages Arcade includes.
|
||||
"""
|
||||
import json
|
||||
import re
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
|
||||
APP_KEYS = {'manifest', 'cover', 'enabled', 'requires'}
|
||||
APP_KEYS = {'manifest', 'cover', 'enabled', 'requires', 'shared_code', 'library_entries'}
|
||||
COVER_KEYS = {'portrait', 'landscape', 'logo', 'caption', 'action'}
|
||||
|
||||
|
||||
@@ -46,9 +47,19 @@ def declared_packages(root, ziran=None, lock_flags=()):
|
||||
any(not isinstance(item, str) or not item for item in requires) or \
|
||||
len(set(requires)) != len(requires):
|
||||
raise ValueError(f'{name}: invalid app dependencies')
|
||||
shared_code = app.get('shared_code', False)
|
||||
if type(shared_code) is not bool or (shared_code and not requires):
|
||||
raise ValueError(f'{name}: shared code needs declared dependencies')
|
||||
library_entries = app.get('library_entries', [])
|
||||
if not isinstance(library_entries, list) or len(library_entries) > 64 or \
|
||||
any(not isinstance(item, str) or len(item) > 253 or
|
||||
not re.fullmatch(r'[A-Za-z_][A-Za-z0-9_]*:[A-Za-z_][A-Za-z0-9_]*', item)
|
||||
for item in library_entries) or len(set(library_entries)) != len(library_entries):
|
||||
raise ValueError(f'{name}: invalid portable library entries')
|
||||
apps.append(dict(package=name, source=source, manifest=manifest,
|
||||
descriptor=json.loads(manifest.read_text()),
|
||||
cover=app.get('cover'), requires=requires, enabled=app.get('enabled', True)))
|
||||
cover=app.get('cover'), requires=requires, shared_code=shared_code,
|
||||
library_entries=library_entries, enabled=app.get('enabled', True)))
|
||||
packages.append(dict(name=name, source=source, id=declaration['id'],
|
||||
title=declaration['title'], apps=apps))
|
||||
return packages
|
||||
|
||||
@@ -0,0 +1,73 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Make Arcade's small copies of each game's cover and preview art.
|
||||
|
||||
Game packages keep their full-size art for their own players and stores.
|
||||
Arcade only shows that art in its library, so it packs copies sized for the
|
||||
screen with a 256-colour palette: about a fifth of the bytes, with no visible
|
||||
change. Arcade stays a small launcher; the games download separately.
|
||||
|
||||
The copies and sources.json, which records the SHA-256 of the art each copy
|
||||
was made from, are committed. The collection build uses them as they are,
|
||||
so its bytes never depend on the local image library, and it stops when a
|
||||
game's art changes until this script makes fresh copies.
|
||||
"""
|
||||
import hashlib
|
||||
import io
|
||||
import json
|
||||
from pathlib import Path
|
||||
from PIL import Image
|
||||
from game_packages import declared_packages
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
LIBRARY = ROOT / 'assets/arcade/library'
|
||||
# Longest side: covers fill the library's screen, logos sit on them and
|
||||
# previews are small tiles and icons.
|
||||
LONGEST = {'portrait': 1280, 'landscape': 1280, 'logo': 800, 'preview': 480}
|
||||
|
||||
|
||||
def small_copy(data, key):
|
||||
image = Image.open(io.BytesIO(data))
|
||||
image.load()
|
||||
scale = min(1.0, LONGEST[key] / max(image.size))
|
||||
if scale < 1.0:
|
||||
size = (round(image.width * scale), round(image.height * scale))
|
||||
image = image.convert('RGBA' if 'A' in image.getbands() else 'RGB').resize(size, Image.Resampling.LANCZOS)
|
||||
if 'A' in image.getbands():
|
||||
image = image.convert('RGBA').quantize(256, method=Image.Quantize.FASTOCTREE, dither=Image.Dither.FLOYDSTEINBERG)
|
||||
else:
|
||||
image = image.convert('RGB').quantize(256, dither=Image.Dither.FLOYDSTEINBERG)
|
||||
output = io.BytesIO()
|
||||
image.save(output, 'PNG', optimize=True)
|
||||
return output.getvalue()
|
||||
|
||||
|
||||
def art(root=ROOT):
|
||||
"""(copy name, key, source bytes) for every enabled game's library art."""
|
||||
for package in declared_packages(root)[1:]:
|
||||
for app in package['apps']:
|
||||
if not app['enabled']:
|
||||
continue
|
||||
name = app['descriptor']['name']
|
||||
yield name, 'preview', (app['source'] / app['descriptor']['preview']).read_bytes()
|
||||
for key in ('portrait', 'landscape', 'logo'):
|
||||
if app['cover'] and key in app['cover']:
|
||||
yield name, key, (app['source'] / app['cover'][key]).read_bytes()
|
||||
|
||||
|
||||
def main():
|
||||
LIBRARY.mkdir(parents=True, exist_ok=True)
|
||||
sources = {}
|
||||
for name, key, data in art():
|
||||
copy = f'{name}-{key}'
|
||||
(LIBRARY / f'{copy}.png').write_bytes(small_copy(data, key))
|
||||
sources[copy] = {'source_sha256': hashlib.sha256(data).hexdigest()}
|
||||
for stale in LIBRARY.glob('*.png'):
|
||||
if stale.stem not in sources:
|
||||
stale.unlink()
|
||||
(LIBRARY / 'sources.json').write_text(json.dumps(dict(sorted(sources.items())), indent=2) + '\n')
|
||||
total = sum((LIBRARY / f'{copy}.png').stat().st_size for copy in sources)
|
||||
print(f'{len(sources)} library images, {total / 1048576:.1f} MiB')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,9 @@
|
||||
/*
|
||||
X-Content-Type-Options: nosniff
|
||||
Referrer-Policy: strict-origin-when-cross-origin
|
||||
|
||||
/*.webp
|
||||
Cache-Control: public, max-age=604800
|
||||
|
||||
/*.png
|
||||
Cache-Control: public, max-age=604800
|
||||
|
After Width: | Height: | Size: 8.8 KiB |
|
After Width: | Height: | Size: 9.2 KiB |
|
After Width: | Height: | Size: 25 KiB |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" rx="8" fill="#181622"/><g transform="translate(4 4)" fill="none" stroke="#fff" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 9v3M13.5 10.5h3M7 5c1 0 3 1 5 1s4-1 5-1c3 0 7 14 3 14-3 0-4.5-4-8-4s-5 4-8 4C0 19 4 5 7 5Zm3 5.5a1.5 1.5 0 1 1-3 0 1.5 1.5 0 0 1 3 0Z"/></g></svg>
|
||||
|
After Width: | Height: | Size: 394 B |
@@ -0,0 +1,83 @@
|
||||
<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
|
||||
<title>Arcade</title>
|
||||
<meta name="description" content="Arcade: all of Waozi's games in one place. Pick a cover, download the game and play, free in your browser.">
|
||||
<meta name="theme-color" content="#111223">
|
||||
<link rel="canonical" href="https://arcade.waozi.xyz/">
|
||||
<link rel="icon" href="icon.svg" type="image/svg+xml">
|
||||
<link rel="apple-touch-icon" href="apple-touch-icon.png">
|
||||
<link rel="manifest" href="manifest.webmanifest">
|
||||
<meta property="og:type" content="website">
|
||||
<meta property="og:url" content="https://arcade.waozi.xyz/">
|
||||
<meta property="og:title" content="Arcade">
|
||||
<meta property="og:description" content="All of Waozi's games in one place, free in your browser.">
|
||||
<meta property="og:image" content="https://arcade.waozi.xyz/og.jpg">
|
||||
<meta name="twitter:card" content="summary_large_image">
|
||||
<style>
|
||||
html, body { margin: 0; width: 100%; height: 100%; overflow: hidden; overscroll-behavior: none; background: #111223; color: #f4f2ff; }
|
||||
canvas { display: block; width: 100%; height: 100%; outline: none; touch-action: none; }
|
||||
#loading { position: fixed; inset: 0; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 20px; background: #111223; font: 600 16px/1.4 system-ui, sans-serif; transition: opacity .3s ease; }
|
||||
#loading.done { opacity: 0; pointer-events: none; }
|
||||
#loading svg { width: 64px; height: 64px; fill: none; stroke: currentColor; stroke-width: 1.6; stroke-linecap: round; stroke-linejoin: round; }
|
||||
#loading .track { width: min(280px, 70vw); height: 6px; border-radius: 3px; background: #ffffff26; overflow: hidden; }
|
||||
#loading .bar { width: 0; height: 100%; background: #ffd166; transition: width .2s ease; }
|
||||
#loading .failed { display: none; color: #ffb4a8; text-align: center; padding: 0 24px; }
|
||||
#loading.error .failed { display: block; }
|
||||
#loading.error .track { display: none; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<canvas id="canvas" tabindex="0"></canvas>
|
||||
<div id="loading" role="status" aria-live="polite">
|
||||
<!-- MingCute game_2 gamepad, Apache-2.0 -->
|
||||
<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M15 9v3M13.5 10.5h3M7 5c1 0 3 1 5 1s4-1 5-1c3 0 7 14 3 14-3 0-4.5-4-8-4s-5 4-8 4C0 19 4 5 7 5Zm3 5.5a1.5 1.5 0 1 1-3 0 1.5 1.5 0 0 1 3 0Z"/></svg>
|
||||
<div class="track"><div class="bar"></div></div>
|
||||
<p class="failed">Arcade could not start. Reload the page to try again.</p>
|
||||
</div>
|
||||
<script>
|
||||
(function () {
|
||||
var loading = document.getElementById('loading');
|
||||
var bar = loading.querySelector('.bar');
|
||||
function failed() { loading.classList.add('error'); }
|
||||
// Arcade's Profile reports ready once the library is about to draw.
|
||||
function watch() {
|
||||
if (window.Module && Module.profileReady) { loading.classList.add('done'); return; }
|
||||
requestAnimationFrame(watch);
|
||||
}
|
||||
window.Module = {
|
||||
canvas: document.getElementById('canvas'),
|
||||
setStatus: function (text) {
|
||||
var match = /\((\d+(?:\.\d+)?)\/(\d+)\)/.exec(text || '');
|
||||
if (match) bar.style.width = Math.min(100, 100 * match[1] / match[2]) + '%';
|
||||
},
|
||||
onAbort: failed,
|
||||
onExit: function (code) { if (code !== 0) failed(); }
|
||||
};
|
||||
// The build receipt names the collection's digest and its trusted Apps
|
||||
// library; Arcade's own copy of that library goes in beside it.
|
||||
Promise.all([
|
||||
fetch('arcade.json', { cache: 'no-cache' }).then(function (response) {
|
||||
if (!response.ok) throw new Error(response.status);
|
||||
return response.text();
|
||||
}),
|
||||
fetch('apps.zx').then(function (response) {
|
||||
return response.ok ? response.arrayBuffer() : null;
|
||||
})
|
||||
]).then(function (loaded) {
|
||||
Module.arcadeReceipt = loaded[0];
|
||||
if (loaded[1]) {
|
||||
Module.preRun = [function () { FS.writeFile('/apps.zx', new Uint8Array(loaded[1])); }];
|
||||
}
|
||||
var script = document.createElement('script');
|
||||
script.src = 'runtime.js';
|
||||
script.onerror = failed;
|
||||
document.body.appendChild(script);
|
||||
watch();
|
||||
}).catch(failed);
|
||||
})();
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"name": "Arcade",
|
||||
"short_name": "Arcade",
|
||||
"description": "All my games in one place.",
|
||||
"start_url": "/",
|
||||
"display": "standalone",
|
||||
"background_color": "#181622",
|
||||
"theme_color": "#181622",
|
||||
"icons": [
|
||||
{ "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" },
|
||||
{ "src": "/icon-512.png", "sizes": "512x512", "type": "image/png" }
|
||||
]
|
||||
}
|
||||
|
After Width: | Height: | Size: 155 KiB |
@@ -19,6 +19,9 @@ ARCADE_BACK_KEY :: 4
|
||||
arcade_state: s32;
|
||||
|
||||
ArcadeStart :: () -> bool {
|
||||
// Later animation pictures load asynchronously too. Keep the last
|
||||
// complete frame visible while a new sprite is being decoded.
|
||||
RaylibCompletePictureFrames(true)
|
||||
// Android before 10 cannot name its system font; the APK carries the
|
||||
// same font as the Windows build, so text never falls back to raylib's
|
||||
// bitmap font.
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
// Arcade's library art: the games' covers, logos and previews, downloaded
|
||||
// beside the games. The Apps host only reads its assets; it never runs.
|
||||
#program_export
|
||||
Main :: () -> s32 { return 0 }
|
||||
@@ -21,6 +21,7 @@
|
||||
#import "kryon/button_widget"
|
||||
#import "kryon/button_props"
|
||||
#import "kryon/hosted_values"
|
||||
#import "kryon/hosted_app"
|
||||
#import "kryon/widget_host"
|
||||
#import "kryon/app_files"
|
||||
#import "kryon/app_protocol"
|
||||
@@ -43,6 +44,9 @@ Codec :: #import "apps/node_codec";
|
||||
#import "entity/entity_records"
|
||||
#import "entity/entity_dew"
|
||||
#import "kryon/widget_palette"
|
||||
#import "kryon/image_raster"
|
||||
#import "kryon/loading_indicator"
|
||||
#import, file "collection_loading.zi";
|
||||
#import "shovey/shovey_theme"
|
||||
ProfileIcon :: #import "mingcute/mingcute_regular_user_4";
|
||||
DewIcon :: #import "mingcute/mingcute_filled_drop";
|
||||
@@ -78,6 +82,8 @@ collection_shared_codec: Codec.WidgetAppSharedCodec;
|
||||
collection_item_codec: Codec.WidgetAppSharedItemCodec;
|
||||
collection_invitation_codec: Codec.WidgetAppInvitationCodec;
|
||||
collection_ready: bool;
|
||||
collection_loading: CollectionLoading;
|
||||
collection_pictures_missing: bool;
|
||||
collection_leave_to_library: bool;
|
||||
// Whether games download new levels when they come out: asked once on the
|
||||
// covers and passed to the games as arcade.updates. -1 unread, 0 off, 1 on,
|
||||
@@ -275,14 +281,15 @@ CollectionCall :: (context: *void, node: *AppNode, module: *u8, function: *u8,
|
||||
}
|
||||
|
||||
CollectionAssetAllowed :: (path: string) -> bool {
|
||||
return path == "" || (collection_widget_node != null && AppHostAsset(collection_widget_node, path).found)
|
||||
return path == "" || (collection_widget_node != null && (AppHostAsset(collection_widget_node, path).found ||
|
||||
AppHostAssetPending(collection_widget_node, path)))
|
||||
}
|
||||
|
||||
CollectionAssetPath :: (path: string) -> string {
|
||||
if path == "" { return "" }
|
||||
if collection_widget_node == null { return "" }
|
||||
asset := AppHostAsset(collection_widget_node, path)
|
||||
if !asset.found { return "" }
|
||||
if !asset.found { collection_pictures_missing = true; return "" }
|
||||
relative := Join(TextUntilNul(collection_widget_node.entry.sha256[:]), path)
|
||||
defer { AppFileFree(relative) }
|
||||
cached := collection_images
|
||||
@@ -378,6 +385,18 @@ CollectionEffect :: (context: *void, account: string, locator: *AppLocator,
|
||||
return true
|
||||
}
|
||||
|
||||
// Arcade's own copy of the shared Apps controller. A collection that does not
|
||||
// pack one uses it; the Apps host accepts it only by the trusted digest.
|
||||
collection_controller: string;
|
||||
|
||||
CollectionController :: (context: *void) -> HostedAsset {
|
||||
unused context
|
||||
controller: HostedAsset
|
||||
controller.data = collection_controller
|
||||
controller.found = collection_controller.count > 0
|
||||
return controller
|
||||
}
|
||||
|
||||
CollectionOpen :: (bundle: string, digest: string, harness_digest: string,
|
||||
data: string, locale: string) -> bool {
|
||||
if collection_ready { return false }
|
||||
@@ -390,7 +409,8 @@ CollectionOpen :: (bundle: string, digest: string, harness_digest: string,
|
||||
.widgets = CollectionWidgets, .save = CollectionSave, .state = CollectionState,
|
||||
.effect = CollectionEffect,
|
||||
.bundle = CollectionBundle, .download = CollectionDownload, .fetch = CollectionFetch,
|
||||
.presentation = AppPresentation.{.cover_grid = true}}
|
||||
// Covers show only the art; the download dialog names the size.
|
||||
.controller = CollectionController, .presentation = AppPresentation.{.cover_grid = true, .hide_sizes = true}}
|
||||
collection_ready = AppHostStart(*collection_host, bundle, "arcade.local", "inbe.arcade",
|
||||
"arcade", digest, "local", platform, harness_digest, locale)
|
||||
if !collection_ready { Report("Arcade: the shared Apps host refused the collection") }
|
||||
@@ -398,6 +418,11 @@ CollectionOpen :: (bundle: string, digest: string, harness_digest: string,
|
||||
}
|
||||
|
||||
CollectionOpenFiles :: (directory: string, data: string) -> bool {
|
||||
// The installed controller beside the collection; kept while Arcade runs.
|
||||
controller_path := Join(directory, "apps.zx")
|
||||
controller, controller_found := ReadEntireFile(controller_path)
|
||||
AppFileFree(controller_path)
|
||||
if controller_found { collection_controller = controller } else { AppFileFree(controller) }
|
||||
bundle_path := Join(directory, "arcade.zx")
|
||||
metadata_path := Join(directory, "arcade.json")
|
||||
defer { AppFileFree(bundle_path); AppFileFree(metadata_path) }
|
||||
@@ -482,6 +507,7 @@ CollectionClose :: () -> bool {
|
||||
if !EntityClose() { return false }
|
||||
if collection_ready && !AppHostStop(*collection_host) { return false }
|
||||
collection_ready = false
|
||||
collection_loading = .{}
|
||||
CollectionDownloadsClose()
|
||||
CollectionCollect()
|
||||
VecFree(collection_frame_paths)
|
||||
@@ -504,9 +530,19 @@ CollectionClose :: () -> bool {
|
||||
AppFilesClose(*collection_resources)
|
||||
AppFileFree(collection_resource_root)
|
||||
collection_resource_root = ""
|
||||
AppFileFree(collection_controller)
|
||||
collection_controller = ""
|
||||
return true
|
||||
}
|
||||
|
||||
CollectionPending :: (request: s64) -> bool {
|
||||
for index: cast(s64)0..collection_host.tree.pending.count - 1 {
|
||||
pending := collection_host.tree.pending[index]
|
||||
if pending.reply.request == request { return !pending.complete }
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
CollectionOpenGame :: (id: string) -> bool {
|
||||
root := AppTreeNode(*collection_host.tree, collection_host.tree.active)
|
||||
if root == null || !root.collection { Report("Arcade: no collection is open to start "); Report(id); Report("\n"); return false }
|
||||
@@ -526,6 +562,12 @@ CollectionOpenGame :: (id: string) -> bool {
|
||||
return false
|
||||
}
|
||||
if !AppTreeDrain(*collection_host.tree) { Report("Arcade: the apps host stopped while starting "); Report(id); Report("\n"); return false }
|
||||
// Games that share code are verified in the background; wait for it.
|
||||
started := MonotonicMilliseconds()
|
||||
while CollectionPending(queued.request) && MonotonicMilliseconds() - started < 60000 {
|
||||
unused SleepMilliseconds(5)
|
||||
if !AppTreeDrain(*collection_host.tree) { Report("Arcade: the apps host stopped while starting "); Report(id); Report("\n"); return false }
|
||||
}
|
||||
for index: cast(s64)0..collection_host.tree.pending.count - 1 {
|
||||
reply := collection_host.tree.pending[index].reply
|
||||
if reply.request == queued.request && reply.status == APPS_REJECTED {
|
||||
@@ -607,6 +649,10 @@ CollectionFrame :: (session: Session, viewport: Rectangle, key: s32, modifiers:
|
||||
if entity_visible { return EntityFrame(session, viewport, key, modifiers) }
|
||||
runtime := AppHostActiveRuntime(*collection_host)
|
||||
if runtime == null { Report("Arcade: no app is running\n"); return false }
|
||||
opening := !runtime.node.collection && (!collection_loading.shown ||
|
||||
collection_loading.slot != collection_host.tree.active.slot ||
|
||||
collection_loading.generation != collection_host.tree.active.generation)
|
||||
if opening { key = 0 }
|
||||
nested := runtime.node.parent.generation != 0 && !runtime.node.collection
|
||||
// An app opened from its cover fills the screen with its own navigation.
|
||||
// Other apps get a bar with Back and their title; the library and that
|
||||
@@ -643,6 +689,7 @@ CollectionFrame :: (session: Session, viewport: Rectangle, key: s32, modifiers:
|
||||
.scale = 1.0, .font = 16, .now = now}
|
||||
}
|
||||
WidgetHostBegin(session, CollectionAssetAllowed, CollectionAssetPath)
|
||||
collection_pictures_missing = false
|
||||
drawn := AppHostRun(*collection_host, APP_FRAME)
|
||||
WidgetHostEnd()
|
||||
if !drawn {
|
||||
@@ -654,6 +701,27 @@ CollectionFrame :: (session: Session, viewport: Rectangle, key: s32, modifiers:
|
||||
unused AppHostBack(*collection_host)
|
||||
return true
|
||||
}
|
||||
if opening {
|
||||
pictures_ready := !collection_pictures_missing
|
||||
// Query every path, including those first requested by this frame's
|
||||
// TileMap. Android decodes them asynchronously on its render thread.
|
||||
for path: collection_frame_paths {
|
||||
if AssetWidth(path) < 0 { pictures_ready = false }
|
||||
}
|
||||
if CollectionNeedsCover(*collection_loading, collection_host.tree.active.slot,
|
||||
collection_host.tree.active.generation, pictures_ready) {
|
||||
collection_toolbar_visible = false
|
||||
Box(session, BoxProps.{.key = cast(u64)49400, .bounds = viewport,
|
||||
.fill = ColorFromPacked(ifx entity_shovey then ShoveyPalette().background else AppCoversPalette().background)})
|
||||
unused Button(session, ButtonProps.{.key = cast(u64)49401, .id = 49401,
|
||||
.bounds = viewport, .invisible = true})
|
||||
LoadingIndicator(session, LoadingIndicatorProps.{.key = cast(u64)49402,
|
||||
.bounds = viewport, .now = now, .scale = 1.5})
|
||||
return true
|
||||
}
|
||||
} else if runtime.node.collection {
|
||||
collection_loading = .{}
|
||||
}
|
||||
if asking {
|
||||
unused WidgetPaletteUse(session, ifx entity_shovey then ShoveyPalette() else AppCoversPalette())
|
||||
CollectionUpdatesQuestion(session, viewport)
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
// A newly opened game stays covered until two complete picture frames have
|
||||
// composed. Images can be requested after the first apparently ready frame.
|
||||
CollectionLoading :: struct {
|
||||
generation: s64
|
||||
slot: s64
|
||||
ready_frame: bool
|
||||
shown: bool
|
||||
}
|
||||
|
||||
CollectionNeedsCover :: (state: *CollectionLoading, slot: s64, generation: s64,
|
||||
pictures_ready: bool) -> bool {
|
||||
if state.slot != slot || state.generation != generation {
|
||||
state.* = CollectionLoading.{.slot = slot, .generation = generation}
|
||||
return true
|
||||
}
|
||||
if state.shown { return false }
|
||||
if !pictures_ready { state.ready_frame = false; return true }
|
||||
if !state.ready_frame { state.ready_frame = true; return true }
|
||||
state.shown = true
|
||||
return false
|
||||
}
|
||||
@@ -48,6 +48,11 @@ DataDirectory :: () -> string {
|
||||
BuilderPrint(*result, "%", private)
|
||||
return BuilderFinish(result)
|
||||
}
|
||||
// The browser keeps saves and downloaded games in the page's persistent
|
||||
// storage, which Kryon mounts at /kryon-apps.
|
||||
#if #defined(PLATFORM_WEB) {
|
||||
return Join("/kryon-apps", "arcade")
|
||||
}
|
||||
exact := EnvironmentText("ARCADE_DATA")
|
||||
if exact != "" { return exact }
|
||||
#if #defined(_WIN32) {
|
||||
|
||||
@@ -10,8 +10,8 @@ SoundMuted :: () -> bool { return sound_muted }
|
||||
|
||||
SoundSetMuted :: (muted: bool) { sound_muted = muted }
|
||||
|
||||
#if #defined(ANDROID_BUILD) {
|
||||
// Android has no SDL audio; games stay silent there and run on.
|
||||
#if #defined(ANDROID_BUILD) || #defined(PLATFORM_WEB) {
|
||||
// Android and the browser have no SDL audio; games stay silent there and run on.
|
||||
SoundPlay :: (bytes: string) -> bool {
|
||||
unused bytes
|
||||
return false
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
// Arcade in the browser: the same arcade.zx Inner Breeze downloads, with its
|
||||
// shared Apps library, the account Profile and each game downloaded from the
|
||||
// node when someone opens it. Saves stay in the page's persistent storage.
|
||||
using Canvas :: #import "kryon/Canvas";
|
||||
#import "kryon/bundle_storage_web"
|
||||
#import "kryon/app_files"
|
||||
#import "kryon/session"
|
||||
#import "kryon/geometry"
|
||||
#import "kryon/tree"
|
||||
#import "kryon/tree_input"
|
||||
#import "kryon/Frame"
|
||||
#import "kryon/ScrollDevice"
|
||||
#import "kryon/key_input"
|
||||
#import "kryon/TestDriver"
|
||||
#import "kryon/page_core"
|
||||
#import "std/file"
|
||||
#import "std/web"
|
||||
#import "std/byte_text_linux"
|
||||
#import "platform"
|
||||
#import "collection_host"
|
||||
#import "entity_host"
|
||||
|
||||
arcade_receipt: [4096]u8;
|
||||
|
||||
// The page passes the collection's build receipt (its digest and trusted
|
||||
// Apps controller) as Module.arcadeReceipt, beside the preloaded /app.zx.
|
||||
ArcadeReceipt :: () -> string {
|
||||
handle := WebAsObject(WebGet(WebGetObject(WebGlobal, WebName("Module")), WebName("arcadeReceipt")))
|
||||
if handle == 0 { return "" }
|
||||
length := WebCopyString(handle, arcade_receipt[:])
|
||||
if length <= 0 || length >= cast(s32)arcade_receipt.count { return "" }
|
||||
return TextFromBytes(arcade_receipt[:length])
|
||||
}
|
||||
|
||||
ArcadeFrame :: (session: Session) -> bool {
|
||||
BeginCanvasFrame()
|
||||
viewport := CanvasViewport()
|
||||
modifiers := CanvasModifiers()
|
||||
KeyboardModifiersSend(session, modifiers)
|
||||
key := CanvasPressedKey()
|
||||
if key == 256 && CollectionBack() { key = 0 }
|
||||
KeyboardSend(session, key)
|
||||
point := CanvasTypedCodepoint()
|
||||
while point != 0 { unused TypedCodepointSend(session, point); point = CanvasTypedCodepoint() }
|
||||
pointer := PollPointer()
|
||||
TreePointerUpdate(session, pointer)
|
||||
TreeSecondaryPointerUpdate(session, PollSecondaryPointer())
|
||||
wheel := CanvasWheelMove()
|
||||
PointerWheelSend(session, pointer.x, pointer.y, wheel)
|
||||
BeginScrollFrame(session, Vector2.{pointer.x, pointer.y}, pointer.pressed,
|
||||
pointer.down, pointer.released, wheel, PageNow() / 1000.0)
|
||||
if BeginFrame(session, cast(u64)1, viewport) != FrameStatus.FrameOk { return false }
|
||||
if !CollectionFrame(session, viewport, key, modifiers) {
|
||||
TreeCancel(session)
|
||||
return false
|
||||
}
|
||||
if EndFrame(session) != FrameStatus.FrameOk { return false }
|
||||
TestDriverFrame(session)
|
||||
CanvasCursor(session)
|
||||
ok := EndCanvasFrame()
|
||||
CollectionCollect()
|
||||
return ok
|
||||
}
|
||||
|
||||
#program_export
|
||||
main :: () -> s32 {
|
||||
if !OpenCanvas() { return 1 }
|
||||
defer CloseCanvas()
|
||||
if !BundleStorageOpen() { return 1 }
|
||||
while !BundleStorageReady() && !BundleStorageFailed() { WebSleep(10) }
|
||||
if !BundleStorageReady() { return 1 }
|
||||
data := DataDirectory()
|
||||
// The page preloads Arcade's published collection; the Profile is embedded.
|
||||
bytes, found := ReadEntireFile("/app.zx")
|
||||
profile, profile_found := ReadEntireFile("/entity.zx")
|
||||
defer { AppFileFree(bytes) }
|
||||
receipt := ArcadeReceipt()
|
||||
// The page writes Arcade's own Apps controller beside the collection.
|
||||
controller, controller_found := ReadEntireFile("/apps.zx")
|
||||
if controller_found { collection_controller = controller } else { AppFileFree(controller) }
|
||||
if !found || !profile_found || receipt == "" || !CollectionOpenBytes(bytes, receipt, data) { return 1 }
|
||||
if !EntityOpen(profile, data) { unused CollectionClose(); return 1 }
|
||||
session := SessionOpen()
|
||||
if !SessionValid(session) { unused CollectionClose(); return 1 }
|
||||
defer { SessionClose(session) }
|
||||
WebSet(WebGetObject(WebGlobal, WebName("Module")), WebName("profileReady"), WebBool(true))
|
||||
saved := PageNow()
|
||||
ok := true
|
||||
while ok && PollCanvas() {
|
||||
scope := WebScope()
|
||||
ok = ArcadeFrame(session)
|
||||
// Saves reach the browser's storage about once a second.
|
||||
if PageNow() - saved >= 1000.0 {
|
||||
unused BundleStorageSync(false)
|
||||
saved = PageNow()
|
||||
}
|
||||
WebEnd(scope)
|
||||
}
|
||||
unused CollectionClose()
|
||||
unused BundleStorageSync(false)
|
||||
return ifx ok then 0 else 1
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
#import, file "../src/collection_loading.zi";
|
||||
|
||||
#program_export
|
||||
Check :: () -> s32 {
|
||||
state: CollectionLoading
|
||||
if !CollectionNeedsCover(*state, 1, 1, true) { return 1 }
|
||||
if !CollectionNeedsCover(*state, 1, 1, true) { return 2 }
|
||||
// A later request invalidates the apparently ready frame.
|
||||
if !CollectionNeedsCover(*state, 1, 1, false) { return 3 }
|
||||
if !CollectionNeedsCover(*state, 1, 1, false) { return 4 }
|
||||
if !CollectionNeedsCover(*state, 1, 1, true) { return 5 }
|
||||
if CollectionNeedsCover(*state, 1, 1, true) { return 6 }
|
||||
// Gameplay never returns to its opening cover for an animation sprite.
|
||||
if CollectionNeedsCover(*state, 1, 1, false) { return 7 }
|
||||
// A new game or a reopened slot gets its own loading stage.
|
||||
if !CollectionNeedsCover(*state, 2, 1, true) { return 8 }
|
||||
if !CollectionNeedsCover(*state, 2, 1, true) { return 9 }
|
||||
if CollectionNeedsCover(*state, 2, 1, true) { return 10 }
|
||||
if !CollectionNeedsCover(*state, 2, 2, true) { return 11 }
|
||||
return 42
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
|
||||
cd "$root"
|
||||
mkdir -p build/collection-loading-test
|
||||
./scripts/ziran.sh bundle --project --root "$root" \
|
||||
--entry collection_loading_behavior:Check \
|
||||
-o build/collection-loading-test/test.zx tests/collection_loading_behavior.zi
|
||||
test "$(./scripts/ziran.sh run build/collection-loading-test/test.zx)" = 42
|
||||
echo 'Local collection loading test: late image requests, consecutive ready frames and navigation'
|
||||
@@ -38,6 +38,7 @@ class CollectionTests(unittest.TestCase):
|
||||
shutil.copytree(ROOT / "build/games", self.root / "build/games")
|
||||
(self.root / "assets/arcade").mkdir(parents=True)
|
||||
shutil.copyfile(ROOT / "assets/arcade/sidebar.shape", self.root / "assets/arcade/sidebar.shape")
|
||||
shutil.copytree(ROOT / "assets/arcade/library", self.root / "assets/arcade/library")
|
||||
# Only a native VM identity gate can trust a controller. This fixture
|
||||
# tests packing and its exact-content requirement, not that handshake.
|
||||
self.controller = self.root / "controller.zx"
|
||||
@@ -70,10 +71,23 @@ class CollectionTests(unittest.TestCase):
|
||||
self.assertEqual(builder.digest(packed), child["sha256"])
|
||||
self.assertEqual(child["version"], ledger[name]["version"])
|
||||
self.assertEqual(child["protocol"], "node/2")
|
||||
# The library packs its own small copy of each game's art.
|
||||
self.assertEqual((self.output / child["preview"]).read_bytes(),
|
||||
(ROOT / f"build/games/{name}-preview.png").read_bytes())
|
||||
(ROOT / f"assets/arcade/library/{name}-preview.png").read_bytes())
|
||||
for key, path in child["cover"].items():
|
||||
if key in ("portrait", "landscape", "logo"):
|
||||
self.assertEqual((self.output / path).read_bytes(),
|
||||
(ROOT / f"assets/arcade/library/{name}-{key}.png").read_bytes())
|
||||
self.assertEqual((self.output / catalog["harness"]).read_bytes(), self.controller.read_bytes())
|
||||
|
||||
def test_changed_game_art_needs_fresh_library_copies(self):
|
||||
sources = self.root / "assets/arcade/library/sources.json"
|
||||
value = json.loads(sources.read_text())
|
||||
value["wurm-portrait"]["source_sha256"] = "0" * 64
|
||||
sources.write_text(json.dumps(value))
|
||||
with self.assertRaisesRegex(ValueError, "wurm-portrait art changed"):
|
||||
self.stage()
|
||||
|
||||
def test_editor_download_reuses_verified_shovey_assets(self):
|
||||
catalog = self.stage()
|
||||
children = {child['id']: child for child in catalog['children']}
|
||||
@@ -110,29 +124,45 @@ class CollectionTests(unittest.TestCase):
|
||||
catalog = self.stage()
|
||||
small = self.root / "small"
|
||||
games = self.root / "arcade.games"
|
||||
builder.stage_downloads(catalog, self.output, small, games)
|
||||
builder.stage_downloads(catalog, self.output, small, games, self.root / "art")
|
||||
art = self.root / "art"
|
||||
self.assertEqual((small / "assets/apps/catalog.json").read_bytes(),
|
||||
(self.output / "assets/apps/catalog.json").read_bytes())
|
||||
self.assertEqual((small / catalog["harness"]).read_bytes(), self.controller.read_bytes())
|
||||
# The published launcher packs neither the host's controller nor art.
|
||||
self.assertFalse((small / catalog["harness"]).exists())
|
||||
self.assertTrue((self.output / catalog["harness"]).is_file(), "Standalone players keep the controller")
|
||||
for child in catalog["children"]:
|
||||
full = self.output / child["bundle"]
|
||||
self.assertTrue(full.is_file(), "Standalone players retain the game")
|
||||
self.assertFalse((small / child["bundle"]).exists())
|
||||
self.assertEqual((games / (child["sha256"] + ".zx")).read_bytes(), full.read_bytes())
|
||||
self.assertEqual((small / child["preview"]).read_bytes(),
|
||||
(self.output / child["preview"]).read_bytes())
|
||||
for key in child["cover"].keys() & {"portrait", "landscape", "logo"}:
|
||||
relative = child["cover"][key]
|
||||
self.assertEqual((small / relative).read_bytes(), (self.output / relative).read_bytes())
|
||||
pictures = [child["preview"]] + [child["cover"][key] for key in child["cover"].keys() & {"portrait", "landscape", "logo"}]
|
||||
for relative in pictures:
|
||||
self.assertFalse((small / relative).exists())
|
||||
self.assertEqual((art / relative).read_bytes(), (self.output / relative).read_bytes())
|
||||
packed = sum(path.stat().st_size for path in small.rglob("*") if path.is_file())
|
||||
self.assertLess(packed, 1024 * 1024, "Arcade itself stays under one megabyte")
|
||||
|
||||
def test_art_bundle_is_published_and_named_by_the_catalog(self):
|
||||
catalog = self.stage()
|
||||
small = self.root / "small"
|
||||
games = self.root / "arcade.games"
|
||||
builder.stage_downloads(catalog, self.output, small, games, self.root / "art")
|
||||
art_bundle = self.root / "art.zx"
|
||||
art_bundle.write_bytes(b"ZX\0\0art fixture")
|
||||
art = builder.add_art(small, games, art_bundle)
|
||||
self.assertEqual(art, dict(sha256=builder.digest(art_bundle), bytes=art_bundle.stat().st_size))
|
||||
self.assertEqual((games / (art["sha256"] + ".zx")).read_bytes(), art_bundle.read_bytes())
|
||||
self.assertEqual(json.loads((small / "assets/apps/catalog.json").read_text())["art"], art)
|
||||
|
||||
def test_changed_download_preserves_previous_outputs(self):
|
||||
catalog = self.stage()
|
||||
small = self.root / "small"
|
||||
games = self.root / "arcade.games"
|
||||
builder.stage_downloads(catalog, self.output, small, games)
|
||||
builder.stage_downloads(catalog, self.output, small, games, self.root / "art")
|
||||
(self.output / catalog["children"][0]["bundle"]).write_bytes(b"changed game")
|
||||
with self.assertRaisesRegex(ValueError, "declared digest"):
|
||||
builder.stage_downloads(catalog, self.output, small, games)
|
||||
builder.stage_downloads(catalog, self.output, small, games, self.root / "art")
|
||||
self.assertTrue((small / "assets/apps/catalog.json").exists())
|
||||
self.assertTrue((games / (catalog["children"][0]["sha256"] + ".zx")).exists())
|
||||
|
||||
@@ -140,7 +170,7 @@ class CollectionTests(unittest.TestCase):
|
||||
catalog = self.stage()
|
||||
small = self.root / "small"
|
||||
games = self.root / "arcade.games"
|
||||
builder.stage_downloads(catalog, self.output, small, games)
|
||||
builder.stage_downloads(catalog, self.output, small, games, self.root / "art")
|
||||
archive = self.root / "arcade.games.tar"
|
||||
builder.archive_downloads(games, archive)
|
||||
with tarfile.open(archive) as content:
|
||||
@@ -154,12 +184,12 @@ class CollectionTests(unittest.TestCase):
|
||||
catalog = self.stage()
|
||||
small = self.root / "small"
|
||||
games = self.root / "arcade.games"
|
||||
builder.stage_downloads(catalog, self.output, small, games)
|
||||
builder.stage_downloads(catalog, self.output, small, games, self.root / "art")
|
||||
catalog["children"] = []
|
||||
# Build a fresh full stage as a real removed registration does.
|
||||
(self.root / "games.json").write_text(json.dumps({"packages": []}))
|
||||
catalog = self.stage()
|
||||
builder.stage_downloads(catalog, self.output, small, games)
|
||||
builder.stage_downloads(catalog, self.output, small, games, self.root / "art")
|
||||
self.assertEqual(list(games.iterdir()), [])
|
||||
self.assertFalse((small / "assets/arcade/games/shovey.zx").exists())
|
||||
|
||||
|
||||
@@ -51,12 +51,14 @@ def package_server(root):
|
||||
def do_GET(self):
|
||||
digest = self.path.removeprefix('/api/v2/packages/inbe.arcade/').removesuffix('.zx')
|
||||
state['requests'].append(digest)
|
||||
if state['offline'] or digest not in by_digest:
|
||||
# Every published file: the games and the library art.
|
||||
published = root / 'build/node-apps/arcade.games' / (digest + '.zx')
|
||||
if state['offline'] or not published.is_file():
|
||||
self.send_error(503)
|
||||
return
|
||||
entry = by_digest[digest]
|
||||
data = (root / 'build/node-apps/arcade.games' / (digest + '.zx')).read_bytes()
|
||||
if (state['corrupt_wurm'] and entry['expected_id'] == 'wurm') or (state['corrupt_shovey'] and entry['expected_id'] == 'shovey'):
|
||||
entry = by_digest.get(digest, {})
|
||||
data = published.read_bytes()
|
||||
if (state['corrupt_wurm'] and entry.get('expected_id') == 'wurm') or (state['corrupt_shovey'] and entry.get('expected_id') == 'shovey'):
|
||||
data = data[:-1] + bytes([data[-1] ^ 1])
|
||||
self.send_response(200)
|
||||
self.send_header('Content-Length', str(len(data)))
|
||||
@@ -83,6 +85,8 @@ def main():
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
entries = json.loads((root / 'build/arcade.json').read_text())['children']
|
||||
by_name = {entry['expected_id']: entry for entry in entries}
|
||||
# The library art downloads with Arcade; games only after consent.
|
||||
games = {entry['sha256'] for entry in entries}
|
||||
def size_text(size):
|
||||
return f"{(size * 10 + 500000) // 1000000 / 10:.1f} MB"
|
||||
sizes = {name: size_text(entry['bytes']) for name, entry in by_name.items()}
|
||||
@@ -127,7 +131,7 @@ def main():
|
||||
assert int(subprocess.check_output(["xdotool", "getwindowpid", window], text=True, timeout=10)) == child.pid
|
||||
subprocess.run(["import", "-window", window, str(output / (name + ".png"))], check=True, timeout=10)
|
||||
|
||||
def grid(child, name):
|
||||
def grid(child, name, phone=False):
|
||||
driver.wait_idle(frames=20)
|
||||
driver.wait(label="Arcade", role="text")
|
||||
assert not driver.find(label="Chess"), "Chess is temporarily disabled"
|
||||
@@ -137,14 +141,21 @@ def main():
|
||||
editor_card = driver.wait(label="Shovey Editor", role="button")
|
||||
assert classic_card['y'] == editor_card['y'], "Apps must share a grid row"
|
||||
assert classic_card['x'] != editor_card['x']
|
||||
assert classic_card['width'] >= 200 and classic_card['height'] >= 350
|
||||
if phone:
|
||||
# Phones show small covers, two or three a row.
|
||||
wurm_card = driver.wait(label='Apfelwurm', role='button')
|
||||
assert wurm_card['y'] == classic_card['y'], 'A phone row holds all three covers'
|
||||
assert 100 <= classic_card['width'] < 200, 'Phone covers must be small cards'
|
||||
else:
|
||||
assert classic_card['width'] >= 200 and classic_card['height'] >= 350
|
||||
assert not driver.find(label='Play', role='button')
|
||||
assert not driver.find(label='Open', role='button')
|
||||
for label in ('Shovey', 'Shovey Editor', 'Apfelwurm'):
|
||||
assert not driver.find(label=label, role='text'), 'Title artwork must not repeat its name underneath'
|
||||
driver.wait(label='Apfelwurm', role='button', visible=False)
|
||||
smallest = (100, 140) if phone else (180, 200)
|
||||
covers = [node for node in driver.find(role='image', visible=True)
|
||||
if node['width'] >= 180 and node['height'] >= 200]
|
||||
if node['width'] >= smallest[0] and node['height'] >= smallest[1]]
|
||||
assert len(covers) >= 2, "Apps must use large title-screen artwork"
|
||||
capture(child, name)
|
||||
with Image.open(output / (name + ".png")) as image:
|
||||
@@ -168,7 +179,7 @@ def main():
|
||||
driver.wait(label='Download size: ' + total, role='text')
|
||||
capture(child, 'editor-download-plan')
|
||||
driver.press(label='Cancel', role='button')
|
||||
assert server['requests'] == [], 'Dependency consent must precede every download'
|
||||
assert not games & set(server['requests']), 'Dependency consent must precede every download'
|
||||
driver.press(label='Shovey Editor', role='button')
|
||||
server['corrupt_shovey'] = True
|
||||
primary_download()
|
||||
@@ -180,7 +191,7 @@ def main():
|
||||
capture(child, 'editor-shared-assets')
|
||||
assert server['requests'].count(by_name['shovey']['sha256']) == 2
|
||||
assert server['requests'].count(by_name['shovey-editor']['sha256']) == 1
|
||||
assert len(server['requests']) == 3, 'Retry must reuse the already downloaded editor'
|
||||
assert len([digest for digest in server['requests'] if digest in games]) == 3, 'Retry must reuse the already downloaded editor'
|
||||
assert by_name['shovey-editor']['bytes'] < by_name['shovey']['bytes'], 'The editor must carry only its additions'
|
||||
server['requests'].clear()
|
||||
# Disabling an entry must leave a person's older Chess save untouched.
|
||||
@@ -204,21 +215,22 @@ def main():
|
||||
answer_library_question(driver)
|
||||
window = subprocess.check_output(['xdotool', 'search', '--onlyvisible', '--pid', str(child.pid)], text=True).splitlines()[0]
|
||||
subprocess.run(['xdotool', 'windowsize', window, '480', '820'], check=True)
|
||||
grid(child, "apps-portrait")
|
||||
assert server['requests'] == [], 'Covers must not predownload games'
|
||||
grid(child, "apps-portrait", phone=True)
|
||||
assert not games & set(server['requests']), "Covers must not predownload games"
|
||||
# Covers show only the art; the download dialog names the size.
|
||||
cover_sizes = dict(sizes, **{'shovey-editor': size_text(by_name['shovey']['bytes'] + by_name['shovey-editor']['bytes'])})
|
||||
for text in cover_sizes.values():
|
||||
driver.wait(label=text, role='text', visible=False)
|
||||
assert not driver.find(label=text, role='text'), "Covers must not show download sizes"
|
||||
driver.press(label='Profile', role='button')
|
||||
driver.wait(label='Account', role='text')
|
||||
capture(child, 'arcade-profile')
|
||||
driver.press(label="Back", role="button")
|
||||
driver.wait(label='Shovey', role='button')
|
||||
assert not list((profile / 'resources/downloads').glob('*.zx'))
|
||||
assert not [path for path in (profile / 'resources/downloads').glob('*.zx') if path.stem in games]
|
||||
driver.press(label="Shovey", role="button")
|
||||
driver.wait(label='Cancel', role='button')
|
||||
driver.press(label='Cancel', role='button')
|
||||
assert server['requests'] == [], 'Cancel must download nothing'
|
||||
assert not games & set(server['requests']), 'Cancel must download nothing'
|
||||
driver.press(label="Shovey", role="button")
|
||||
primary_download()
|
||||
driver.wait(label=f"Level 1 / {classic}")
|
||||
@@ -275,15 +287,16 @@ def main():
|
||||
assert not driver.find(label='Pause', role='button'), 'Unverified bytes must never run'
|
||||
server['corrupt_wurm'] = False
|
||||
primary_download('Try again')
|
||||
driver.wait(label='Play', role='button', timeout=60)
|
||||
capture(child, 'wurm-title')
|
||||
driver.press(label='Play', role='button')
|
||||
# The cover is its title: Apfelwurm asks once how to move, then plays.
|
||||
driver.wait(label='How do you want to move?', role='text', timeout=60)
|
||||
driver.press(label='Swipe', role='button')
|
||||
driver.wait(label='Pause', role='button')
|
||||
capture(child, 'wurm-playing')
|
||||
driver.press(label='Pause', role='button')
|
||||
driver.wait(label='Resume', role='button')
|
||||
driver.press(label='Back to title', role='button')
|
||||
driver.wait(label='Play', role='button')
|
||||
capture(child, 'wurm-title')
|
||||
driver.press(label='Back', role='button')
|
||||
driver.wait(label='Shovey', role='button')
|
||||
for entry in json.loads((root / 'build/arcade.json').read_text())['children']:
|
||||
|
||||
@@ -8,9 +8,32 @@ import unittest
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / 'scripts'))
|
||||
from game_resources import dependency_order, share_resources
|
||||
from game_packages import declared_apps
|
||||
|
||||
|
||||
class GameResourcesTest(unittest.TestCase):
|
||||
def test_shared_code_requires_explicit_dependencies_and_valid_library_entries(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
(root / 'games.json').write_text(json.dumps({'packages': []}))
|
||||
(root / 'catalog.json').write_text(json.dumps({'id': 'editor', 'name': 'editor'}))
|
||||
app = {'manifest': 'catalog.json', 'requires': ['game'], 'shared_code': True,
|
||||
'library_entries': ['engine:Step']}
|
||||
|
||||
def declare(value):
|
||||
(root / 'apps.json').write_text(json.dumps(
|
||||
{'id': 'fixture', 'title': 'Fixture', 'apps': [value]}))
|
||||
return declared_apps(root)[0]
|
||||
|
||||
parsed = declare(app)
|
||||
self.assertTrue(parsed['shared_code'])
|
||||
self.assertEqual(parsed['library_entries'], ['engine:Step'])
|
||||
for invalid in [app | {'requires': []}, app | {'shared_code': 1},
|
||||
app | {'library_entries': ['engine:../Step']},
|
||||
app | {'library_entries': ['engine:Step', 'engine:Step']}]:
|
||||
with self.subTest(invalid=invalid), self.assertRaises(ValueError):
|
||||
declare(invalid)
|
||||
|
||||
def test_dependency_order_rejects_missing_disabled_and_cyclic_games(self):
|
||||
base = dict(enabled=True, descriptor=dict(id='game'), requires=[])
|
||||
editor = dict(enabled=True, descriptor=dict(id='editor'), requires=['game'])
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
// Open Arcade's browser edition in a private headless browser and require
|
||||
// its library to draw without a failed frame. Usage: node tests/web_site_test.mjs SITE_DIR
|
||||
import { spawn } from 'node:child_process';
|
||||
import { createServer } from 'node:http';
|
||||
import { access, mkdtemp, readFile, rm } from 'node:fs/promises';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { extname, join, normalize } from 'node:path';
|
||||
import { setTimeout as delay } from 'node:timers/promises';
|
||||
|
||||
const site = process.argv[2];
|
||||
if (!site) throw new Error('Usage: node tests/web_site_test.mjs SITE_DIR');
|
||||
const types = { '.html': 'text/html', '.js': 'text/javascript', '.wasm': 'application/wasm', '.json': 'application/json',
|
||||
'.svg': 'image/svg+xml', '.png': 'image/png', '.jpg': 'image/jpeg', '.webmanifest': 'application/manifest+json' };
|
||||
const server = createServer(async (request, response) => {
|
||||
const path = normalize(decodeURIComponent(new URL(request.url, 'http://x').pathname)).replace(/^\/+/, '') || 'index.html';
|
||||
try {
|
||||
const body = await readFile(join(site, path));
|
||||
response.writeHead(200, { 'Content-Type': types[extname(path)] || 'application/octet-stream' });
|
||||
response.end(body);
|
||||
} catch { response.writeHead(404); response.end(); }
|
||||
});
|
||||
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
|
||||
const profile = await mkdtemp(join(process.env.TMPDIR || tmpdir(), 'arcade-web-'));
|
||||
const env = { ...process.env };
|
||||
for (const key of ['DISPLAY', 'WAYLAND_DISPLAY', 'XAUTHORITY', 'DBUS_SESSION_BUS_ADDRESS']) delete env[key];
|
||||
const browser = spawn(process.env.CHROMIUM || 'chromium', ['--headless=new', '--no-sandbox', '--use-gl=swiftshader',
|
||||
'--enable-unsafe-swiftshader', '--no-first-run', '--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank'],
|
||||
{ env, detached: true, stdio: 'ignore' });
|
||||
let socket, sequence = 0;
|
||||
const pending = new Map(), console_lines = [];
|
||||
const command = (method, params = {}) => new Promise((resolve, reject) => {
|
||||
const id = ++sequence; pending.set(id, { resolve, reject }); socket.send(JSON.stringify({ id, method, params }));
|
||||
});
|
||||
let failure = '';
|
||||
try {
|
||||
const started = Date.now();
|
||||
while (true) {
|
||||
try { await access(join(profile, 'DevToolsActivePort')); break; } catch {}
|
||||
if (Date.now() - started > 15000) throw new Error('the browser did not start');
|
||||
await delay(50);
|
||||
}
|
||||
const port = (await readFile(join(profile, 'DevToolsActivePort'), 'utf8')).split('\n')[0];
|
||||
const targets = await (await fetch(`http://127.0.0.1:${port}/json/list`)).json();
|
||||
socket = new WebSocket(targets.find(target => target.type === 'page').webSocketDebuggerUrl);
|
||||
await new Promise((resolve, reject) => { socket.onopen = resolve; socket.onerror = reject; });
|
||||
socket.onmessage = event => {
|
||||
const message = JSON.parse(event.data);
|
||||
if (message.method === 'Runtime.consoleAPICalled')
|
||||
console_lines.push(message.params.args.map(arg => arg.value ?? arg.description ?? '').join(' '));
|
||||
const request = pending.get(message.id);
|
||||
if (!request) return;
|
||||
pending.delete(message.id);
|
||||
message.error ? request.reject(new Error(JSON.stringify(message.error))) : request.resolve(message.result);
|
||||
};
|
||||
await command('Runtime.enable'); await command('Page.enable');
|
||||
await command('Emulation.setDeviceMetricsOverride', { width: 1280, height: 800, deviceScaleFactor: 1, mobile: false });
|
||||
await command('Page.navigate', { url: `http://127.0.0.1:${server.address().port}/` });
|
||||
let ready = false;
|
||||
const deadline = Date.now() + 60000;
|
||||
while (!ready && Date.now() < deadline) {
|
||||
// The page may still be loading; it answers once its status element exists.
|
||||
const state = await command('Runtime.evaluate', {
|
||||
expression: 'JSON.stringify({ready: !!(window.Module && Module.profileReady), error: !!document.getElementById("loading")?.classList.contains("error")})',
|
||||
returnByValue: true });
|
||||
if (typeof state.result?.value !== 'string') { await delay(250); continue; }
|
||||
const value = JSON.parse(state.result.value);
|
||||
if (value.error) { failure = 'the page reported that Arcade could not start'; break; }
|
||||
ready = value.ready;
|
||||
if (!ready) await delay(250);
|
||||
}
|
||||
if (!ready && !failure) failure = 'the library never became ready';
|
||||
// Let the library draw several frames before judging them.
|
||||
await delay(3000);
|
||||
const failed = console_lines.find(line => /frame failed|portable execution failed/.test(line));
|
||||
if (!failure && failed) failure = failed;
|
||||
} finally {
|
||||
try { process.kill(-browser.pid, 'SIGTERM'); } catch {}
|
||||
server.close();
|
||||
await rm(profile, { recursive: true, force: true }).catch(() => {});
|
||||
}
|
||||
if (failure) {
|
||||
console.error(console_lines.slice(-20).join('\n'));
|
||||
throw new Error(failure);
|
||||
}
|
||||
console.log('Arcade opened its library in the browser');
|
||||
@@ -1,14 +1,6 @@
|
||||
{
|
||||
"format": 1,
|
||||
"packages": [
|
||||
{
|
||||
"commit": "ce01eafebd60cf0f729154fa6c735a37cd907d2d",
|
||||
"dependencies": {"crypto": "pc23fbf455e97614d", "kryon": "p2d318e48a4d2aa44"},
|
||||
"id": "p00c3077d466cc4cc",
|
||||
"name": "Apps",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/waozixyz/apps.git"
|
||||
},
|
||||
{
|
||||
"commit": "b31299434c785d0f2bd82f36b5bfd2fd36ba1216",
|
||||
"dependencies": {},
|
||||
@@ -28,7 +20,7 @@
|
||||
},
|
||||
{
|
||||
"commit": "1cb9df183089a77c8a16448a556186f30b261a98",
|
||||
"dependencies": {"kryon": "p2d318e48a4d2aa44"},
|
||||
"dependencies": {"kryon": "pc345e310c75f8d37"},
|
||||
"id": "p1b13dda539ed2a39",
|
||||
"name": "Kss",
|
||||
"ref": "master",
|
||||
@@ -36,7 +28,7 @@
|
||||
},
|
||||
{
|
||||
"commit": "bad2caaa84ef3eae61e40c99bf572d2b060d0ca2",
|
||||
"dependencies": {"kryon": "p2d318e48a4d2aa44"},
|
||||
"dependencies": {"kryon": "pc345e310c75f8d37"},
|
||||
"id": "p20eb23d3e6db3711",
|
||||
"name": "Game2D",
|
||||
"ref": "master",
|
||||
@@ -53,20 +45,12 @@
|
||||
},
|
||||
{
|
||||
"commit": "be74b13fd9b991e63a96360e8f13d781cece964e",
|
||||
"dependencies": {"daochi_client": "p9972fcdd2d5ba999", "kryon": "p2d318e48a4d2aa44", "monocypher": "p809b4d31a48625a3", "qrcode": "p0dfa70137405b096"},
|
||||
"dependencies": {"daochi_client": "p9972fcdd2d5ba999", "kryon": "pc345e310c75f8d37", "monocypher": "p809b4d31a48625a3", "qrcode": "p0dfa70137405b096"},
|
||||
"id": "p2b0009b9bbaa09de",
|
||||
"name": "Entity",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/waozixyz/entity.git"
|
||||
},
|
||||
{
|
||||
"commit": "92ca1fd68ced43969df57632720060ee9666da16",
|
||||
"dependencies": {"raylib": "p5a77c9c35110e925"},
|
||||
"id": "p2d318e48a4d2aa44",
|
||||
"name": "kryon",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/kryonlabs/kryon.git"
|
||||
},
|
||||
{
|
||||
"commit": "eb2b201a2da3bfc6fefd7ff2d8e476e3cb9e5bcb",
|
||||
"dependencies": {},
|
||||
@@ -78,7 +62,7 @@
|
||||
},
|
||||
{
|
||||
"commit": "2f6f1f57d7de742ef7ebc01159c2315acf793d5b",
|
||||
"dependencies": {"apps": "p00c3077d466cc4cc", "crypto": "pc23fbf455e97614d", "curl": "p2f75403ea4cb61e4", "daochi_client": "p9972fcdd2d5ba999", "game2d": "p20eb23d3e6db3711", "kryon": "p2d318e48a4d2aa44", "kss": "p1b13dda539ed2a39", "liboqs": "p4b0a50b49959e674", "mingcute": "pe1027b9d16704793", "monocypher": "p809b4d31a48625a3", "oqs": "p7098ac9cd92f7e5f", "plot": "pab5377a2950368a2", "qrcode": "p0dfa70137405b096", "rini": "p09fa77e94b0dfc6c", "self": "pa4da0de6c3c44e61", "sqlite": "p219661bf4be659ed"},
|
||||
"dependencies": {"apps": "p7407a72c65eeeb2b", "crypto": "pc23fbf455e97614d", "curl": "p2f75403ea4cb61e4", "daochi_client": "p9972fcdd2d5ba999", "game2d": "p20eb23d3e6db3711", "kryon": "pc345e310c75f8d37", "kss": "p1b13dda539ed2a39", "liboqs": "p4b0a50b49959e674", "mingcute": "pe1027b9d16704793", "monocypher": "p809b4d31a48625a3", "oqs": "p7098ac9cd92f7e5f", "plot": "pab5377a2950368a2", "qrcode": "p0dfa70137405b096", "rini": "p09fa77e94b0dfc6c", "self": "pa4da0de6c3c44e61", "sqlite": "p219661bf4be659ed"},
|
||||
"id": "p48228a6b7e2920d3",
|
||||
"name": "Inbe",
|
||||
"ref": "master",
|
||||
@@ -93,6 +77,14 @@
|
||||
"source": true,
|
||||
"url": "https://github.com/open-quantum-safe/liboqs.git"
|
||||
},
|
||||
{
|
||||
"commit": "481ec2a6cdee05680bd809d3436134ef670db6ce",
|
||||
"dependencies": {"apps": "p7407a72c65eeeb2b", "kryon": "pc345e310c75f8d37", "mingcute": "pe1027b9d16704793"},
|
||||
"id": "p4b52e2fb4081447c",
|
||||
"name": "Apfelwurm",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/waozixyz/wurm.git"
|
||||
},
|
||||
{
|
||||
"commit": "fafa2cea97d0cb379d832086ba45a989fa6f9c8e",
|
||||
"dependencies": {},
|
||||
@@ -110,6 +102,22 @@
|
||||
"ref": "master",
|
||||
"url": "https://github.com/ziranlang/oqs.git"
|
||||
},
|
||||
{
|
||||
"commit": "96e0ac55add63c65bea22dc2395a751e0b048fc1",
|
||||
"dependencies": {"crypto": "pc23fbf455e97614d", "kryon": "pc345e310c75f8d37"},
|
||||
"id": "p7407a72c65eeeb2b",
|
||||
"name": "Apps",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/waozixyz/apps.git"
|
||||
},
|
||||
{
|
||||
"commit": "83c89a86b0047f1d539c2465ad87087597a8c156",
|
||||
"dependencies": {"apps": "p7407a72c65eeeb2b", "entity": "p2b0009b9bbaa09de", "kryon": "pc345e310c75f8d37", "mingcute": "pe1027b9d16704793"},
|
||||
"id": "p7e870c2925a901aa",
|
||||
"name": "Shovey",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/waozixyz/shovey.git"
|
||||
},
|
||||
{
|
||||
"commit": "f5f0a19a5dc6c14a49adb3cd63ea79a60f6ba77b",
|
||||
"dependencies": {},
|
||||
@@ -129,7 +137,7 @@
|
||||
},
|
||||
{
|
||||
"commit": "357a71d1ee2c7c9526c2af18793ea8628c505034",
|
||||
"dependencies": {"daochi_client": "p9972fcdd2d5ba999", "kryon": "p2d318e48a4d2aa44", "monocypher": "p809b4d31a48625a3", "qrcode": "p0dfa70137405b096"},
|
||||
"dependencies": {"daochi_client": "p9972fcdd2d5ba999", "kryon": "pc345e310c75f8d37", "monocypher": "p809b4d31a48625a3", "qrcode": "p0dfa70137405b096"},
|
||||
"id": "pa4da0de6c3c44e61",
|
||||
"name": "Self",
|
||||
"ref": "master",
|
||||
@@ -137,20 +145,12 @@
|
||||
},
|
||||
{
|
||||
"commit": "3f888653b6b97010163d824c4cc72476be3214f3",
|
||||
"dependencies": {"kryon": "p2d318e48a4d2aa44"},
|
||||
"dependencies": {"kryon": "pc345e310c75f8d37"},
|
||||
"id": "pab5377a2950368a2",
|
||||
"name": "plot",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/kryonlabs/plot.git"
|
||||
},
|
||||
{
|
||||
"commit": "a6aebdbb5af7491b9303e70aed85b32c70a127a2",
|
||||
"dependencies": {"apps": "p00c3077d466cc4cc", "kryon": "p2d318e48a4d2aa44", "mingcute": "pe1027b9d16704793"},
|
||||
"id": "pb047b340fde29f6b",
|
||||
"name": "Apfelwurm",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/waozixyz/wurm.git"
|
||||
},
|
||||
{
|
||||
"commit": "944826f70779a6b6cd53f6b06a75b36f4d8a2558",
|
||||
"dependencies": {},
|
||||
@@ -159,6 +159,14 @@
|
||||
"ref": "master",
|
||||
"url": "https://github.com/ziranlang/crypto.git"
|
||||
},
|
||||
{
|
||||
"commit": "919a18d7fca3b052c1a694aff105f5937d723e3f",
|
||||
"dependencies": {"raylib": "p5a77c9c35110e925"},
|
||||
"id": "pc345e310c75f8d37",
|
||||
"name": "kryon",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/kryonlabs/kryon.git"
|
||||
},
|
||||
{
|
||||
"commit": "9cc6872f75447c3a24c16764f9829d0f58751cb0",
|
||||
"dependencies": {},
|
||||
@@ -166,22 +174,14 @@
|
||||
"name": "mingcute",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/kryonlabs/mingcute.git"
|
||||
},
|
||||
{
|
||||
"commit": "2c05b39693a6d8a697f5b111f9d438092b4f186a",
|
||||
"dependencies": {"apps": "p00c3077d466cc4cc", "entity": "p2b0009b9bbaa09de", "kryon": "p2d318e48a4d2aa44", "mingcute": "pe1027b9d16704793"},
|
||||
"id": "ped09a2b79138be62",
|
||||
"name": "Shovey",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/waozixyz/shovey.git"
|
||||
}
|
||||
],
|
||||
"root": {
|
||||
"dependencies": {"apps": "p00c3077d466cc4cc", "entity": "p2b0009b9bbaa09de", "inbe": "p48228a6b7e2920d3", "kryon": "p2d318e48a4d2aa44", "mingcute": "pe1027b9d16704793", "shovey": "ped09a2b79138be62", "wurm": "pb047b340fde29f6b"},
|
||||
"dependencies": {"apps": "p7407a72c65eeeb2b", "entity": "p2b0009b9bbaa09de", "inbe": "p48228a6b7e2920d3", "kryon": "pc345e310c75f8d37", "mingcute": "pe1027b9d16704793", "shovey": "p7e870c2925a901aa", "wurm": "p4b52e2fb4081447c"},
|
||||
"name": "Arcade"
|
||||
},
|
||||
"toolchain": {
|
||||
"commit": "21c6a681c9ba684bbe069004fd971748cc5c7dc0",
|
||||
"commit": "5efa24f818485cf265bdd5c066a4e2150175ac0e",
|
||||
"ref": "master",
|
||||
"url": "https://github.com/ziranlang/ziran.git"
|
||||
}
|
||||
|
||||