Skill-based Rock Paper Scissors

Vignesh
/
Skill-based Rock Paper Scissors
on 6 Nov 2026
7
23
8
0
9969
game.m
function g = game()
%game Skill-based Rock Paper Scissors! -- a one-button reflex game.
%
%   The top panel shows an object. Your panel (bottom) cycles through
%   rock, paper and scissors; the thin bar on its right shows how long
%   the current one stays. Tap (SPACE or click) at the right moment:
%     RED screen  "BEAT THIS"    -> tap when yours BEATS it
%     BLUE screen "LOSE TO THIS" -> tap when yours LOSES to it
%   Hitting on the first chance scores PERFECT (+3), the second GREAT
%   (+2), later GOOD (+1). A wrong tap costs one of 3 lives. Each tap
%   freezes the frame briefly so you can see what you hit. Each game has
%   60 seconds of play and the cycling speeds up with every hit.
%
%   Workflow:
%       >> minihackContest.validate   % check the contract and contest rules
%       >> minihackContest.play       % play locally at 30 fps
%       >> minihackContest.submit     % publish to the contest

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

function s = initState(ax)
% Main tunables (others are inline, marked "tunable")
s.gameLen = 60;          % seconds of play per game
s.maxLives = 3;
s.fxLen = 0.6;           % bonus effect duration
s.names = ["ROCK" "PAPER" "SCISSORS"];

% Speed bonus tiers: 1st chance, 2nd chance, later
s.tierName = ["PERFECT!" "GREAT!" "GOOD"];
s.tierCol = [1 0.82 0.15; 0.78 0.45 1; 0.45 0.75 1];
s.tierNP = [10 6 3];    % particle counts
s.tierBurst = [0.8 0.6 0.4];
s.botCol = [0.21 0.21 0.28];

% Game state; startGame/newRound fill in the per-game/per-round fields
s.t = 0;
s.hs = [];               % high scores for this session
s.pv = zeros(10, 2);     % particle velocities
s.wait = 0;
s.q = 0;                 % last question (target + rule) and its repeat count
s.rep = 0;
s = startGame(s);        % phase: 1 playing, 2 freeze frame, 3 game over
s.demo = true;           % attract mode: the game plays itself until a tap
s.msg = ["Skill-based"; "Rock Paper Scissors!"; ""
    "RED: tap what BEATS it"
    "BLUE: tap what LOSES to it"; ""
    "60 s  -  3 lives"; ""
    "TAP  (SPACE / click)  TO START"];

% Axes
ax.XLim = [0 800];
ax.YLim = [0 600];
ax.YDir = 'normal';
P = {'HitTest', 'off', 'PickableParts', 'none'};
box = @(x, y, c) patch(ax, x([1 2 2 1]), y([1 1 2 2]), c, 'EdgeColor', 'none', P{:});

% Background (tinted by the rule), panels, game clock bar
g.bg = box([-50 850], [-50 650], 'k');
g.topP = box([20 780], [315 525], 'k');
g.botP = box([20 780], [40 290], s.botCol);
box([20 780], [538 552], [0.25 0.25 0.3]);
g.bar = box([20 780], [538 552], 'k');

% HUD texts
txt = @(x, y, sz, varargin) text(ax, x, y, '', 'Color', 'w', ...
    'FontSize', sz, 'FontWeight', 'bold', 'HorizontalAlignment', 'center', ...
    varargin{:}, P{:});
g.score = txt(25, 575, 18, 'HorizontalAlignment', 'left');
g.time = txt(400, 575, 18);
g.lives = txt(775, 575, 22, 'HorizontalAlignment', 'right', ...
    'Color', [1 0.35 0.4]);
g.head = txt(400, 505, 20);
g.topL = txt(400, 333, 14);
g.botL = txt(400, 58, 14);

% Timing bar (right edge): fills upward while the current symbol shows
box([748 756], [70 260], [0.26 0.26 0.33]);
g.fill = box([748 756], [70 260], 'k');

