Each cell below represents ~25 lines of estwhi.pas, top‑left first. Colours group by concern. The takeaway: the AI tables and drawing code dwarf everything else, and the bidder dialog spends its last 240 lines repeating itself sixteen times.

{Array.from({ length: TOTAL }).map((_, i) => { const r = cellRegion(i); const startLine = i * linesPerCell + 1; return (

setHover({ line: startLine, label: r[2] })} onMouseLeave={() => setHover(null)} /> ); })}

{SRC_REGIONS.map((r, i) => (

L{r[0]}–{r[1]} {r[2]}

))}

Live:{" "} {hover ? ( <>around line {hover.line} — {hover.label}. ) : ( <>Hover the heatmap to see what's at any line. )}

); } /* ===================================================================== Card encoding (interactive) ===================================================================== */ const SUITS = ["♣", "♦", "♠", "♥"]; const SUIT_NAMES = ["Clubs", "Diamonds", "Spades", "Hearts"]; const SUIT_COLORS = ["black", "red", "black", "red"]; const RANK_LABEL = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]; function decodeCard(n) { // Per source: 1..13 = Clubs A..K, 14..26 = Diamonds, 27..39 = Spades, // 40..52 = Hearts. And "Ace is high" via a sentinel of 60 in DecideWinner. if (n < 1 || n > 52) return null; const suitIdx = Math.floor((n - 1) / 13); // 0..3 const rankIdx = (n - 1) % 13; // 0..12 (Ace=0) return { n, suit: SUITS[suitIdx], suitName: SUIT_NAMES[suitIdx], rank: RANK_LABEL[rankIdx], color: SUIT_COLORS[suitIdx], isAce: rankIdx === 0, suitIdx, rankIdx, }; } function CardEncoder() { const [n, setN] = useState(40); // 40 = Ace of Hearts const c = decodeCard(n); return (

Interactive: how the deck is stored

One integer per card, suit = (n−1) div 13.

The deck is just a 1‑indexed array of integers from 1 to 52. There's no Suit type and no Rank type — both are decoded on the fly. The Ace lives at the bottom of each suit's range, and the program patches it up to "high" when deciding who won a trick by replacing its sort value with a sentinel of 60.

Cards[i] = setN(parseInt(e.target.value))} /> {n}

n = {n}

(n − 1) div 13 = {c.suitIdx} → {c.suitName}

(n − 1) mod 13 = {c.rankIdx} → {c.rank} {c.isAce && (ace‑high)}

DetermineSuit returns {c.suitIdx + 1}; trump match uses Trump * 13 windows.

{c.rank}

{c.suit}

{c.rank}

The whole pack

Each square is one integer 1..52. Click to select.

{Array.from({ length: 52 }).map((_, i) => { const cc = decodeCard(i + 1); return (

setN(i + 1)} > {cc.rank}{cc.suit}

); })}

); } /* ===================================================================== AI table + hand builder (interactive) ===================================================================== */ // CallValueOne (used for hands of 2..5 cards) const CALL_ONE_NORMAL = [1.0, 0, 0, 0, 0, 0, 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.8]; const CALL_ONE_TRUMP = [1.0, 0.1, 0.2, 0.2, 0.3, 0.3, 0.3, 0.4, 0.7, 0.9, 1.0, 1.0, 1.0]; // CallValueTwo (used for hands of 6+ cards) const CALL_TWO_NORMAL = [1.0, 0, 0, 0, 0, 0, 0.1, 0.1, 0.1, 0.1, 0.1, 0.4, 1.0]; const CALL_TWO_TRUMP = [1.0, 0.1, 0.1, 0.1, 0.1, 0.2, 0.2, 0.3, 0.3, 0.4, 0.5, 0.9, 1.0]; function CallTable({ normal, trump, highlightSet }) { return (

{RANK_LABEL.map((r, i) => )} {normal.map((v, i) => ( ))} {trump.map((v, i) => ( ))}

	{r}
