Treasure Seas

Alex Churchill
/
Treasure Seas
on 4 Nov 2026
2
14
7
0
9927
game.m
function g = game()
%game Treasure Seas: a one-button exploration game.
%
%   The boat spins constantly; each tap is a rowing stroke along the red
%   line, and drag slowly brings the boat to rest. Circle an island as
%   many times as its number shows to reveal its treasure. Archipelagos
%   hide treasure behind rings of rocks. Treasure maps reveal a chest
%   far away, with a gold pointer showing the way. Find every treasure to
%   start a harder voyage. Rocks and sharks each cost one of three hull
%   points; lose them all and the game ends.
%
%   Character budget note: the contest counts tree2str(mtree(...)) of
%   this file, which re-indents every line and adds spaces after commas
%   and inside brackets. Comments are free; statements, nesting depth and
%   array literals are what cost. Hence the vectorised update below.

g.init   = @initState;
g.update = @updateState;
g.render = @renderFrame;
end

function s = initState(ax)
% Tunables. seed = [] gives a new random sea every voyage; a number gives
% the same sea for each voyage level, for reproducible testing.
s.seed = [];
s.W = 3000;             % world size: about 3.75 x 3.75 screens to explore
s.H = 2250;
s.nI = 4;               % islands (treasure revealed by circling)
s.nA = 3;               % archipelagos (treasure inside a ring of rocks)
s.nT = 2;               % treasure maps (each reveals a distant chest)
s.nS = 4;               % shark pool; voyage v uses min(v, nS) of them
s.spin = 2.4;           % boat heading rotation, rad/s
s.kick = 85;            % speed added by one stroke
s.drag = .9;            % exponential drag rate, 1/s
s.vmax = 320;
s.ax = ax;
s.voyage = 1;
s.voy = '';             % HUD voyage label, shown only from voyage 2 on
s.best = Inf;          % best completion time this session
s.mapId = 0;            % bumps on every new map so render redraws terrain
s.mode = 0;             % 0 title, 1 sailing, 2 game over / voyage complete
s.wait = 0;             % seconds before a tap may dismiss the message
s.msg = {'TREASURE SEAS', '', 'Tap to row along the red line', ...
    'Circle islands to reveal treasure', 'Rocks and sharks damage the hull'};

ax.Color = [.05 .32 .48];
o = {'HitTest', 'off', 'PickableParts', 'none'};
% Shared patch options. Round line joins stop thick outlines (beaches,
% boat) drawing spiky miter points, notably at the closing vertex in the
% MATLAB Online renderer.
pp = [{'XData', NaN, 'YData', NaN, 'EdgeColor', 'none', 'LineJoin', 'round'}, o];

% Shallows: the circling zone round each island that still needs laps.
% Created first so it lies beneath everything, wave flecks included.
s.g.shal = patch(ax, pp{:}, FaceColor = [.1 .34 .54]);

% Static wave flecks give a sense of motion as the camera scrolls.
line(ax, s.W*rand(1, 900), s.H*rand(1, 900), o{:}, LineStyle = 'none', ...
    Marker = '.', Color = [.25 .45 .65]);
rectangle(ax, o{:}, Position = [0 0 s.W s.H], EdgeColor = [.9 .8 .5], ...
    LineWidth = 3);

% Terrain: one multi-face patch per layer, refilled on each new map. A
% thick sand-coloured edge draws the beach round each island.
s.g.land = patch(ax, pp{:}, FaceColor = [.24 .58 .3], ...
    EdgeColor = [.88 .8 .52], LineWidth = 8);
s.g.rock = patch(ax, pp{:}, FaceColor = [.5 .47 .45]);

% Lap counters, one text per island (text with vector x/y returns a pool).
% tb is shared by the bold, centred texts.
z = zeros(s.nI, 1);
tb = [{'FontWeight', 'bold', 'HorizontalAlignment', 'center'}, o];
s.g.cnt = text(ax, z, z, '', tb{:}, FontSize = 22);