% Bonus starburst and stars sit behind the icons so they never hide them
s.bAng = (0:23) * pi/12;
s.bRad = repmat([60 18], 1, 12);
g.burst = box([0 0], [0 0], 'w');
g.part = line(ax, NaN, NaN, 'LineStyle', 'none', 'Marker', 'p', ...
    'MarkerSize', 12, 'MarkerEdgeColor', 'w', P{:});

% Icons: one set on top, one for the player; toggled by visibility
for k = 1:3
    g.top(k) = makeIcon(ax, k, 400, 422, 68, P);
    g.bot(k) = makeIcon(ax, k, 400, 160, 72, P);
end

% Bonus pop-up texts, then the message box on top
g.pop = txt(400, 300, 36);
g.popSub = txt(630, 160, 26);
g.msg = txt(400, 300, 14, 'BackgroundColor', [0.1 0.1 0.14], ...
    'EdgeColor', [1 0.82 0.3], 'LineWidth', 1.5, 'Margin', 14, ...
    'Color', [1 0.82 0.3]);
s.g = g;
end

function s = updateState(s, dt, pressed)
s.t = s.t + dt;
% Attract mode: auto-tap on the answer (always PERFECT) with the clock
% held, until the player's first tap starts a real game
if s.demo
    s.left = s.gameLen;
    go = pressed;
    pressed = ~go && s.ply == s.ans && s.sw > 0.2;
    if go
        s = startGame(s);
    end
end
switch s.phase
    case 1
        s.left = s.left - dt;
        s.sw = s.sw + dt;
        if s.sw >= s.cyc
            s.sw = s.sw - s.cyc;
            s.prev = s.ply;
            s.ply = mod(s.ply, 3) + 1;
            s.chance = s.chance + (s.ply == s.ans);
        end
        % 0.05 s grace: a tap just after a switch still counts for the
        % symbol you were looking at (tunable)
        late = s.sw < 0.05 && s.prev == s.ans;
        if pressed && (s.ply == s.ans || late)
            s.ply = s.ans;
            s.sw = min(s.sw + late*s.cyc, s.cyc);
            s = scoreHit(s);
        elseif pressed
            verb = ["beat" "lose to"];
            s = loseLife(s, s.names(s.ply) + " does not " + ...
                verb(s.lose + 1) + " " + s.names(s.tgt) + "!");
        elseif s.left <= 0
            s = gameOver(s, "TIME'S UP!");
        end
    case 2
        % Freeze frame after a tap; the game clock is paused
        s.wait = s.wait - dt;
        if s.wait <= 0
            s.phase = 1;
            s = newRound(s);
        end
    case 3
        % Short lockout so a frantic tap doesn't instantly restart
        s.wait = s.wait - dt;
        if pressed && s.wait <= 0
            s = startGame(s);
        end
end
s.fxt = s.fxt + dt;
s.fx = s.fx * (s.fxt < s.fxLen);
end

function s = startGame(s)
s.score = 0;
s.hits = 0;
s.lives = s.maxLives;
s.left = s.gameLen;
s.fx = 0;                % bonus effect tier playing (0 = none)
s.fxt = 0;
s.miss = false;
s.demo = false;
s.phase = 1;
s = newRound(s);
end

function s = newRound(s)
s.tgt = randi(3);
% "LOSE TO THIS" rounds appear after 4 hits, 35% of the time (tunable)
s.lose = s.hits >= 4 && rand < 0.35;
% Same question at most twice in a row: otherwise switch to another target
if s.tgt + 3*s.lose == s.q && s.rep >= 2
    s.tgt = mod(s.tgt - 1 + randi(2), 3) + 1;
end
q = s.tgt + 3*s.lose;
s.rep = 1 + s.rep*(q == s.q);
s.q = q;
s.ans = mod(s.tgt + s.lose, 3) + 1;
% Time per symbol: 0.8 s, 2% faster per hit, floor 0.25 s (tunable)
s.cyc = max(0.25, 0.8 * 0.98^s.hits);
% Start the player on a wrong option so mashing can't win
opts = setdiff(1:3, s.ans);
s.ply = opts(randi(2));
s.prev = s.ply;
s.chance = 0;            % times the answer has been shown this round
s.sw = 0;                % time since the last symbol switch
end