non‑trump	{v.toFixed(1)}
trump	{v.toFixed(1)}

); } function BidAI() { // hand = array of card numbers 1..52, length 1..15 const [hand, setHand] = useState([1, 13, 27, 40, 52]); // A♣ K♣ A♠ A♥ K♥ const [trumpSuit, setTrumpSuit] = useState(0); // 0=clubs..3=hearts const isTrump = (cardN) => Math.floor((cardN - 1) / 13) === trumpSuit; const rankOf = (cardN) => (cardN - 1) % 13; // Pick which lookup table is active const activeTable = hand.length >= 6 ? "two" : "one"; const normal = activeTable === "two" ? CALL_TWO_NORMAL : CALL_ONE_NORMAL; const trump = activeTable === "two" ? CALL_TWO_TRUMP : CALL_ONE_TRUMP; // Highlight the cells that the current hand pulls from const highlightSet = useMemo(() => { const n = new Set(); const t = new Set(); if (hand.length >= 2) { hand.forEach(c => { const r = rankOf(c); if (isTrump(c)) t.add(r); else n.add(r); }); } return { normal: n, trump: t }; }, [hand, trumpSuit]); // Compute the call as in AutoCallTwo let call; let breakdown = []; if (hand.length === 1) { const c = hand[0]; const isAceOfTrump = rankOf(c) === 0 && isTrump(c); if (isAceOfTrump) { call = 1; breakdown.push(["Ace of trump → guaranteed trick", 1]); } else if (isTrump(c) && rankOf(c) >= 5) { call = 1; breakdown.push(["Trump higher than 5 → hopeful", 1]); } else { call = 0; breakdown.push(["No trump-Ace, no high trump → bid 0", 0]); } } else { let total = 0; hand.forEach(c => { const r = rankOf(c); const v = isTrump(c) ? trump[r] : normal[r]; total += v; breakdown.push([`${RANK_LABEL[r]}${SUITS[Math.floor((c-1)/13)]} ${isTrump(c) ? "(trump)" : ""}`, v]); }); call = Math.trunc(total + 0.5); } // Build a deck of 52 buttons grouped by suit const deck = Array.from({ length: 52 }, (_, i) => i + 1); const toggleCard = (cardN) => { if (hand.includes(cardN)) { setHand(hand.filter(c => c !== cardN)); } else if (hand.length < 15) { setHand([...hand, cardN].sort((a, b) => a - b)); } }; return (

Interactive: AutoCallTwo

An AI made of two tiny lookup tables and a sum.

Each card has a "trick value" — a real number between 0 and 1 — depending on its rank and whether it's a trump. The bot sums those values across your hand, rounds half up, and that's its bid. There are two tables: one for small hands (2–5 cards), one for big hands (6+). The 1‑card case is a hand-written special case.

Your hand

Click cards to add or remove. Pick a trump suit. Max 15.

Trump: {SUITS.map((s, i) => ( ))}

{SUIT_NAMES.map((sn, si) => (

{sn} {si === trumpSuit && (trump)}

{RANK_LABEL.map((r, ri) => { const cardN = si * 13 + ri + 1; const inHand = hand.includes(cardN); return (

toggleCard(cardN)} style={{ fontSize: 10 }} > {r}{SUITS[si]}

); })}

))}

The lookup table in play

{hand.length} {hand.length === 1 ? "card" : "cards"} in hand →{" "} {hand.length === 1 ? (<>special‑case 1‑card branch) : hand.length < 6 ? (<>CallValueOne (2–5 cards)) : (<>CallValueTwo (6+ cards))}

What the AI would bid: {call}

{breakdown.map(([lbl, v], i) => (

{lbl} + {Number(v).toFixed(1)}

))} {hand.length > 1 && ( <>

TRUNC(sum + 0.5) = {call}

)}