% Chests, maps and sharks are marker-only lines; hidden items get NaN
% coords. The world is drawn 1:1 with screen pixels, so marker sizes are
% stable.
mk = [{NaN, NaN, 'LineStyle', 'none', 'LineWidth', 2}, o];
s.g.ch = line(ax, mk{:}, Marker = 's', MarkerSize = 12, ...
    MarkerFaceColor = [1 .8 .1], Color = [.5 .3 0]);
s.g.map = line(ax, mk{:}, Marker = 's', MarkerSize = 12, ...
    MarkerFaceColor = [.6 .25 .15], Color = [.95 .85 .6]);
s.g.shark = line(ax, mk{:}, Marker = 'o', MarkerSize = 18, ...
    MarkerFaceColor = [.35 .38 .42], Color = [.9 .9 .9]);

% Gold pointers from the boat towards chests whose maps have been found.
s.g.ptr = line(ax, NaN, NaN, o{:}, Color = [1 .8 .1], LineStyle = ':', LineWidth = 3);

% Boat and its faint red heading line.
s.g.aim = line(ax, [0 0], [0 0], o{:}, Color = [1 .25 .25 .5], LineWidth = 2);
s.g.boat = patch(ax, pp{:}, FaceColor = [.6 .35 .15], ...
    EdgeColor = [1 .9 .7], LineWidth = 1.5);

% HUD and centre message; repositioned every frame to follow the camera.
s.g.hud = text(ax, 0, 0, '', o{:}, Color = 'w', FontSize = 14, ...
    FontName = 'FixedWidth', VerticalAlignment = 'top');
% Hull bar, top right: a dark backing with a fill that shrinks per hit.
s.g.hpBg = rectangle(ax, o{:}, FaceColor = [0 0 0 .5], EdgeColor = 'w');
s.g.hp = rectangle(ax, o{:}, EdgeColor = 'none');
s.g.msg = text(ax, 0, 0, '', tb{:}, Color = [1 .9 .5], FontSize = 20, ...
    BackgroundColor = [0 0 0 .5], Margin = 12);
s = newMap(s);
end

function s = newMap(s)
% Generate a fresh sea for the current voyage and reset the boat.
if isempty(s.seed)
    rng('shuffle');
else
    rng(s.seed + s.voyage);
end

% Difficulty ramps per voyage, not within one: tighter rock gaps, faster
% and more numerous sharks (sharkV is the average shark speed). The gap
% never drops below 40, comfortably wider than the 14-unit boat.
v = s.voyage;
s.gap = max(40, 80 - 10*v);
s.sharkV = 45 + 10*v;

% occ lists [x y r] keep-out circles so features don't overlap. The start
% point at the centre of the world gets a small clear area, so features
% can be in view from the first frame.
c0 = [s.W s.H]/2;

% Islands: radius 20-100, with room around each to sail circles. The
% first sits 330 from the start, just at the edge of the opening view,
% and has a lap count of 0 so its chest is an easy first find.
b = 2*pi*rand;
I = [c0 + 330*[cos(b) sin(b)], 50];
occ = [c0 150; I + [0 0 200]];
for k = 2:s.nI
    r = 20 + 80*rand;
    [p, occ] = place(s, occ, r+200);
    I(k, :) = [p r];
end

% Archipelagos: rocks scattered in an annulus round a central chest. Any
% two rocks keep at least s.gap of clear water between them, so a route
% to the chest always exists (the inflated rocks are disjoint discs).
A = zeros(s.nA, 2);
R = zeros(0, 3);
for k = 1:s.nA
    [A(k, :), occ] = place(s, occ, 230);
    for t = 1:300
        rr = 10 + 10*rand;
        a = 2*pi*rand;
        c = A(k, :) + (55 + 100*sqrt(rand))*[cos(a) sin(a)];
        if all(dst(R, c) > R(:, 3)+rr+s.gap)
            R(end+1, :) = [c rr]; %#ok<AGROW>
        end
    end
end

% Lone rocks dotted about the open sea.
for k = 1:15
    rr = 10 + 20*rand;
    [p, occ] = place(s, occ, rr+40);
    R(end+1, :) = [p rr]; %#ok<AGROW>
