Knight's Move

Marco
/
Knight's Move
on 3 Nov 2026
3
22
9
0
9917
game.m
function g = game()
%game Knight's Move - one knight, endless pawns.
%
%   You are a chess knight. Click any highlighted square to move there.
%   Landing on a pawn captures it (+1). After every move each pawn steps one
%   square toward you (diagonals too). If a pawn reaches you, it's over.
%   New pawns keep spawning, but only a few are ever on the board at once.
%
%   Set CLICK_MODE = false in initState for the pure one-button version: a
%   cursor sweeps your legal moves and a press (SPACE / click) locks one in.
%
%   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 state = initState(ax)
% Called once. Creates every graphics object (pooled and toggled with
% Visible later) and builds the initial game state.

    state = struct();
    N = 8;  cs = 70;  x0 = 200;  y0 = 20;        % board geometry (world units)
    state.N = N;  state.cs = cs;  state.x0 = x0;  state.y0 = y0;
    state.offsets = [ 1  2;  2  1;  2 -1;  1 -2; -1 -2; -2 -1; -2  1; -1  2];
    state.best = 0;

    % ---- difficulty knobs ----
    state.maxPawns   = 6;    % never more than this many pawns on the board
    state.spawnEvery = 4;    % a new pawn every this many moves (gets a bit faster)

    CLICK_MODE = true;       % true: click the square you want. false: sweeping cursor
    state.clickMode = CLICK_MODE;
    state.ax = ax;           % used to read where the mouse was clicked

    useUnicode = true;       % false -> plain letters
    if useUnicode
        knightChar = char(9822);  pawnChar = char(9823);
    else
        knightChar = 'N';  pawnChar = 'P';
    end

    ax.XLim = [0 800];  ax.YLim = [0 600];
    try, ax.YDir = 'normal'; catch, end
    try, ax.Color = [0.10 0.10 0.12]; catch, end
    hold(ax,'on');
    np = {'HitTest','off','PickableParts','none'};   % never steal clicks

    % background + board
    rectangle(ax,'Position',[0 0 800 600],'FaceColor',[0.10 0.10 0.12], ...
              'EdgeColor','none',np{:});
    lightCol = [0.93 0.85 0.70];
    darkCol  = [0.55 0.38 0.25];
    for r = 1:N
        for c = 1:N
            if mod(r+c,2) == 0, col = darkCol; else, col = lightCol; end
            rectangle(ax,'Position',[x0+(c-1)*cs, y0+(r-1)*cs, cs, cs], ...
                      'FaceColor',col,'EdgeColor','none',np{:});
        end
    end
    rectangle(ax,'Position',[x0 y0 N*cs N*cs],'FaceColor','none', ...
              'EdgeColor',[0.8 0.8 0.8],'LineWidth',2,np{:});

    h = struct();

    % move highlights (a knight has at most 8 moves)
    h.hl = gobjects(1,8);
    for i = 1:8
        h.hl(i) = patch(ax,[0 1 1 0],[0 0 1 1],[0.2 0.8 0.3], ...
                        'FaceAlpha',0.5,'EdgeColor','none','Visible','off',np{:});
    end

    % knight
    h.knight = text(ax,0,0,knightChar,'FontSize',38,'Color',[0.10 0.25 0.95], ...
                    'HorizontalAlignment','center','VerticalAlignment','middle', ...
                    'Visible','off',np{:});

    % pawn pool (maxPawns on the board + the one that may catch you)
    h.enemy = gobjects(1,state.maxPawns + 2);
    for i = 1:numel(h.enemy)
        h.enemy(i) = text(ax,0,0,pawnChar,'FontSize',34,'Color',[0.80 0.10 0.10], ...
                          'HorizontalAlignment','center','VerticalAlignment','middle', ...
                          'Visible','off',np{:});
    end

    % danger marks + sweep cursor (on top of pieces)
    h.dx = gobjects(1,8);
    for i = 1:8
        h.dx(i) = text(ax,0,0,'x','FontSize',18,'FontWeight','bold','Color',[0.80 0 0], ...
                       'HorizontalAlignment','center','VerticalAlignment','middle', ...
                       'Visible','off',np{:});
    end
    h.cursor = rectangle(ax,'Position',[0 0 cs-4 cs-4],'EdgeColor',[1 0.9 0.1], ...
                         'LineWidth',4,'FaceColor','none','Visible','off',np{:});

    % HUD (left panel)
    h.title = text(ax,15,585,'KNIGHT SURVIVAL','FontSize',14,'FontWeight','bold', ...
                   'Color','w','HorizontalAlignment','left','VerticalAlignment','top',np{:});
    h.score = text(ax,15,540,'','FontSize',20,'FontWeight','bold','Color','w', ...
                   'HorizontalAlignment','left','VerticalAlignment','top',np{:});
    h.best  = text(ax,15,505,'','FontSize',13,'Color',[0.8 0.8 0.8], ...
                   'HorizontalAlignment','left','VerticalAlignment','top',np{:});
    h.pawns = text(ax,15,480,'','FontSize',13,'Color',[0.8 0.8 0.8], ...
                   'HorizontalAlignment','left','VerticalAlignment','top',np{:});

    h.over  = text(ax,x0+N*cs/2,y0+N*cs/2,'','FontSize',26,'FontWeight','bold', ...
                   'Color','w','BackgroundColor',[0 0 0],'EdgeColor','w','Margin',14, ...
                   'HorizontalAlignment','center','VerticalAlignment','middle', ...
                   'Visible','off',np{:});

    state.h = h;
    state = resetGame(state);