function s = scoreHit(s)
tier = min(s.chance, 3);
s.hits = s.hits + 1;
s.score = s.score + 4 - tier;
s.fx = tier;
s.fxt = 0;
n = s.tierNP(tier);
a = 2*pi*rand(n, 1);
v = 180 + 300*rand(n, 1);
s.pv(1:n, :) = [v.*cos(a), v.*sin(a) + 180];
% Freeze 0.3 s on a hit (tunable)
s.phase = 2;
s.wait = 0.3;
s.miss = false;
end

function s = loseLife(s, reason)
s.lives = s.lives - 1;
s.fx = 0;
s.miss = true;
if s.lives <= 0
    s = gameOver(s, ["OUT OF LIVES!"; reason]);
    return
end
% Freeze 0.8 s on a miss, then continue (tunable)
s.phase = 2;
s.wait = 0.8;
s.msg = [reason; ""; "Lives left: " + s.lives];
end

function s = gameOver(s, headline)
s.phase = 3;
s.wait = 0.8;
s.fx = 0;
s.left = max(s.left, 0);
% Insert into the session's top 5 (ties rank below older scores)
rank = 1 + sum(s.hs >= s.score);
s.msg = [headline(:); ""; "Score: " + s.score];
if s.score > 0 && rank <= 5
    s.hs = [s.hs(1:rank-1), s.score, s.hs(rank:end)];
    s.hs = s.hs(1:min(end, 5));
    s.msg(end+1) = "NEW HIGH SCORE  #" + rank + " !";