Caveat from the source: the "last player" rule patches the result so the bids never sum exactly to the dealt cards — same house rule used at real Whist tables. There's also an older AutoCall routine (different algorithm, pattern-matched on suit holdings) that isn't called from anywhere. Dead code, kept as a reference.

); } /* ===================================================================== Random things (drunkard's walk) ===================================================================== */ const SUIT_SVGS = { club: ( ), diamond: ( ), heart: ( ), spade: ( ), md: (

), ic: (

♥♣
♦♠

), }; const THING_KEYS = ["club", "diamond", "heart", "spade", "md", "ic"]; function RandomThings() { const [count, setCount] = useState(6); const [mult, setMult] = useState(6); const [interval, setInterval] = useState(120); const [running, setRunning] = useState(true); const feltRef = useRef(null); const [FELT_W, setFeltW] = useState(760); // measured felt width; CSS scales const FELT_H = 360; const THING = 31; useEffect(() => { const el = feltRef.current; if (!el) return; const apply = w => { if (w > 0) setFeltW(w); }; apply(el.clientWidth); if (typeof ResizeObserver === "undefined") return; const ro = new ResizeObserver(entries => { for (const e of entries) apply(e.contentRect.width); }); ro.observe(el); return () => ro.disconnect(); }, []); const [positions, setPositions] = useState(() => Array.from({ length: 6 }, () => ({ x: Math.random() * (FELT_W - THING), y: Math.random() * (FELT_H - THING), })) ); useEffect(() => { if (!running) return; const id = window.setInterval(() => { setPositions(prev => prev.map(p => { let nx = p.x + mult * (Math.floor(Math.random() * 3) - 1); let ny = p.y + mult * (Math.floor(Math.random() * 3) - 1); if (nx < 0) nx += mult; if (nx > FELT_W - THING) nx -= mult; if (ny < 0) ny += mult; if (ny > FELT_H - THING) ny -= mult; // Don't eat the logo const lcx = FELT_W / 2 - 31, lcy = FELT_H / 2 - 31; if (nx > lcx - THING && nx < lcx + 62 && ny > lcy - THING && ny < lcy + 62) { if (nx < FELT_W / 2) nx = lcx - THING; else nx = lcx + 62; } return { x: nx, y: ny }; })); }, interval); return () => window.clearInterval(id); }, [running, mult, interval, FELT_W]); return (

Interactive recreation

1–6 little bitmaps that wander while you idle.

When you're not in a game, the main window fires a timer every 20–1000ms. On each tick, every "thing" steps a random multiple in x and in y (−1, 0, or +1 times a multiplier). Edge cases nudge them away from the buttons and the centre logo so they don't get eaten. It's delightful, it has nothing to do with playing cards, and it is the biggest single dialog in the options menu.

ESTWHI

{positions.slice(0, count).map((p, i) => (

{SUIT_SVGS[THING_KEYS[i]]}

))}

Random Things

Multiplier setMult(parseInt(e.target.value))} className="slider" /> {mult}

Number of setCount(parseInt(e.target.value))} className="slider" /> {count}

Time interval setInterval(parseInt(e.target.value))} className="slider" /> {interval}ms

// from estwhi.pas

XPos[A] := XPos[A] +

Multiplier*(INTEGER(RANDOM(3)) - 1);

); } /* ===================================================================== Trump cycle + rounds ===================================================================== */ function RoundsAndTrumps() { const [round, setRound] = useState(7); // 1..25 const maxCards = 13; const numRounds = 2 * maxCards - 1; // 25 const cardsDealt = round <= maxCards ? round : 2 * maxCards - round; const trumpIdx = ((round - 1) % 4); // 0..3 // Per source order: 1=clubs, 2=diamonds, 3=spades, 4=hearts const SUIT_ORDER = [0, 1, 2, 3]; // index into our SUITS arr const activeSuit = SUIT_ORDER[trumpIdx]; return (

Interactive

The trump suit cycles. The cards-per-hand pyramids.

With MaxCards = 13, you play 25 rounds. Round N deals min(N, 25−N+1) cards to each player. The trump suit advances every round through clubs → diamonds → spades → hearts → clubs, regardless of who's playing or what was dealt. Click a round below to see it.

{SUITS.map((s, i) => (

{s}

{i < 3 &&

→

} ))}

(loops)

Round selector

{Array.from({ length: numRounds }).map((_, i) => { const r = i + 1; const cards = r <= maxCards ? r : 2 * maxCards - r; const isHere = r === round; const isPassed = r < round; return (

setRound(r)} title={`Round ${r}: ${cards} cards`} > {cards}

); })}

Cell value = cards dealt to each player. Cell index = round number.

Round {round} of {numRounds}

cards per player {cardsDealt}

trump suit {SUITS[activeSuit]}

direction {round <= maxCards ? "ascending" : "descending"}