end

% =========================================================================
function state = updateState(state, dt, pressed)
% Advance the game by dt seconds.

    if ~state.alive
        state.deadT = state.deadT + dt;
        if pressed && state.deadT > 0.6          % small delay so you can see how you died
            state = resetGame(state);
        end
        return;
    end

    T = legalMoves(state);
    M = size(T,1);

    if state.clickMode
        % Instant mode: the clicked square is the move. No waiting on dt.
        if ~pressed, return; end
        rc = clickCell(state);
        if isempty(rc), return; end
        hit = find(T(:,1)==rc(1) & T(:,2)==rc(2), 1);
        if ~isempty(hit)
            state = doMove(state, T(hit,:));
        end
        return;
    end

    % One-button mode: a cursor sweeps around the moves, a press locks one in.
    state.cursorT = state.cursorT + dt;
    if pressed
        state = doMove(state, T(cursorIndex(state, M),:));
    end
end

% =========================================================================
function renderFrame(~, state)
% Push state onto the pre-built graphics objects. No objects are created here.

    h  = state.h;
    cs = state.cs;
    E  = state.enemies;
    nE = size(E,1);

    % ---- move highlights ----
    nT = 0;  T = zeros(0,2);  isCap = false(0,1);  cur = 0;
    if state.alive
        [T,isCap] = legalMoves(state);
        nT = size(T,1);
        if ~state.clickMode, cur = cursorIndex(state, nT); end
    end
    for i = 1:8
        if i <= nT
            [x,y] = cellXY(state, T(i,:));
            if isCap(i), col = [1.0 0.55 0.1]; else, col = [0.2 0.8 0.3]; end
            if state.clickMode, a = 0.55; elseif i == cur, a = 0.80; else, a = 0.40; end
            set(h.hl(i),'XData',x+[-0.5 0.5 0.5 -0.5]*cs, ...
                        'YData',y+[-0.5 -0.5 0.5 0.5]*cs, ...
                        'FaceColor',col,'FaceAlpha',a,'Visible','on');
            danger = false;
            if nE > 0
                others = E(~(E(:,1)==T(i,1) & E(:,2)==T(i,2)), :);
                danger = ~isempty(others) && any(max(abs(others - T(i,:)),[],2) <= 1);
            end
            if danger
                set(h.dx(i),'Position',[x+0.3*cs, y+0.3*cs],'Visible','on');
            else
                set(h.dx(i),'Visible','off');
            end
        else
            set(h.hl(i),'Visible','off');
            set(h.dx(i),'Visible','off');
        end
    end

    % sweep cursor (one-button mode only)
    if cur > 0
        [x,y] = cellXY(state, T(cur,:));
        set(h.cursor,'Position',[x-cs/2+2, y-cs/2+2, cs-4, cs-4],'Visible','on');
    else
        set(h.cursor,'Visible','off');
    end

    % knight
    [x,y] = cellXY(state, state.knight);
    set(h.knight,'Position',[x y],'Visible','on');

    % pawns
    for i = 1:numel(h.enemy)
        if i <= nE
            [x,y] = cellXY(state, E(i,:));
            set(h.enemy(i),'Position',[x y],'Visible','on');
        else
            set(h.enemy(i),'Visible','off');
        end
    end

    % HUD
    set(h.score,'String',sprintf('Score: %d', state.score));
    set(h.best, 'String',sprintf('Best: %d',  state.best));
    set(h.pawns,'String',sprintf('Pawns: %d', nE));
    if state.alive
        set(h.over,'Visible','off');
    else
        set(h.over,'String',{'GAME OVER', sprintf('Score %d   Best %d', state.score, state.best), ...
                             'Click to restart'},'Visible','on');
    end