end
s.msg = [s.msg; ""; "HIGH SCORES"
    compose("%d.   %d", (1:numel(s.hs))', s.hs(:)); ""
    "TAP TO PLAY AGAIN"];
end

function renderFrame(~, s)
% Properties are only written when they change; rewriting text and
% visibility every frame is what makes MATLAB graphics lag.
g = s.g;
fz = s.phase > 1;        % frozen (freeze frame or game over)

% Target and player icons
for k = 1:3
    sp(g.top(k), 'Visible', k == s.tgt);
    sp(g.bot(k), 'Visible', k == s.ply);
end
sp(g.topL, 'String', s.names(s.tgt));
marks = ["" "  " + char(10003) "  " + char(10007)];
sp(g.botL, 'String', s.names(s.ply) + marks(1 + fz*(1 + s.miss)));

% Rule: whole screen red "BEAT THIS" or blue "LOSE TO THIS"
heads = ["BEAT THIS" "LOSE TO THIS"];
sp(g.head, 'String', heads(s.lose + 1));
sp(g.head, 'Color', [1 0.75 0.75] + s.lose * [-0.3 0.15 0.25]);
sp(g.topP, 'FaceColor', [0.5 0.14 0.17] + s.lose * [-0.38 0.18 0.38]);
bgc = [0.28 0.06 0.08] + s.lose * [-0.23 0.09 0.24];
miss = s.miss && fz;
sp(g.botP, 'FaceColor', s.botCol + miss * [0.44 -0.09 -0.16]);

% Timing bar for the current symbol (muted green/red when frozen)
sp(g.fill, 'FaceColor', [0.45 0.45 0.55] + fz * ([-0.1 0.15 -0.15] + miss * [0.35 -0.3 0]));
h = 190 * s.sw / s.cyc;
g.fill.YData = 70 + [0 0 h h];

% HUD; the clock bar turns red for the last 10 s
f = s.left / s.gameLen;
g.bar.XData = [20 20+760*f 20+760*f 20];
sp(g.bar, 'FaceColor', [0.3 0.85 0.4] + (s.left < 10) * [0.65 -0.55 -0.15]);
sp(g.time, 'String', sprintf('%d', ceil(s.left)));
sp(g.score, 'String', sprintf('Score: %d', s.score));
sp(g.lives, 'String', [repmat(char(9829), 1, s.lives), ...
    repmat(char(9825), 1, s.maxLives - s.lives)]);

% Bonus effect: spinning burst, flying stars, punchy shaking text, flash
fx = s.fx > 0;
for h = [g.burst g.part g.pop g.popSub]
    sp(h, 'Visible', fx);
end
if fx
    e = s.fxt / s.fxLen;
    c = s.tierCol(s.fx, :);
    r = s.tierBurst(s.fx) * (1.2 + 2.5*e) * s.bRad;
    a = s.bAng + e*pi/3;
    % Fade by blending into the panel (cheaper than transparency)
    set(g.burst, 'XData', 400 + r.*cos(a), 'YData', 160 + r.*sin(a), ...
        'FaceColor', c + e*(s.botCol - c));
    n = s.tierNP(s.fx);
    set(g.part, 'XData', 400 + s.pv(1:n, 1) * s.fxt, ...
        'YData', 160 + s.pv(1:n, 2) * s.fxt - 360*s.fxt^2);
    sp(g.part, 'MarkerFaceColor', c);
    % Text starts big then snaps to size; PERFECT shakes it
    sh = (s.fx == 1 && e < 0.3) * 12 * sin([97 131] * s.fxt);
    sp(g.pop, 'String', s.tierName(s.fx));
    sp(g.pop, 'Color', c);
    sp(g.pop, 'FontSize', 36 + 16*(e < 0.15));
    g.pop.Position = [400 + sh(1), 300 + 20*e + sh(2)];
    sp(g.popSub, 'String', "+" + (4 - s.fx) + " " + repmat(char(9733), 1, 4 - s.fx));
    sp(g.popSub, 'Color', c);
    if e < 0.12
        bgc = 0.5*c;
    end
end
sp(g.bg, 'FaceColor', bgc);

% Message box: gold on slate (miss, game over; on the empty left side
% during the demo)
sp(g.msg, 'Visible', s.demo || s.phase == 3 || miss);
sp(g.msg, 'Position', [400 - 240*s.demo, 300, 0]);
sp(g.msg, 'String', cellstr(s.msg));
end

function sp(h, p, v)
% Set a graphics property only if its value changed.
if ~isequal(h.(p), v)
    h.(p) = v;
end
end

function h = makeIcon(ax, kind, cx, cy, sz, P)
% Draw a rock, paper or scissors icon as a hidden hggroup.
h = hggroup(ax, 'Visible', 'off', P{:});
dk = [0.1 0.1 0.12];
Q = [{'Parent', h}, P];
pa = @(x, y, c, w) patch(cx + sz*x, cy + sz*y, c, 'EdgeColor', dk, 'LineWidth', w, Q{:});
ln = @(x, y, c, w) line(cx + sz*x, cy + sz*y, 'Color', c, 'LineWidth', w, Q{:});
switch kind
    case 1 % Rock: lumpy polygon with two cracks
        a = (0:8) * 2*pi/9;
        r = [1 0.9 1.05 0.85 1 0.95 0.8 1 0.9];
        pa(r.*cos(a), 0.8*r.*sin(a), [0.55 0.55 0.6], 2);
        ln([-0.4 -0.1 0.1 NaN 0.3 0.5], [0.3 0.05 0.2 NaN -0.2 -0.45], dk, 1.5);
    case 2 % Paper: sheet with a folded corner and ruled lines
        pa([-0.75 0.4 0.75 0.75 -0.75], [0.95 0.95 0.6 -0.95 -0.95], [0.97 0.97 0.95], 2);
        pa([0.4 0.4 0.75], [0.95 0.6 0.6], [0.8 0.8 0.78], 1.5);
        for y = linspace(0.45, -0.65, 5)
            ln([-0.55 0.5], [y y], [0.55 0.65 0.85], 1.5);
        end
    case 3 % Scissors: two crossed blades, red finger rings, pivot
        pa([-0.43 -0.27 0.55], [-0.4 -0.5 1], [0.82 0.84 0.88], 1.5);
        pa([0.43 0.27 -0.55], [-0.4 -0.5 1], [0.82 0.84 0.88], 1.5);
        th = linspace(0, 2*pi, 40);
        ln([-0.45 0.45] + 0.28*cos(th'), -0.75 + 0.28*sin(th') + [0 0], [0.85 0.2 0.2], 5);
        line(cx, cy + 0.11*sz, 'Marker', 'o', 'MarkerSize', 7, ...
            'MarkerFaceColor', dk, 'MarkerEdgeColor', dk, Q{:});
end
end
Play Game
Preview

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