end
s.isl = I;
s.rocks = R;

% Treasure maps in open sea. Each map's chest is placed at least 600
% from the map (a temporary keep-out round it), clear of everything else.
T = zeros(s.nT, 2);
s.mapP = T;
for k = 1:s.nT
    [s.mapP(k, :), occ] = place(s, occ, 40);
    T(k, :) = place(s, [occ; s.mapP(k, :) 600], 20);
    occ(end+1, :) = [T(k, :) 20]; %#ok<AGROW>
end
s.mapGot = false(s.nT, 1);

% Chests are [islands; archipelagos; maps]. Island chests sit just off a
% random point of the shore and appear when that island's lap count
% (0-2) reaches zero; archipelago chests show from the start; map chests
% show once their map is collected. acc accumulates signed angle swept
% round each island; z flags which islands' circling zone the boat was
% in last frame.
a = 2*pi*rand(s.nI, 1);
a(1) = b + pi;          % the first island's chest faces the start
s.chP = [I(:, 1:2) + (I(:, 3)+28).*[cos(a) sin(a)]; A; T];
s.laps = [0; randi(3, s.nI-1, 1) - 1];
s.acc = 0*a;
s.ang = a;
s.z = false(s.nI, 1);
s.total = s.nI + s.nA + s.nT;
s.got = false(s.total, 1);

% Sharks start well away from the boat. Each gets a temperament sk, a
% shuffle of 1/4, 2/4, 3/4, 1 so no two sharks are alike: speed scales by
% .85 + .3*sk and it aims sk*1.2 seconds ahead of the boat, so fast
% sharks try to cut the boat off while slow ones trail it. Their paths
% differ, so sharks rarely stack on top of each other.
M = zeros(s.nS, 2);
for k = 1:s.nS
    M(k, :) = place(s, [occ; c0 900], 20);
end
s.mon = M;
s.mOn = (1:s.nS)' <= v;
s.sk = randperm(s.nS)'/s.nS;

% Precompute terrain patch geometry; render pushes it once per map.
[s.landV, s.landF] = circles(I, .12);
[s.rockV, s.rockF] = circles(R, .25);
[s.shV, s.shF] = circles(I + [0 0 250], 0);
s.mapId = s.mapId + 1;

s.p = c0;
s.v = [0 0];
s.th = 0;
s.t = 0;
s.found = 0;
s.hp = 3;
s.inv = 0;              % invulnerability seconds left after a hit
end

function [p, occ] = place(s, occ, r)
% Random point whose circle of radius r clears every circle in occ.
% Gives up after 500 tries and accepts the last point (the sea is
% sparse enough that this never matters in practice).
for t = 1:500
    p = [r+(s.W-2*r)*rand, r+(s.H-2*r)*rand];
    if all(dst(occ, p) > occ(:, 3)+r), break; end
end
occ(end+1, :) = [p r];
end

function [V, F] = circles(C, j)
% Patch data for rough 32-gons C = [x y r], one face each; j is the
% radial jitter fraction that makes them look like natural coastline.
a = (0:31)'*pi/16;
m = size(C, 1);
V = zeros(m*32, 2);
for k = 1:m
    V(k*32-31:k*32, :) = C(k, 1:2) + C(k, 3)*(1 + j*(rand(32, 1)-.5)).*[cos(a) sin(a)];
end
F = reshape(1:m*32, 32, m)';
end

function s = updateState(s, dt, pressed)
% The heading spins in every mode, so the title screen shows it off.
s.th = mod(s.th + s.spin*dt, 2*pi);