end

% =========================================================================
%                              GAME LOGIC
% =========================================================================
function state = resetGame(state)
    state.knight  = [4 4];           % [row col], row 1 = bottom
    state.enemies = zeros(0,2);
    state.score   = 0;
    state.turn    = 0;
    state.alive   = true;
    state.cursorT = 0;
    state.deadT   = 0;
    state = spawnEnemy(state);       % start with just one pawn
end

function idx = cursorIndex(state, M)
% Which of the M legal moves the sweeping cursor is on (speeds up with score).
    period = max(0.18, 0.55 - 0.008*state.score);
    idx = mod(floor(state.cursorT / period), M) + 1;
end

function [x,y] = cellXY(state, rc)
    x = state.x0 + (rc(2) - 0.5) * state.cs;
    y = state.y0 + (rc(1) - 0.5) * state.cs;
end

function rc = clickCell(state)
% Board cell [row col] under the last mouse click, or [] if outside the board.
    rc = [];
    try
        p = state.ax.CurrentPoint;
    catch
        return;
    end
    c = floor((p(1,1) - state.x0) / state.cs) + 1;
    r = floor((p(1,2) - state.y0) / state.cs) + 1;
    if r >= 1 && r <= state.N && c >= 1 && c <= state.N
        rc = [r c];
    end
end

function [T, isCap] = legalMoves(state)
% Knight-move destinations (clockwise order) and whether each captures a pawn.
    T = state.knight + state.offsets;
    T = T(all(T >= 1 & T <= state.N, 2), :);
    E = state.enemies;
    isCap = false(size(T,1),1);
    for i = 1:size(T,1)
        isCap(i) = ~isempty(E) && any(E(:,1)==T(i,1) & E(:,2)==T(i,2));
    end
end

function state = doMove(state, dest)
% Move the knight (capturing any pawn there), then let the pawns respond.
    state.knight = dest;
    state.cursorT = 0;
    E = state.enemies;
    if ~isempty(E)
        hit = find(E(:,1)==dest(1) & E(:,2)==dest(2));
        if ~isempty(hit)
            state.enemies(hit,:) = [];
            state.score = state.score + 1;
            state.best = max(state.best, state.score);
        end
    end
    state.turn = state.turn + 1;
    state = enemyPhase(state);
end

function state = spawnEnemy(state)
    if size(state.enemies,1) >= state.maxPawns, return; end
    N = state.N;
    [R,C] = ndgrid(1:N,1:N);
    onEdge = (R==1) | (R==N) | (C==1) | (C==N);
    far = max(abs(R - state.knight(1)), abs(C - state.knight(2))) >= 3;
    occ = false(N);
    for i = 1:size(state.enemies,1)
        occ(state.enemies(i,1), state.enemies(i,2)) = true;
    end
    cand = find(onEdge & far & ~occ);
    if isempty(cand), return; end
    idx = cand(randi(numel(cand)));
    state.enemies(end+1,:) = [R(idx) C(idx)];
end

function state = enemyPhase(state)
    nE = size(state.enemies,1);
    if nE > 0
        dist = max(abs(state.enemies - state.knight), [], 2);
        [~,order] = sort(dist);                  % closest pawns move first
        for i = order'
            e  = state.enemies(i,:);
            ne = e + sign(state.knight - e);     % one step toward the knight
            if all(ne == state.knight)
                state.alive = false;             % a pawn caught the knight
                state.deadT = 0;
                state.enemies(i,:) = ne;
                return;
            end
            if ~any(state.enemies(:,1)==ne(1) & state.enemies(:,2)==ne(2))
                state.enemies(i,:) = ne;
            end
        end
    end
    % a new pawn every few moves (slightly faster as the score grows)
    interval = max(2, state.spawnEvery - floor(state.score/15));
    if mod(state.turn, interval) == 0
        state = spawnEnemy(state);
    end
end
Play Game
Preview

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