round-start player (round − 1) mod N + 1

Maximum possible per game = 15. That's why the bid dialog has buttons 0..15 and the program declares sixteen CallButN methods, sixteen ID_CALLxxx constants, and a sixteen-way CASE to grey out invalid options.

); } /* ===================================================================== Scoring (interactive) ===================================================================== */ function ScoreChart({ mode, call }) { // bars showing score for outcomes 0..15 with given call & mode const N = 16; const data = Array.from({ length: N }, (_, tricks) => { if (mode === "vanilla") { return tricks === call ? tricks + 10 : tricks; } else { return tricks === call ? tricks * tricks + 10 : tricks; } }); const max = Math.max(...data, 1); return (

{data.map((v, i) => (

{i}

))}

x: tricks taken · gold = matches your call of {call}

); } function Scoring() { const [call, setCall] = useState(3); return (

Interactive

Two modes. Same shape, very different incentives.

In vanilla mode, you always score one point per trick taken, plus a flat 10‑point bonus if your tricks exactly equal your call. In squared mode, hitting your call earns tricks² + 10 — overshooting it wipes out almost all the value. Squared mode rewards accurate, ambitious bidding; vanilla mode is gentler.

Your call setCall(parseInt(e.target.value))} className="slider" /> {call}

Vanilla

score += tricks; if tricks = call: score += 10

Squared

if tricks = call: score += tricks² + 10; else score += tricks

Hard scoring (an option). If total bids around the table are less than the dealt cards and you bid zero, you forfeit the 10‑point bonus — punishing the "everyone undershoots" loophole. The author commented out the (n) indicator that was supposed to display this state on the scoreboard; the comment is still in the source.

); } /* ===================================================================== Build / tooling ===================================================================== */ function BuildAndTools() { return (

Tooling

A pure 1990s Borland toolchain.

Compiler: Borland Turbo Pascal for Windows v1.5 ("TP4W v1.5" in the source header). Compiles 16-bit Pascal to a Windows 3.x .EXE.
Framework: ObjectWindows Library 1.x — Borland's Pascal answer to MFC. Provides TApplication, TWindow, TDialog, PButton, PStatic, PScrollBar, etc.
3D look: Microsoft's CTL3D.DLL. The main program registers it on entry and unregisters on exit, so dialogs get the chiselled-bezel look that became the Win 3.1 aesthetic.
Resources: A separate RESOURCE.BAT shells out to Borland's rc compiler, producing ESTWHI.RES (icons, bitmaps, menus, dialog templates) which Pascal links in via LoadBitmap(HInstance, PChar(N)).
Help: Windows Help 3.1 (WinHelp API). The .HPJ project compiles ESTWHI.RTF + segmented hypergraphics (.SHG files) into ESTWHI.HLP.
Persistence: GetPrivateProfileInt / WritePrivateProfileString against ESTWHI.INI. No registry.

Files in the project

{`estwhi/
├── estwhi.pas      3,952 lines, all source
├── ABOUT.RC          17 lines, dialog template
├── RESOURCE.BAT       1 line, invokes 'rc'
├── ESTWHI.RES                 compiled resources
├── ESTWHI.EXE                 Win16 binary
├── RELEASE/
│   └── ESTWHI.ZIP             shipping archive
└── HELP/
    ├── ESTWHI.HPJ             help project
    ├── ESTWHI.RTF    611 lines, help source
    ├── estwhi.PH              keyword index
    ├── *.BMP, *.SHG           illustrations
    └── BMP.ZIP                image archive`}

{`(* Custom controls *)`}{"\n"}
Ctl3dRegister(HInstance);{"\n"}
Ctl3dAutoSubclass(HInstance);{"\n"}
{"\n"}
CardApp.Init('ESTWHI');{"\n"}
CardApp.Run;{"\n"}
CardApp.Done;{"\n"}
{"\n"}
Ctl3dUnRegister(HInstance);

); } /* ===================================================================== Timeline ===================================================================== */ function Timeline() { const events = [ { year: "1993", ver: "DOS draft", body: "Author writes a character-based DOS version first. According to the help file, this is the seed of everything that follows.", }, { year: "1994", ver: "v1.0 · 20 May", body: "First Windows release. Rewritten in Turbo Pascal for Windows with OWL. CTL3D.DLL is added at the last moment to give dialogs their 3D look, and a status bar gets bolted on.", }, { year: "2002", ver: "v1.1 · 20 Jul", body: 'Eight years pass. "Even longer in development than the previous version." The changes are cosmetic — pulling colour values from Windows via GetSysColor instead of hard-coded RGB.', }, { year: "2002", ver: "v1.2 · 1 Aug", body: 'Twelve days later, v1.2. The status bar string and the about box go from "Copyright 1994" to "1994-2002." Other than that, the source diff is small.', }, ]; return (

Timeline

Nine years between draft and final version. Two of them in 2002.

{events.map((e, i) => (

{e.year}

{e.ver}

{e.body}

))}

From the help file: "Future development might result in a v1.2 with a more intelligent playing algorithm. Time will tell. Perhaps in another eight years ;-)" — written in v1.1. The smarter play algorithm never arrived; v1.2 shipped two weeks later as a cosmetic update, and PlayCard still picks legal moves uniformly at random.

); } /* ===================================================================== Good / Bad / Curious ===================================================================== */ function GoodBadCurious() { return (

What holds up

♣ Good

Genuinely complete. Persistence, help file, options, high scores, cheat mode, idle animation, status-bar tooltips. Nothing is half there.
Comments worth reading. The author explains why there are two paint loops, why the random walk has guard rails, what each AI table flag means.
Heuristic AI with documented tunables. The two lookup tables are commented rank-by-rank. Adjusting bot strength is a one-line edit, not an algorithm change.
Idiomatic OWL. Proper GetDC/ReleaseDC bracketing, virtual destructors free brushes and bitmaps, child windows are owned by parents — clean Win16 manners.
Friendly UX. Hover any menu item and the status bar describes it. Hover any region of the help-file screenshot and you get a context popup.

What doesn't

♠ Could be better

One file, 3,952 lines. No unit boundaries between game logic, AI, drawing, persistence, and dialogs. Everything reaches into a sea of globals.
16 identical button handlers. CallZer through CallFif each set one integer and close. A 5‑line for‑loop would suffice.
Dumb-play AI. PlayCard picks a uniformly-random legal card. The bidding is heuristic; the actual play is a coin flip.
Shuffle is 1000 random swaps instead of one Fisher–Yates pass. Statistically fine, but the giveaway of someone who learned by intuition.
Selection sort on the hand. With at most 15 cards it doesn't matter — but it stands out next to all the careful Win16 code.
Dead code. AutoCall (a whole pattern‑matched bidder) is defined and never called. BackPic[1..12] is declared and freed but never loaded. BackNo is declared and never used.
Probability window paints a 52×N matrix that is never updated past its initial value of (100 * NoCards) DIV 52.

Easter eggs & quirks

♥ Curious

The leftover title. ABOUT.RC still says CAPTION "About Nonogram Solver" — copy-pasted from the author's previous app and never updated. The runtime overrides it before display, so users never saw.
The cheat class is called TChetBox. Pascal identifier limits, plus an unfortunate elision.
Self-talk in comments: "Note to my myself - there is a reason for having two loops which are essentially the same…Thanks."
Trump cycle is C → D → S → H — not alphabetical, not the bridge order. The order is hard-coded by a CASE in DrawInformation.
OutputDebugString in production. DebugEnabled := TRUE on startup, and a wrapper called ODS fires "Estimation Whist initialised" into the system debugger every launch.
Help acknowledgements: the testers section credits "Father and Ross." That's the entire team.
The cosmetic v1.2 fix: the about box still says "Copyright (C) M G Davidson 1994" hard-coded in the .RC, but the live version label says 1994–2002. The dialog code overrides the static text on setup.

); } /* ===================================================================== Closing — a peek at the actual Pascal ===================================================================== */ function TheCallHandler() { const code = `PROCEDURE TCallWin.CallZer (VAR Msg: TMessage); BEGIN (* Player has called zero tricks *) PlayCall[1] := 0; TDialog.OK(Msg); END; PROCEDURE TCallWin.CallOne (VAR Msg: TMessage); BEGIN (* Player has called one trick *) PlayCall[1] := 1; TDialog.OK(Msg); END; PROCEDURE TCallWin.CallTwo (VAR Msg: TMessage); BEGIN (* Player has called two tricks *) PlayCall[1] := 2; TDialog.OK(Msg); END; (* ... and thirteen more, all the same shape, ending at CallFif which writes 15. *)`; return (

Source — verbatim

Sixteen procedures for one integer assignment each.

This is the bidder dialog's entire action surface. Each of the sixteen call buttons gets a dedicated handler that writes the chosen value into PlayCall[1] (human player is always player 1) and closes the dialog. The whole thing could be one method that reads the button ID from the message — but the framework binds methods to message IDs statically via the virtual ID_FIRST + ID_CALLxxx; dispatch syntax, and writing the macro out by hand is the cheaper local fix than building a generic.

{code}

); } /* ===================================================================== Closing console ===================================================================== */ function Closing() { return (

In one sentence

A complete, lived-in, single-file Pascal card game with a real heuristic bidder, a play algorithm that's a coin flip, and decorative suit bitmaps that bounce around the felt while it waits for you to start a new round.

The shape of it tells you a lot about the era: heavy OWL boilerplate, CTL3D for the look, RTF + WinHelp for documentation, .INI files for state, all driven by raw Win16 messages. Today you'd build the same thing in a weekend with web components; in 1994 it was nine years of work in spare time, and it shows in the affection of the comments more than in the code shape.

If you want to keep digging

estwhi.pas — the whole program. Start at L555 (globals) and L1750 (the AI).
HELP/ESTWHI.RTF — the help file in source form. Reads as a friendly manual.
ABOUT.RC — 17 lines and the wrong title.
The author's older game, Stop the Bus, is mentioned in the help history as the predecessor.

C:\TPW\BIN\> tpc estwhi.pas /win

Turbo Pascal for Windows Version 1.5

estwhi.pas(3952): 3952 lines, 0 errors.

C:\TPW\BIN\> _

); } /* ===================================================================== App ===================================================================== */ function App() { return (

); } const root = ReactDOM.createRoot(document.getElementById("root")); root.render();