% Title / end screens: a tap (after a short guard delay so a frantic
% last stroke doesn't skip the message) starts sailing, building a new
% map first if a voyage just ended.
if s.mode ~= 1
    s.wait = s.wait - dt;
    if pressed && s.wait <= 0
        if s.mode == 2, s = newMap(s); end
        s.mode = 1;
    end
    return
end
s.t = s.t + dt;
s.inv = s.inv - dt;

% Rowing: impulse along the heading, exponential drag, speed cap.
s.v = (s.v + pressed*s.kick*[cos(s.th) sin(s.th)])*exp(-s.drag*dt);
s.v = s.v*min(1, s.vmax/max(norm(s.v), 1));
s.p = s.p + s.v*dt;

% World edge: clamp and bounce back at half speed.
L = [s.W s.H];
e = s.p < 10 | s.p > L-10;
s.v(e) = -s.v(e)/2;
s.p = min(max(s.p, 10), L-10);

% Beaching on an island is harmless. Rocks bounce the boat off more
% sharply and cost a hull point.
s = bounce(s, s.isl, .5);
[s, k] = bounce(s, s.rocks, .8);
if k
    s = hurt(s, 'Wrecked on the rocks!');
    if s.mode > 1, return; end
end

% Lap counting: while the boat stays within 250 of an unfinished
% island's shore, add up the (wrapped) angle it sweeps round the centre.
% A full turn either way knocks one off that island's counter. Leaving
% the zone resets the partial lap.
d = s.p - s.isl(:, 1:2);
a = atan2(d(:, 2), d(:, 1));
z = s.laps > 0 & dst(d, 0) < s.isl(:, 3)+250;
s.acc = z.*(s.acc + s.z.*(mod(a - s.ang + pi, 2*pi) - pi));
lap = abs(s.acc) >= 2*pi;
s.laps = s.laps - lap;
s.acc(lap) = 0;
s.ang = a;
s.z = z;

% Maps and chests: sail over one to collect it. A chest only counts
% once revealed.
s.mapGot = s.mapGot | dst(s.mapP, s.p) < 22;
on = [s.laps == 0; true(s.nA, 1); s.mapGot];
s.got = s.got | on & dst(s.chP, s.p) < 22;
s.found = sum(s.got);
if s.found == s.total
    s.best = min(s.best, s.t);
    s = endGame(s, ['All treasure found in ' mmss(s.t) '!'], 1);
    return
end

% Sharks always hunt the boat, slowly, each at its own speed and lead.
e = s.p + 1.2*s.sk.*s.v - s.mon;
n = max(dst(e, 0), 1e-6);
s.mon = s.mon + e./n.*min(n, s.sharkV*(.85 + .3*s.sk)*dt);

% Keep sharks off land: one that strays onto an island is pushed back
% out to the shore of the nearest one. Combined with the pull towards
% its target, that makes it slide round the coast instead of crossing.
I = s.isl;
[q, j] = min(hypot(s.mon(:, 1)-I(:, 1)', s.mon(:, 2)-I(:, 2)') - I(:, 3)', [], 2);
o = q < 16;
s.mon(o, :) = I(j(o), 1:2) + (s.mon(o, :) - I(j(o), 1:2)).*(I(j(o), 3)+16)./(q(o)+I(j(o), 3));

% A bite costs a hull point and knocks the biter 250 back from the boat.
e = s.mon - s.p;
n = max(dst(e, 0), 1e-6);
hit = s.mOn & n < 18;
if any(hit) && s.inv <= 0
    s.mon(hit, :) = s.p + 250*e(hit, :)./n(hit);
    s = hurt(s, 'Eaten by a shark!');
end
end

function [s, k] = bounce(s, C, e)
% Push the boat out of the first circle in C = [x y r] it overlaps and
% reflect the inward part of its velocity with restitution e. k is that
% circle's index, or empty if there was no contact.
d = s.p - C(:, 1:2);
D = dst(d, 0);
k = find(D < C(:, 3)+8, 1);
if k
    n = d(k, :)/D(k);
    s.p = C(k, 1:2) + n*(C(k, 3)+8);
    s.v = s.v - (1+e)*min(0, s.v*n')*n;
end
end

function D = dst(X, p)
% Distance from the [x y] in each row of X to the point p.
D = vecnorm(X(:, 1:2) - p, 2, 2);
end

function s = hurt(s, m)
% Take one hull point unless still invulnerable from the last hit; the
% third hit ends the game with message m.
if s.inv <= 0
    s.hp = s.hp - 1;
    s.inv = 2;
    if s.hp <= 0, s = endGame(s, m, 0); end
end
end

function s = endGame(s, m, won)
% Show the end message. Completing a voyage moves on to a harder one;
% any loss sends the player back to voyage 1.
s.mode = 2;
s.wait = 1;
if won
    s.voyage = s.voyage + 1;
    s.voy = sprintf('   Voyage %d', s.voyage);
    s.msg = {m, ['Best: ' mmss(s.best)], '', sprintf('Tap for voyage %d', s.voyage)};
else
    s.voyage = 1;
    s.voy = '';
    s.msg = {m, sprintf('%d of %d treasures', s.found, s.total), '', 'Tap to try again'};
end
end

function str = mmss(t)
% Format seconds as m:ss.
str = sprintf('%d:%02d', floor(t/60), floor(mod(t, 60)));
end

function renderFrame(~, s)
G = s.g;

% Terrain only changes with the map; the patch remembers which map it
% last drew in UserData, which keeps render idempotent and cheap.
if ~isequal(G.rock.UserData, s.mapId)
    set(G.land, Faces = s.landF, Vertices = s.landV);
    set(G.rock, Faces = s.rockF, Vertices = s.rockV, UserData = s.mapId);
end

% Camera follows the boat, clamped to the world edges.
c = min(max(s.p, [400 300]), [s.W-400 s.H-300]);
s.ax.XLim = c(1) + [-400 400];
s.ax.YLim = c(2) + [-300 300];

% Boat: a triangle pointing along the heading, plus the red stroke line.
u = [cos(s.th) sin(s.th)];
w = [-u(2) u(1)];
B = s.p + [14*u; 7*w-9*u; -7*w-9*u];
xy(G.boat, B);
G.boat.Visible = s.inv <= 0 | mod(s.t, .2) < .1;
xy(G.aim, s.p + [0; 80]*u);

% Island counters: blank once done, yellow while the boat is circling.
% A finished island maps to a space, which cellstr trims to ''. Only
% unfinished islands keep their shallows.
n = s.laps;
set(G.shal, Vertices = s.shV, Faces = s.shF(n > 0, :));
set(G.cnt, {'Position'}, num2cell(s.isl(:, 1:2), 2), ...
    {'String'}, cellstr(char(48 + n - 16*(n == 0))), ...
    {'Color'}, num2cell([1 + 0*n, 1 + 0*n, ~s.z], 2));

% Chests, maps and sharks: NaN out anything hidden (0/0 is NaN).
xy(G.ch, s.chP + 0./(~s.got & [n == 0; true(s.nA, 1); s.mapGot]));
xy(G.map, s.mapP + 0./~s.mapGot);
xy(G.shark, s.mon + 0./s.mOn);

% Map pointers: a dash from 40 to 100 along the unit vector U towards
% each revealed, uncollected map chest; NaN rows hide the rest and also
% separate the dashes. [A B NaN]' reshaped to 2 columns interleaves the
% start, end and gap points of every dash.
C = s.chP(end-s.nT+1:end, :);
U = (C - s.p)./dst(C, s.p) + 0./(s.mapGot & ~s.got(end-s.nT+1:end));
xy(G.ptr, reshape([s.p + 40*U, s.p + 100*U, NaN*U]', 2, [])');

G.hud.Position = c + [-390 290];
G.hud.String = sprintf('Treasure %d/%d   %s%s', s.found, s.total, mmss(s.t), s.voy);
% Hull bar shades from green to red as points are lost.
G.hpBg.Position = [c + [240 272] 150 16];
G.hp.Position = [c + [240 272] 50*max(s.hp, .01) 16];
G.hp.FaceColor = [1 - s.hp/3, s.hp/3, .2];
G.msg.Position = c;
G.msg.Visible = s.mode ~= 1;
G.msg.String = s.msg;
end

function xy(h, P)
% Set a graphics object's coordinates from the rows [x y] of P.
set(h, XData = P(:, 1), YData = P(:, 2));
end
Play Game
Preview

Play Game opens this in MATLAB Drive. Click Run this app there to play.