PASCAL · WIN16 · 1994
Estimation Whist,
by M. G. Davidson.

Bid your tricks, then take exactly that many.

It's OOP — barely. One giant TWindow holds the game.

{node.name}

One file, six concerns, sixteen identical button handlers.

One integer per card, suit = (n−1) div 13.

An AI made of two tiny lookup tables and a sum.

What the AI would bid: {call}

1–6 little bitmaps that wander while you idle.

The trump suit cycles. The cards-per-hand pyramids.

Round {round} of {numRounds}

Two modes. Same shape, very different incentives.

Vanilla

Squared

A pure 1990s Borland toolchain.

Nine years between draft and final version. Two of them in 2002.

♣ Good

♠ Could be better

♥ Curious

Sixteen procedures for one integer assignment each.

A complete, lived-in, single-file Pascal card game with a real heuristic bidder, a play algorithm that's a coin flip, and decorative suit bitmaps that bounce around the felt while it waits for you to start a new round.

PASCAL · WIN16 · 1994 Estimation Whist, by M. G. Davidson.

Bid your tricks, then take exactly that many.

It's OOP — barely. One giant TWindow holds the game.

{node.name}

One file, six concerns, sixteen identical button handlers.

One integer per card, suit = (n−1) div 13.

An AI made of two tiny lookup tables and a sum.

What the AI would bid: {call}

1–6 little bitmaps that wander while you idle.

The trump suit cycles. The cards-per-hand pyramids.

Round {round} of {numRounds}

Two modes. Same shape, very different incentives.

Vanilla

Squared

A pure 1990s Borland toolchain.

Nine years between draft and final version. Two of them in 2002.

♣ Good

♠ Could be better

♥ Curious

Sixteen procedures for one integer assignment each.

A complete, lived-in, single-file Pascal card game with a real heuristic bidder, a play algorithm that's a coin flip, and decorative suit bitmaps that bounce around the felt while it waits for you to start a new round.

PASCAL · WIN16 · 1994
Estimation Whist,
by M. G. Davidson.