---

Basics of Nim

Bagels

#[
Bagels

Original version in BASIC:
  D. Resek, P. Rowe, 1978.
  Creative Computing (Morristown, New Jersey, USA), 1978.

This version in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written in 2025-01-19/20.

Last modified: 20250124T0133+0100.
]#

import std/random
import std/sequtils
import std/strformat
import std/strutils
import std/terminal
import std/unicode

proc cursorHome() =
  setCursorPos(0, 0)

proc clearScreen() =
  eraseScreen()
  cursorHome()

# Clear the screen, display the credits and wait for a keypress.
#
proc printCredits() =

  clearScreen()
  writeLine(stdout, "Bagels")
  writeLine(stdout, "Number guessing game\n")
  writeLine(stdout, "Original source unknown but suspected to be:")
  writeLine(stdout, "    Lawrence Hall of Science, U.C. Berkely.\n")
  writeLine(stdout, "Original version in BASIC:")
  writeLine(stdout, "    D. Resek, P. Rowe, 1978.")
  writeLine(stdout, "    Creative computing (Morristown, New Jersey, USA), 1978.\n")
  writeLine(stdout, "This version in Nim:")
  writeLine(stdout, "    Copyright (c) 2025, Marcos Cruz (programandala.net)")
  writeLine(stdout, "    SPDX-License-Identifier: Fair\n")
  write(stdout, "Press Enter to read the instructions. ")
  discard readLine(stdin)

# Clear the screen, print the instructions and wait for a keypress.
#
proc printInstructions() =

  clearScreen()
  writeLine(stdout, "Bagels")
  writeLine(stdout, "Number guessing game\n")
  writeLine(stdout, "I am thinking of a three-digit number that has no two digits the same.")
  writeLine(stdout, "Try to guess it and I will give you clues as follows:\n")
  writeLine(stdout, "   PICO   - one digit correct but in the wrong position")
  writeLine(stdout, "   FERMI  - one digit correct and in the right position")
  writeLine(stdout, "   BAGELS - no digits correct")
  write(stdout, "\nPress Enter to start. ")
  discard readLine(stdin)

const digits = 3

# Return a sequence containing as many random digits as the value of the
# `digits` constant.
#
proc random(): seq[int]  =
  while len(result) < digits:
    var digit = rand(9)
    if digit notin result:
      add(result, digit)

# Print the given prompt and update the array whose address is given with a
# three-digit number from the user.
#
proc getInput(prompt: string, userDigit: var array[digits, int]) =

  var ok = false
  while not ok:
    write(stdout, prompt)
    var input = readLine(stdin)
    if len(input) != digits:
      writeLine(stdout, "Remember it's a ", digits, "-digit number.")
      continue
    ok = true
    for pos, charDigit in input:
      if isDigit(charDigit):
        var stringDigit = newStringOfCap(1)
        add(stringDigit, charDigit)
        userDigit[pos] = parseInt(stringDigit)
      else:
        ok = false
        writeLine(stdout, "What?")
        break
    if ok and len(deduplicate(userDigit)) < digits:
      writeLine(stdout, "Remember my number has no two digits the same.")
      ok = false

# Return `true` if the given string is "yes" or a synonym.
#
proc isYes(s: string): bool  =

  return toLower(s) in ["ok", "y", "yeah", "yes"]

# Return `true` if the given string is "no" or a synonym.
#
proc isNo(s: string): bool  =

  return toLower(s) in ["n", "no", "nope"]

# Print the given prompt, wait until the user enters a valid yes/no string,
# and return `true` for "yes" or `false` for "no".
#
proc yes(prompt: string): bool  =

  while true:
    write(stdout, prompt)
    var answer = readLine(stdin)
    if isYes(answer):
      return true
    if isNo(answer):
      return false

# Init and run the game loop.
#
proc play() =

  const tries = 20
  var score = 0
  var fermi: int # counter
  var pico: int # counter
  var userNumber: array[digits, int]
  while true:
    clearScreen()
    var computerNumber = random()
    writeLine(stdout, "O.K.  I have a number in mind.")
    for guess in 1 .. tries:
      # writeLine(stdout, "My number: ", computerNumber) # XXX TMP
      getInput(fmt"Guess #{guess:00}: ", userNumber)
      fermi = 0
      pico = 0
      for i in 0 ..< digits:
        for j in 0 ..< digits:
          if userNumber[i] == computerNumber[j]:
            if i == j:
              fermi += 1
            else:
              pico += 1

      write(stdout, repeat("PICO ", pico))
      write(stdout, repeat("FERMI ", fermi))
      if pico + fermi == 0:
        write(stdout, "BAGELS")
      writeLine(stdout, "")
      if fermi == digits:
        break
    if fermi == digits:
      writeLine(stdout, "You got it!!!")
      score += 1
    else:
      writeLine(stdout, "Oh well.")
      write(stdout, "That's ", tries, " guesses.  My number was ")
      for i in 0 ..< digits:
        write(stdout, computerNumber[i])
      writeLine(stdout, ".")
    if not yes("Play again? "):
      break
  if score != 0:
    writeLine(stdout, "A ", score, "-point bagels, buff!!")
  writeLine(stdout, "Hope you had fun.  Bye.")

printCredits()
printInstructions()
play()

• Todas las versiones de Bagels

Bug

#[
Bug

Original version in BASIC:
  Brian Leibowitz, 1978.
  Creative Computing (Morristown, New Jersey, USA), 1978.

This version in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2025-01-20.

Last modified: 20250405T0304+0200.
]#

import std/random
import std/strformat
import std/strutils
import std/terminal
import std/unicode

type Bug = tuple [
  body: bool,
  neck: bool,
  head: bool,
  feelers: int,
  feelerType: char,
  tail: bool,
  legs: int ]

type Player = tuple [
  pronoun: string,
  possessive: string,
  bug: Bug ]

var computer: Player
var human: Player

const bugParts = 6

type Part = enum
    body = 1, neck, head, feeler, tail, leg

# Bug body attributes.
#
const bodyHeight = 2
const feelerLength = 4
const legLength = 2
const maxFeelers = 2
const maxLegs = 6
const neckLength = 2

proc cursorHome() =
  setCursorPos(0, 0)

proc clearScreen() =
  eraseScreen()
  cursorHome()

# Move the cursor to the previous row, without changing the column position,
# and erase its line.
#
proc erasePreviousLine() =
  cursorUp()
  eraseLine()

# Clear the screen, display the credits and wait for a keypress.
#
proc printCredits() =
  clearScreen()
  writeLine(stdout, "Bug\n")
  writeLine(stdout, "Original version in BASIC:")
  writeLine(stdout, "    Brian Leibowitz, 1978.")
  writeLine(stdout, "    Creative computing (Morristown, New Jersey, USA), 1978.\n")
  writeLine(stdout, "This version in Nim:")
  writeLine(stdout, "    Copyright (c) 2025, Marcos Cruz (programandala.net)")
  writeLine(stdout, "    SPDX-License-Identifier: Fair\n")
  write(stdout, "Press Enter to read the instructions. ")
  discard readLine(stdin)

const instructions = """
The object is to finish your bug before I finish mine. Each number
stands for a part of the bug body.

I will roll the die for you, tell you what I rolled for you, what the
number stands for, and if you can get the part. If you can get the
part I will give it to you. The same will happen on my turn.

If there is a change in either bug I will give you the option of
seeing the pictures of the bugs. The numbers stand for parts as
follows:
"""

# Print a table with the bug parts' description.
#
proc printPartsTable() =
  const columns = 3
  const columnWidth = 8
  const columnSeparation = 2
  var padding: string

  # Headers
  const header: array[3, string] = ["Number", "Part", "Quantity"]
  for i in 0 ..< columns:
    padding = repeat(" ", columnWidth + columnSeparation - len(header[i]))
    write(stdout, header[i], padding)
  writeLine(stdout, "")

  # Rulers
  const ruler = repeat("-", columnWidth)
  for i in 0 ..< columns:
    padding = if i == columns - 1: "" else: repeat(" ", columnSeparation)
    write(stdout, ruler, padding)
  writeLine(stdout, "")

  # Data
  var partQuantity: array[bugParts, int] = [1, 1, 1, 2, 1, 6]
  for part in Part:
    padding = repeat(" ", columnWidth + columnSeparation - len($int(part)))
    write(stdout, int(part), padding)
    padding = repeat(" ", columnWidth + columnSeparation - len($part))
    write(stdout, capitalize($part), padding)
    writeLine(stdout, partQuantity[int(part) - 1])

proc printInstructions() =
  clearScreen()
  writeLine(stdout, "Bug\n")
  writeLine(stdout, instructions)
  printPartsTable()
  write(stdout, "\nPress Enter to start. ")
  discard readLine(stdin)

proc printHead() =
  writeLine(stdout, "        HHHHHHH")
  writeLine(stdout, "        H     H")
  writeLine(stdout, "        H O O H")
  writeLine(stdout, "        H     H")
  writeLine(stdout, "        H  V  H")
  writeLine(stdout, "        HHHHHHH")

proc printBug(bug: Bug) =
  if bug.feelers > 0:
    for _ in 0 ..< feelerLength:
      write(stdout, "        ")
      for _ in 0 ..< bug.feelers:
        write(stdout, " ", bug.feelerType)
      writeLine(stdout, "")
  if bug.head:
    printHead()
  if bug.neck:
    for _ in 0 ..< neckLength:
      writeLine(stdout, "          N N")
  if bug.body:
    writeLine(stdout, "     BBBBBBBBBBBB")
    for _ in 0 ..< bodyHeight:
      writeLine(stdout, "     B          B")
    if bug.tail:
      writeLine(stdout, "TTTTTB          B")
    writeLine(stdout, "     BBBBBBBBBBBB")
  if bug.legs > 0:
    for _ in 0 ..< legLength:
      write(stdout, "    ")
      for _ in 0 ..< bug.legs:
        write(stdout, " L")
      writeLine(stdout, "")

proc finished(bug: Bug): bool  =
  return bug.feelers == maxFeelers and bug.tail and bug.legs == maxLegs

proc dice(): int  =
  return rand(1 .. 6)

const asText: array[maxLegs + 1, string] = [
  "no",
  "a",
  "two",
  "three",
  "four",
  "five",
  "six" ]

# Return a string containing the given number and noun in their proper form.
#
proc plural(number: int, noun: string): string  =
  let ending = if number > 1: "s" else: ""
  return fmt" {asText[number]} {noun}{ending}"

# Add the given part to the given player's bug.
#
proc addPart(part: var Part, player: var Player): bool  =
  var changed: bool = false
  case part:
  of Part.body:
    if player.bug.body:
      writeLine(stdout, ", but ", player.pronoun, " already have a body.")
    else:
      writeLine(stdout, "; ", player.pronoun, " now have a body:")
      player.bug.body = true
      changed = true
  of Part.neck:
    if player.bug.neck:
      writeLine(stdout, ", but ", player.pronoun, " already have a neck.")
    elif not player.bug.body:
      writeLine(stdout, ", but ", player.pronoun, " need a body first.")
    else:
      writeLine(stdout, "; ", player.pronoun, " now have a neck:")
      player.bug.neck = true
      changed = true
  of Part.head:
    if player.bug.head:
      writeLine(stdout, ", but ", player.pronoun, " already have a head.")
    elif not player.bug.neck:
      writeLine(stdout, ", but ", player.pronoun, " need a a neck first.")
    else:
      writeLine(stdout, "; ", player.pronoun, " now have a head:")
      player.bug.head = true
      changed = true
  of Part.feeler:
    if player.bug.feelers == maxFeelers:
      writeLine(stdout, ", but ", player.pronoun, " have two feelers already.")
    elif not player.bug.head:
      writeLine(stdout, ", but ", player.pronoun, " need a head first.")
    else:
      player.bug.feelers += 1
      write(stdout, "; ", player.pronoun, " now have",
        plural(player.bug.feelers, "feeler"))
      writeLine(stdout, ":")
      changed = true
  of Part.tail:
    if player.bug.tail:
      writeLine(stdout, ", but ", player.pronoun, " already have a tail.")
    elif not player.bug.body:
      writeLine(stdout, ", but ", player.pronoun, " need a body first.")
    else:
      writeLine(stdout, "; ", player.pronoun, " now have a tail:")
      player.bug.tail = true
      changed = true
  of Part.leg:
    if player.bug.legs == maxLegs:
      writeLine(stdout, ", but ", player.pronoun, " have",
        asText[maxLegs], "feet already.")
    elif not player.bug.body:
      writeLine(stdout, ", but ", player.pronoun, " need a body first.")
    else:
      player.bug.legs += 1
      write(stdout, "; ", player.pronoun, " now have",
        plural(player.bug.legs, "leg"))
      writeLine(stdout, ":")
      changed = true
  return changed

# Ask the user to press the Enter key, wait for the input, then erase the
# prompt text.
#
proc prompt() =
  write(stdout, "Press Enter to roll the dice. ")
  discard readLine(stdin)
  erasePreviousLine()

# Play one turn for the given player, rolling the dice and updating his bug.
#
proc turn(player: var Player) =
  prompt()
  var number: int = dice()
  var part = Part(number)
  write(stdout, capitalize(player.pronoun), " rolled a ", number, " (", part, ")")
  if addPart(part, player):
    writeLine(stdout, "")
    printBug(player.bug)
  writeLine(stdout, "")

proc printWinner() =
  if finished(human.bug) and finished(computer.bug):
    writeLine(stdout, "Both of our bugs are finished in the same number of turns!")
  elif finished(human.bug):
    writeLine(stdout, human.possessive, " bug is finished.")
  elif finished(computer.bug):
    writeLine(stdout, computer.possessive, " bug is finished.")

proc gameOver(): bool  =
  return finished(human.bug) or finished(computer.bug)

proc play() =
  clearScreen()
  while not gameOver():
    turn(human)
    turn(computer)
  printWinner()

# Init the players' data before a new game.
#
proc init() =
  human.pronoun = "you"
  human.possessive = "Your"
  human.bug.feelerType = 'A'
  computer.pronoun = "I"
  computer.possessive = "My"
  computer.bug.feelerType = 'F'

init()
printCredits()
printInstructions()
play()
writeLine(stdout, "I hope you enjoyed the game, play it again soon!!")

• Todas las versiones de Bug

Bunny

#[
Bunny

Original version in BASIC:
  Creative Computing (Morristown, New Jersey, USA), 1978.

This version in Nim:
  Copyright (c) 2023, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written in 2023-08.

Last modified: 20250405T0304+0200.
]#

import std/algorithm
import std/terminal

proc cursorHome() =
  setCursorPos 0, 0

proc clearScreen() =
  eraseScreen()
  cursorHome()

proc showCredits() =
  echo "Bunny\n"
  echo "Original version in BASIC:"
  echo "    Creative computing (Morristown, New Jersey, USA), ca. 1978.\n"
  echo "This version in Nim:"
  echo "    Copyright (c) 2023, Marcos Cruz (programandala.net)"
  echo "    SPDX-License-Identifier: Fair\n"
  echo "Press any key to start the program."
  discard getch()

const Width = 53
const space = ' '
var line: array[Width, char] # buffer

# Print the line buffer.
proc printLine() =
  for col in 0 ..< Width:
    write(stdout, line[col])
  echo ""

const letter: array[5, char] = ['B', 'U', 'N', 'N', 'Y']

const EOL = -1 # end of line identifier

const data = [
  1, 2, EOL, 0, 2, 45, 50, EOL, 0, 5, 43, 52, EOL, 0, 7, 41, 52, EOL,
  1, 9, 37, 50, EOL, 2, 11, 36, 50, EOL, 3, 13, 34, 49, EOL, 4, 14,
  32, 48, EOL, 5, 15, 31, 47, EOL, 6, 16, 30, 45, EOL, 7, 17, 29, 44,
  EOL, 8, 19, 28, 43, EOL, 9, 20, 27, 41, EOL, 10, 21, 26, 40, EOL,
  11, 22, 25, 38, EOL, 12, 22, 24, 36, EOL, 13, 34, EOL, 14, 33, EOL,
  15, 31, EOL, 17, 29, EOL, 18, 27, EOL, 19, 26, EOL, 16, 28, EOL,
  13, 30, EOL, 11, 31, EOL, 10, 32, EOL, 8, 33, EOL, 7, 34, EOL, 6,
  13, 16, 34, EOL, 5, 12, 16, 35, EOL, 4, 12, 16, 35, EOL, 3, 12, 15,
  35, EOL, 2, 35, EOL, 1, 35, EOL, 2, 34, EOL, 3, 34, EOL, 4, 33,
  EOL, 6, 33, EOL, 10, 32, 34, 34, EOL, 14, 17, 19, 25, 28, 31, 35,
  35, EOL, 15, 19, 23, 30, 36, 36, EOL, 14, 18, 21, 21, 24, 30, 37, 37,
  EOL, 13, 18, 23, 29, 33, 38, EOL, 12, 29, 31, 33, EOL, 11, 13, 17,
  17, 19, 19, 22, 22, 24, 31, EOL, 10, 11, 17, 18, 22, 22, 24, 24, 29,
  29, EOL, 22, 23, 26, 29, EOL, 27, 29, EOL, 28, 29, EOL ]


# Draw the graphic out of `data` and `letter`.
proc draw() =
  var d = 0 # pointer in `data`
  var col: int # col to draw from
  var toCol: int # col to draw to
  fill(line, space)
  while d < data.len:
    col = data[d]
    d += 1
    if col == EOL:
      printLine()
      fill(line, space)
    else:
      toCol = data[d]
      d += 1
      for c in col .. toCol:
        line[c] = letter[c mod letter.len]

clearScreen()
showCredits()
clearScreen()
draw()

• Todas las versiones de Bunny

Chase

#[

Chase

Original version in BASIC:

  Anonymous.
  Published in 1977 in "The Best of Creative Computing", Volume 2.

  https://www.atariarchives.org/bcc2/showpage.php?page=253

Version in Oberon-07:

  Copyright (c) 2022, 2023, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Version in Odin:

  Copyright (c) 2023, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

This version in Nim:

  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2025-01-22.

Last modified: 20250405T0304+0200.

]#

import std/strformat
import std/random
import std/strutils
import std/terminal

# Terminal {{{1
# =============================================================

proc cursorHome() =
  setCursorPos(0, 0)

proc clearScreen() =
  eraseScreen()
  cursorHome()

proc eraseLineRight() =
  write(stdout, "\e[K")

proc eraseDown() =
  # Erases the screen from the current line down to the bottom of the screen.
  #
  # This is defined in std/terminal but deactivated, because it does not have
  # equivalent in Windows.
  write(stdout, "\e[J")

proc setCursorPosYX(y: int, x: int) =
  setCursorPos(x, y)

const black = 0
const red = 1
const green = 2
const yellow = 3
const blue = 4
const magenta = 5
const cyan = 6
const white = 7
const default = 9

const foreground = +30 # color offset
const background = +40 # color offset
const bright = +60 # foreground and background offset

const normal = 0
const bold = 1 # bold text (or bright on terminals not supporting)
const dim = 2 # dim text
const italic = 3 # italic (or reverse on terminals not supporting)
const underlined = 4
const blinking = 5 # blinking/bold text
const rapidBlinking = 6 # rapid blinking/bold text (not widely supported)
const reversed = 7
const hidden = 8
const crossedout = 9 # strikethrough

const styleOff = +20 # style offset to turn it off

const notBold = 21 # or double underlined on some terminals
const notDim = 22
const notItalic = 23
const notUnderlined = 24
const notBlinking = 25
const notReversed = 27
const notHidden = 28
const notCrossedout = 29

proc ansiStyleCode(fg: int = default, bg: int = default, style: int = normal): string =
  result = &"\e[0;{style};{fg + foreground};{bg + background}m"

proc setStyle(style: string) =
  write(stdout, style)

proc setStyles(fg: int = default, bg: int = default, style: int = normal) =
  setStyle(ansiStyleCode(fg, bg, style))

# Globals {{{1
# =============================================================

# Colors

const defaultInk = ansiStyleCode(white)
const inputInk = ansiStyleCode(bright + green)
const instructionsInk = ansiStyleCode(bright + yellow)
const titleInk = ansiStyleCode(bright + red)

# Arena

const arenaWidth = 20
const arenaHeight = 10
const arenaLastX = arenaWidth - 1
const arenaLastY = arenaHeight - 1
const arenaRow = 3

type Arena = array[arenaHeight, array[arenaWidth, string]]
var arena: Arena

const empty = " "
const fence = "X"
const machine = "m"
const human = "@"

const fences = 15 # inner obstacles, not the border

# The end

type End = enum
  notYet,
  surrender,
  electrified,
  killed,
  victory,

var theEnd: End

# Machines

const machines = 5
const machinesDrag = 2 # probability not moving: 0=0%, 1=50%, 2=66%, 3=75%, etc.

var machineX: array[machines, int]
var machineY: array[machines, int]
var operative: array[machines, bool]
var destroyedMachines: int # counter

# Human

var humanX: int
var humanY: int

# User input {{{1
# =============================================================

# Print the given prompt and wait until the user enters a string.
#
proc inputString(prompt: string = ""): string =
  setStyle(inputInk)
  defer: setStyle(defaultInk)
  write(stdout, prompt)
  result = readLine(stdin) # XXX TODO orElse ""

# Print the given prompt and wait until the user presses Enter.
#
proc pressEnter(prompt: string) =
  discard inputString(prompt)

# Return `true` if the given string is "yes" or a synonym.
#
proc isYes(s: string): bool  =
  return toLower(s) in ["ok", "y", "yeah", "yes"]

# Return `true` if the given string is "no" or a synonym.
#
proc isNo(s: string): bool  =
  return toLower(s) in ["n", "no", "nope"]

# Print the given prompt, wait until the user enters a valid yes/no string,
# and return `true` for "yes" or `false` for "no".
#
proc yes(prompt: string): bool =
  while true:
    var answer = inputString(prompt)
    if isYes(answer):
      return true
    if isNo(answer):
      return false

# Title, credits and instructions {{{1
# =============================================================

const title = "Chase"

# Print the title at the current cursor position.
#
proc printTitle() =
  setStyle(titleInk)
  writeLine(stdout, title)
  setStyle(defaultInk)

proc printCredits() =
  printTitle()
  writeLine(stdout, "\nOriginal version in BASIC:")
  writeLine(stdout, "    Anonymous.")
  writeLine(stdout, "    Published in \"The Best of Creative Computing\", Volume 2, 1977.")
  writeLine(stdout, "    https://www.atariarchives.org/bcc2/showpage.php?page=253")
  writeLine(stdout, "\nThis version in Nim:")
  writeLine(stdout, "    Copyright (c) 2025, Marcos Cruz (programandala.net)")
  writeLine(stdout, "    SPDX-License-Identifier: Fair")

# Print the game instructions and wait for a key.
#
proc printInstructions() =
  printTitle()
  setStyle(instructionsInk)
  defer: setStyle(defaultInk)
  writeLine(stdout, "\nYou (", human, ") are in a high voltage maze with ", machines, "")
  writeLine(stdout, "security machines (", machine, ") trying to kill you.")
  writeLine(stdout, "You must maneuver them into the maze (", fence, ") to survive.\n")
  writeLine(stdout, "Good luck!\n")
  writeLine(stdout, "The movement commands are the following:\n")
  writeLine(stdout, "    ↖  ↑  ↗")
  writeLine(stdout, "    NW N NE")
  writeLine(stdout, "  ←  W   E  →")
  writeLine(stdout, "    SW S SE")
  writeLine(stdout, "    ↙  ↓  ↘")
  writeLine(stdout, "\nPlus 'Q' to end the game.")

# Arena {{{1
# =============================================================

# Display the arena at the top left corner of the screen.
#
proc printArena() =
  setCursorPosYX(arenaRow, 0)
  for y in 0 .. arenaLastY:
    for x in 0 .. arenaLastX:
      write(stdout, arena[y][x])
    writeLine(stdout, "")

# If the given arena coordinates `y` and `x` are part of the border arena
# (i.e. its surrounding fence), return `true`, otherwise return `false`.
#
proc isBorder(y, x: int): bool =
  result = (y == 0) or (x == 0) or (y == arenaLastY) or (x == arenaLastX)

# Place the given string at a random empty position of the arena and return
# the coordinates.
#
proc place(s: string): (int, int) =
  var y: int
  var x: int
  while true:
    y = rand(1 .. arenaLastY - 1)
    x = rand(1 .. arenaLastX - 1)
    if arena[y][x] == empty:
      break
  arena[y][x] = s
  result = (y, x)

# Inhabit the arena with the machines, the inner fences and the human.
#
proc inhabitArena() =
  for m in 0 ..< machines:
    (machineY[m], machineX[m]) = place(machine)
    operative[m] = true
  for _ in 0 ..< fences:
    discard place(fence)
  (humanY, humanX) = place(human)

# Clean the arena, i.e. empty it and add a surrounding fence.
#
proc cleanArena() =
  for y in 0 .. arenaLastY:
    for x in 0 .. arenaLastX:
      arena[y][x] = if isBorder(y, x): fence else: empty

# Game {{{1
# =============================================================

# Init the game.
#
proc initGame() =
  cleanArena()
  inhabitArena()
  destroyedMachines = 0
  theEnd = notYet

# Move the given machine.
#
proc moveMachine(m: int) =

  var maybe: int

  arena[machineY[m]][machineX[m]] = empty

  maybe = rand(0 .. 1)
  if machineY[m] > humanY:
    machineY[m] -= maybe
  elif machineY[m] < humanY:
    machineY[m] += maybe

  maybe = rand(0 .. 1)
  if machineX[m] > humanX:
    machineX[m] -= maybe
  elif machineX[m] < humanX:
    machineX[m] += maybe

  if arena[machineY[m]][machineX[m]] == empty:
    arena[machineY[m]][machineX[m]] = machine
  elif arena[machineY[m]][machineX[m]] == fence:
    operative[m] = false
    destroyedMachines += 1
    if destroyedMachines == machines:
      theEnd = victory
  elif arena[machineY[m]][machineX[m]] == human:
    theEnd = killed

# Maybe move the given operative machine.
#
proc maybeMoveMachine(m: int) =
  if rand(machinesDrag) == 0:
    moveMachine(m)

# Move the operative machines.
#
proc moveMachines() =
  for m in 0 ..< machines:
    if operative[m]:
      maybeMoveMachine(m)

# Read a user command; update `theEnd` accordingly and return the direction
# increments.
#
proc getMove(): (int, int) =
  var yInc = 0
  var xInc = 0
  writeLine(stdout, "")
  eraseLineRight()
  var command = toLower(inputString("Command: "))
  case command:
  of "q":
    theEnd = surrender
  of "sw":
    yInc = +1
    xInc = -1
  of "s":
    yInc = +1
  of "se":
    yInc = +1
    xInc = +1
  of "w":
    xInc = -1
  of "e":
    xInc = +1
  of "nw":
    yInc = -1
    xInc = -1
  of "n":
    yInc = -1
  of "ne":
    yInc = -1
    xInc = +1
  else:
    discard
  result = (yInc, xInc)

proc play() =
  var yInc: int
  var xInc: int

  while true: # game loop

    clearScreen()
    printTitle()
    initGame()

    while true: # action loop
      printArena()
      (yInc, xInc) = getMove()
      if theEnd == notYet:
        if yInc != 0 or xInc != 0:
          arena[humanY][humanX] = empty
          if arena[humanY + yInc][humanX + xInc] == fence:
            theEnd = electrified
          elif arena[humanY + yInc][humanX + xInc] == machine:
            theEnd = killed
          else:
            arena[humanY][humanX] = empty
            humanY = humanY + yInc
            humanX = humanX + xInc
            arena[humanY][humanX] = human
            printArena()
            moveMachines()
      if theEnd != notYet:
        break
    # action loop

    case theEnd:
    of surrender:
      writeLine(stdout, "\nSorry to see you quit.")
    of electrified:
      writeLine(stdout, "\nZap! You touched the fence!")
    of killed:
      writeLine(stdout, "\nYou have been killed by a lucky machine.")
    of victory:
      writeLine(stdout, "\nYou are lucky, you destroyed all machines.")
    else:
      discard

    if not yes("\nDo you want to play again? "):
      break

  # game loop

  writeLine(stdout, "\nHope you don't feel fenced in.")
  writeLine(stdout, "Try again sometime.")

# Main {{{1
# =============================================================

randomize()
setStyle(defaultInk)

clearScreen()
printCredits()

pressEnter("\nPress the Enter key to read the instructions. ")
clearScreen()
printInstructions()

pressEnter("\nPress the Enter key to start. ")
play()

• Todas las versiones de Chase

3D Plot

#[
D3 Plot

Original version in BASIC, "3D PLOT":
  Creative Computing (Morristown, New Jersey, USA), ca. 1980.

This version in Nim:
  Copyright (c) 2023, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written in 2023-01/02, 2023-08.

Last modified: 20250405T0304+0200.
]#

import std/algorithm
import std/math
import std/terminal

proc cursorHome() =
  setCursorPos 0, 0

proc clearScreen() =
  eraseScreen()
  cursorHome()

proc showCredits() =
  echo "D3 Plot\n"
  echo "Original version in BASIC:"
  echo "    3D PLOT"
  echo "    Creative computing (Morristown, New Jersey, USA), ca. 1980.\n"
  echo "This version in Nim:"
  echo "    Copyright (c) 2023, Marcos Cruz (programandala.net)"
  echo "    SPDX-License-Identifier: Fair\n"
  echo "Press any key to start the program."
  discard getch()

proc a(z: float): float =
  result = 30 * exp(-z * z / 100)

proc draw() =

  const width = 56
  const space = ' '
  const dot = '*'
  var line: array[width, char]

  var l = 0
  var y1 = 0
  var z = 0

  var x = -30.0
  while x <= 30:
    fill(line, space)
    l = 0
    y1 = 5 * int(sqrt(900 - x * x) / 5)
    for y in countdown(y1, -y1, 5):
      z = int(25 + a(sqrt(x * x + float(y * y)))-0.7 * float(y))
      if z > l:
        l = z
        line[z] = dot
    for pos in 0 ..< width:
      write(stdout, line[pos])
    echo ""
    x += 1.5

clearScreen()
showCredits()
clearScreen()
draw()

• Todas las versiones de 3D Plot

Diamond

#[
Diamond

Original version in BASIC:
  Example included in Vintage BASIC 1.0.3.
  http://www.vintage-basic.net

This version in Nim:
  Copyright (c) 2023, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written in 2023-07-18/19, 2023-08-27.

Last modified: 20250405T0302+0200.
]#

const Lines = 17

for i in 1 .. int(Lines / 2 + 1):
  for j in 1 .. int((Lines + 1) / 2) - i + 1:
    write(stdout, " ")
  for j in 1 .. i * 2 - 1:
    write(stdout, "*")
  writeLine(stdout, "")

for i in 1 .. int(Lines / 2):
  for j in 1 .. i + 1:
    write(stdout, " ")
  for j in 1 .. (int((Lines + 1) / 2) - i) * 2 - 1:
    write(stdout, "*")
  writeLine(stdout, "")

• Todas las versiones de Diamond

Hammurabi

#[
Hammurabi

Description:
  A simple text-based simulation game set in the ancient kingdom of Sumeria.

Original program:
  Written in FOCAL on a DEP PDP-8 by Rick Merrill, 1969.

BASIC port:
  Ported from FOCAL and modified for Edusystem 70 by David Ahl, c. 1973.
  Modified for 8K Microsoft BASIC by Peter Turnbull, c. 1978.

More details:
  - https://en.wikipedia.org/wiki/Hamurabi_(video_game)
  - https://www.mobygames.com/game/22232/hamurabi/

Improved remake in Odin:
  Copyright (c) 2023, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

This improved remake in Odin:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2025-01-22.

Last modified: 20251119T0013+0100.

Acknowledgment:
  The following Python port was used as a reference of the original
  variables: <https://github.com/jquast/hamurabi.py>.

]#

import std/math
import std/random
import std/strformat
import std/strutils
import std/terminal
import system

# Terminal {{{1
# =============================================================

proc cursorHome() =
  setCursorPos(0, 0)

proc clearScreen() =
  eraseScreen()
  cursorHome()

proc eraseLineRight() =
  write(stdout, "\e[K")

proc eraseDown() =
  # Erases the screen from the current line down to the bottom of the screen.
  #
  # This is defined in std/terminal but deactivated, because it does not have
  # equivalent in Windows.
  write(stdout, "\e[J")

const black = 0
const red = 1
const green = 2
const yellow = 3
const blue = 4
const magenta = 5
const cyan = 6
const white = 7
const default = 9

const foreground = +30 # color offset
const background = +40 # color offset
const bright = +60 # foreground and background offset

const normal = 0
const bold = 1 # bold text (or bright on terminals not supporting)
const dim = 2 # dim text
const italic = 3 # italic (or reverse on terminals not supporting)
const underlined = 4
const blinking = 5 # blinking/bold text
const rapidBlinking = 6 # rapid blinking/bold text (not widely supported)
const reversed = 7
const hidden = 8
const crossedout = 9 # strikethrough

const styleOff = +20 # style offset to turn it off

const notBold = 21 # or double underlined on some terminals
const notDim = 22
const notItalic = 23
const notUnderlined = 24
const notBlinking = 25
const notReversed = 27
const notHidden = 28
const notCrossedout = 29

proc ansiStyleCode(fg: int = default, bg: int = default, style: int = normal): string =
  result = &"\e[0;{style};{fg + foreground};{bg + background}m"

proc setStyle(style: string) =
  write(stdout, style)

proc setStyles(fg: int = default, bg: int = default, style: int = normal) =
  setStyle(ansiStyleCode(fg, bg, style))

# Globals {{{1
# =============================================================

const acresABushelCanSeed = 2 # yearly
const acresAPersonCanSeed = 10 # yearly
const initialAcresPerPerson = 10 # to calculate the initial acres of the city
const bushelsToFeedAPerson = 20 # yearly
const irritationLevels = 5 # after the switch in `showIrritation`
const maxIrritation = 16
const irritationStep = int(maxIrritation / irritationLevels)
const minHarvestedBushelsPerAcre = 17
const rangeOfHarvestedBushelsPerAcre = 10
const maxHarvestedBushelsPerAcre = minHarvestedBushelsPerAcre + rangeOfHarvestedBushelsPerAcre - 1
const plagueChance = 0.15 # 15% yearly
const years = 10 # goverment period

type Result = enum
  veryGood
  notTooBad
  bad
  veryBad

var acres: int
var bushelsEatenByRats: int
var bushelsHarvested: int
var bushelsHarvestedPerAcre: int
var bushelsInStore: int
var bushelsToFeedWith: int
var dead: int
var infants: int
var irritation: int # counter (0 .. 99)
var population: int
var starvedPeoplePercentage: int
var totalDead: int

const defaultStyle = ansiStyleCode(white)
const inputStyle = ansiStyleCode(bright + green)
const instructionsStyle = ansiStyleCode(bright + yellow)
const resultStyle = ansiStyleCode(bright + cyan)
const speechStyle = ansiStyleCode(bright + magenta)
const titleStyle = ansiStyleCode(bright + white)
const warningStyle = ansiStyleCode(bright + red)

# User input {{{1
# =============================================================

# Print the given prompt and return the integer entered by the
# user; if the user input is not a valid integer, ask again.
#
proc input(prompt: string): int =
  setStyle(inputStyle)
  defer: setStyle(defaultStyle)
  while true:
    try:
      write(stdout, prompt)
      result = parseInt(readLine(stdin))
      break
    except ValueError:
      continue

proc pause(prompt: string = "> ") =
  setStyle(inputStyle)
  write(stdout, prompt)
  discard readLine(stdin)
  setStyle(defaultStyle)

# Instructions and credits {{{1
# =============================================================

proc instructions(): string =
  result = fmt"""
Hammurabi is a simulation game in which you, as the ruler of the ancient
kingdom of Sumeria, Hammurabi, manage the resources.

You may buy and sell land with your neighboring city-states for bushels of
grain ― the price will vary between {minHarvestedBushelsPerAcre} and {maxHarvestedBushelsPerAcre} bushels per acre.  You also must
use grain to feed your people and as seed to plant the next year's crop.

You will quickly find that a certain number of people can only tend a certain
amount of land and that people starve if they are not fed enough.  You also
have the unexpected to contend with such as a plague, rats destroying stored
grain, and variable harvests.

You will also find that managing just the few resources in this game is not a
trivial job.  The crisis of population density rears its head very rapidly.

Try your hand at governing ancient Sumeria for a {years}-year term of office."""

proc printInstructions() =
  setStyle(instructionsStyle)
  writeLine(stdout, instructions())
  setStyle(defaultStyle)

const credits = """Hammurabi

Original program:
  Written in FOCAL on a DEP PDP-8 by Rick Merrill, 1969.

BASIC port:
  Ported from FOCAL and modified for Edusystem 70 by David Ahl, c. 1973.
  Modified for 8K Microsoft BASIC by Peter Turnbull, c. 1978.

This improved remake in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair"""

proc printCredits() =
  setStyle(titleStyle)
  writeLine(stdout, credits)
  setStyle(defaultStyle)

# Game {{{1
# =============================================================

proc ordinalSuffix(n: int): string =
  case n:
  of 1: return "st"
  of 2: return "nd"
  of 3: return "rd"
  else: return "th"

# Return the description of the given year as the previous one.
#
proc previous(year: int): string =
  if year == 0:
    return "the previous year"
  else:
    return fmt"your {year}{ordinalSuffix(year)} year"

# Return the proper wording for `n` persons, using the given or default words
# for singular and plural forms.
#
proc persons(n: int, singular = "person", plural = "people"): string =
  case n:
  of 0: return "nobody"
  of 1: return fmt"one {singular}"
  else: return fmt"{n} {plural}"

proc printAnnualReport(year: int) =
  clearScreen()
  setStyle(speechStyle)
  writeLine(stdout, "Hammurabi, I beg to report to you.")
  setStyle(defaultStyle)

  let children = persons(infants, "infant", "infants")
  let were = if infants > 1: "were" else: "was"
  write(stdout, &"\nIn {previous(year)}, {persons(dead)} starved and {children} {were} born.\n")

  population += infants

  if year > 0 and rand(1.0) <= plagueChance:
    population = int(population / 2)
    setStyle(warningStyle)
    writeLine(stdout, "A horrible plague struck!  Half the people died.")
    setStyle(defaultStyle)

  writeLine(stdout, fmt"The population is {population}.")
  writeLine(stdout, fmt"The city owns {acres} acres.")
  write(stdout, &"You harvested {bushelsHarvested} bushels ({bushelsHarvestedPerAcre} per acre).\n")
  if bushelsEatenByRats > 0:
    writeLine(stdout, fmt"The rats ate {bushelsEatenByRats} bushels.")
  writeLine(stdout, fmt"You have {bushelsInStore} bushels in store.")
  bushelsHarvestedPerAcre =
    int(rangeOfHarvestedBushelsPerAcre * rand(1.0)) +
    minHarvestedBushelsPerAcre
  writeLine(stdout, &"Land is trading at {bushelsHarvestedPerAcre} bushels per acre.\n")

proc sayBye() =
  setStyle(defaultStyle)
  writeLine(stdout, "\nSo long for now.\n")

proc quitGame() =
  sayBye()
  quit(0)

proc relinquish() =
  setStyle(speechStyle)
  writeLine(stdout, "\nHammurabi, I am deeply irritated and cannot serve you anymore.")
  writeLine(stdout, "Please, get yourself another steward!")
  setStyle(defaultStyle)
  quitGame()

proc increaseIrritation() =
  irritation += 1 + rand(irritationStep - 1)
  if irritation >= maxIrritation:
    relinquish() # this never returns

proc printIrritated(adverb: string) =
  writeLine(stdout, fmt"The steward seems {adverb} irritated.")

proc showIrritation() =
  if irritation < irritationStep:
    discard
  elif irritation < irritationStep * 2:
    printIrritated("slightly")
  elif irritation < irritationStep * 3:
    printIrritated("quite")
  elif irritation < irritationStep * 4:
    printIrritated("very")
  else:
    printIrritated("profoundly")

# Print a message begging to repeat an ununderstandable input.
#
proc begRepeat() =
  increaseIrritation() # this may never return
  setStyle(speechStyle)
  writeLine(stdout, "I beg your pardon?  I did not understand your order.")
  setStyle(defaultStyle)
  showIrritation()

# Print a message begging to repeat a wrong input, because there's only `n`
# items of `name`.
#
proc begThinkAgain(n: int, name: string) =
  increaseIrritation() # this may never return
  setStyle(speechStyle)
  writeLine(stdout, fmt"I beg your pardon?  You have only {n} {name}.  Now then…")
  setStyle(defaultStyle)
  showIrritation()

# Buy or sell land.
#
proc trade() =
  var acresToBuy: int
  var acresToSell: int
  var ok: bool

  while true:
    acresToBuy = input("How many acres do you wish to buy? (0 to sell): ")
    if acresToBuy < 0:
      begRepeat() # this may never return
      continue
    if bushelsHarvestedPerAcre * acresToBuy <= bushelsInStore:
      break
    begThinkAgain(bushelsInStore, "bushels of grain")

  if acresToBuy != 0:

    writeLine(stdout, fmt"You buy {acresToBuy} acres.")
    acres += acresToBuy
    bushelsInStore -= bushelsHarvestedPerAcre * acresToBuy
    writeLine(stdout, fmt"You now have {acres} acres and {bushelsInStore} bushels.")

  else:

    while true:
      acresToSell = input("How many acres do you wish to sell?: ")
      if acresToSell < 0:
        begRepeat() # this may never return
        continue
      if acresToSell < acres:
        break
      begThinkAgain(acres, "acres")

    if acresToSell > 0:
      writeLine(stdout, fmt"You sell {acresToSell} acres.")
      acres -= acresToSell
      bushelsInStore += bushelsHarvestedPerAcre * acresToSell
      writeLine(stdout, fmt"You now have {acres} acres and {bushelsInStore} bushels.")

# Feed the people.
#
proc feed() =
  var ok: bool

  while true:
    bushelsToFeedWith = input("How many bushels do you wish to feed your people with?: ")
    if bushelsToFeedWith < 0:
      begRepeat() # this may never return
      continue
    # Trying to use more grain than is in silos?
    if bushelsToFeedWith <= bushelsInStore:
      break
    begThinkAgain(bushelsInStore, "bushels of grain")

  writeLine(stdout, fmt"You feed your people with {bushelsToFeedWith} bushels.")
  bushelsInStore -= bushelsToFeedWith
  writeLine(stdout, fmt"You now have {bushelsInStore} bushels.")

# Seed the land.
#
proc seed() =
  var acresToSeed: int
  var ok: bool

  while true:

    acresToSeed = input("How many acres do you wish to seed?: ")
    if acresToSeed < 0:
      begRepeat() # this may never return
      continue
    if acresToSeed == 0:
      break

    # Trying to seed more acres than you own?
    if acresToSeed > acres:
      begThinkAgain(acres, "acres")
      continue

    # Enough grain for seed?
    if int(acresToSeed / acresABushelCanSeed) > bushelsInStore:
      begThinkAgain(
        bushelsInStore,
        fmt"bushels of grain,\nand one bushel can seed {acresABushelCanSeed} acres")
      continue

    # Enough people to tend the crops?
    if acresToSeed <= acresAPersonCanSeed * population:
      break

    begThinkAgain(
      population,
      fmt"people to tend the fields,\nand one person can seed {acresAPersonCanSeed} acres")

  var bushelsUsedForSeeding = int(acresToSeed / acresABushelCanSeed)
  writeLine(stdout, fmt"You seed {acresToSeed} acres using {bushelsUsedForSeeding} bushels.")
  bushelsInStore -= bushelsUsedForSeeding
  writeLine(stdout, fmt"You now have {bushelsInStore} bushels.")

 # A bountiful harvest!
  bushelsHarvestedPerAcre = rand(1 .. 5)
  bushelsHarvested = acresToSeed * bushelsHarvestedPerAcre
  bushelsInStore += bushelsHarvested

proc isEven(n: int): bool =
  result = n %% 2 == 0

proc checkRats() =
  var ratChance = rand(1 .. 5)
  bushelsEatenByRats = if isEven(ratChance): int(bushelsInStore / ratChance) else: 0
  bushelsInStore -= bushelsEatenByRats

# Set the variables to their values in the first year.
#
proc init() =
  dead = 0
  totalDead = 0
  starvedPeoplePercentage = 0
  population = 95
  infants = 5
  acres = initialAcresPerPerson * (population + infants)
  bushelsHarvestedPerAcre = 3
  bushelsHarvested = acres * bushelsHarvestedPerAcre
  bushelsEatenByRats = 200
  bushelsInStore = bushelsHarvested - bushelsEatenByRats
  irritation = 0

proc printResult(result: Result) =
  setStyle(resultStyle)

  case result:
  of veryGood:
      writeLine(stdout, "A fantastic performance!  Charlemagne, Disraeli and Jefferson combined could")
      writeLine(stdout, "not have done better!")
  of notTooBad:
      writeLine(stdout, "Your performance could have been somewat better, but really wasn't too bad at")
      write(stdout, &"all. {int(float(population) * 0.8 * rand(1.0))} people would dearly like to see you assassinated, but we all have our\n")
      writeLine(stdout, "trivial problems.")
  of bad:
      writeLine(stdout, "Your heavy-handed performance smacks of Nero and Ivan IV.  The people")
      writeLine(stdout, "(remaining) find you an unpleasant ruler and, frankly, hate your guts!")
  of veryBad:
      writeLine(stdout, "Due to this extreme mismanagement you have not only been impeached and thrown")
      writeLine(stdout, "out of office but you have also been declared national fink!!!")

  setStyle(defaultStyle)

proc printFinalReport() =
  clearScreen()

  if starvedPeoplePercentage > 0:
    write(stdout, &"In your {years}-year term of office, {starvedPeoplePercentage} percent of the\n")
    write(stdout, &"population starved per year on the average, i.e., a total of {totalDead} people died!\n\n")

  var acresPerPerson = acres / population
  write(stdout, &"You started with {initialAcresPerPerson} acres per person and ended with {acresPerPerson}.\n\n")

  if starvedPeoplePercentage > 33 or acresPerPerson < 7:
    printResult(veryBad)
  elif starvedPeoplePercentage > 10 or acresPerPerson < 9:
    printResult(bad)
  elif starvedPeoplePercentage > 3 or acresPerPerson < 10:
    printResult(notTooBad)
  else:
    printResult(veryGood)

proc checkStarvation(year: int) =
    # How many people has been fed?
    var fedPeople = int(bushelsToFeedWith / bushelsToFeedAPerson)

    if population > fedPeople:

      dead = population - fedPeople
      starvedPeoplePercentage = int((float64((year - 1) * starvedPeoplePercentage) + float64(dead) * 100.0 / float64(population)) / float64(year))
      population -= dead
      totalDead += dead

      # Starve enough for impeachment?
      if dead > int(0.45 * float(population)):
        setStyle(warningStyle)
        writeLine(stdout, &"\nYou starved {dead} people in one year!!!\n")
        setStyle(defaultStyle)
        printResult(veryBad)
        quitGame()

proc govern() =
  init()

  printAnnualReport(0)

  for year in 1 .. years:

    trade()
    feed()
    seed()
    checkRats()

    # Let's have some babies
    infants = int(rand(1 .. 5) * (20 * acres + bushelsInStore) / population / 100 + 1)

    checkStarvation(year)

    pause("\nPress the Enter key to read the annual report. ")
    printAnnualReport(year)

# Main {{{1
# =============================================================

randomize()

clearScreen()
printCredits()

pause("\nPress the Enter key to read the instructions. ")
clearScreen()
printInstructions()

pause("\nPress the Enter key to start. ")
govern()

pause("Press the Enter key to read the final report. ")
printFinalReport()
sayBye()

• Todas las versiones de Hammurabi

High Noon

#[
High Noon

Original version in BASIC:
  Designed and programmed by Chris Gaylo, Syosset High School, New York, 1970-09-12.
  http://mybitbox.com/highnoon-1970/
  http://mybitbox.com/highnoon/

Transcriptions:
  https://github.com/MrMethor/Highnoon-BASIC/
  https://github.com/mad4j/basic-highnoon/

Version modified for QB64:
  By Daniele Olmisani, 2014.
  https://github.com/mad4j/basic-highnoon/

Improved remake in Odin:
  Copyright (c) 2023, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

This improved remake in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2025-01-21.

Last modified: 20250404T0159+0200.
]#

import std/math
import std/random
import std/strformat
import std/strutils
import std/terminal
import std/unicode

# Terminal {{{1
# =============================================================

proc cursorHome() =
  setCursorPos(0, 0)

proc clearScreen() =
  eraseScreen()
  cursorHome()

# Global variables and constants {{{1
# =============================================================

type Color = tuple [
  foreground: ForegroundColor,
  bright: bool,
  ]

const defaultInk: Color = (fgWhite, false)
const inputInk: Color = (fgGreen, true)
const instructionsInk: Color = (fgYellow, false)
const titleInk: Color = (fgRed, false)

const initialDistance = 100
const initialBullets = 4
const maxWateringTroughs = 3

var distance: int # distance between both gunners, in paces
var strategy: string # player's strategy

var playerBullets: int
var opponentBullets: int

# User input {{{1
# =============================================================

# Print the given prompt and wait until the user enters an integer.
#
proc inputInt(prompt = ""): int =
  write(stdout, ansiForegroundColorCode(inputInk.foreground, inputInk.bright))
  defer: write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))
  while true:
    try:
      write(stdout, prompt)
      result = parseInt(readLine(stdin))
      break
    except ValueError:
      result = 0

# Print the given prompt and wait until the user enters a string.
#
proc inputString(prompt = ""): string =
  write(stdout, ansiForegroundColorCode(inputInk.foreground, inputInk.bright))
  defer: write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))
  write(stdout, prompt)
  result = readLine(stdin)

# Print the given prompt and wait until the user presses Enter.
#
proc pressAnyKey(prompt: string) =
  write(stdout, prompt)
  discard getch()

# Return `true` if the given string is "yes" or a synonym.
#
proc isYes(s: string): bool  =
  result = toLower(s) in ["ok", "y", "yeah", "yes"]

# Return `true` if the given string is "no" or a synonym.
#
proc isNo(s: string): bool  =
  result = toLower(s) in ["n", "no", "nope"]

# Print the given prompt, wait until the user enters a valid yes/no string,
# and return `true` for "yes" or `false` for "no".
#
proc yes(prompt: string): bool =
  while true:
    var answer = inputString(prompt)
    if isYes(answer):
        return true
    if isNo(answer):
        return false

# Title, instructions and credits {{{1
# =============================================================

# Print the title at the current cursor position.
#
proc printTitle() =
  write(stdout, ansiForegroundColorCode(titleInk.foreground, titleInk.bright))
  writeLine(stdout, "High Noon")
  write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))

proc printCredits() =
  printTitle()
  writeLine(stdout, "\nOriginal version in BASIC:")
  writeLine(stdout, "    Designed and programmend by Chris Gaylo, 1970.")
  writeLine(stdout, "    http://mybitbox.com/highnoon-1970/")
  writeLine(stdout, "    http://mybitbox.com/highnoon/")
  writeLine(stdout, "Transcriptions:")
  writeLine(stdout, "    https://github.com/MrMethor/Highnoon-BASIC/")
  writeLine(stdout, "    https://github.com/mad4j/basic-highnoon/")
  writeLine(stdout, "Version modified for QB64:")
  writeLine(stdout, "    By Daniele Olmisani, 2014.")
  writeLine(stdout, "    https://github.com/mad4j/basic-highnoon/")
  writeLine(stdout, "This improved remake in Nim:")
  writeLine(stdout, "    Copyright (c) 2025, Marcos Cruz (programandala.net)")
  writeLine(stdout, "    SPDX-License-Identifier: Fair")

proc printInstructions() =
  printTitle()
  write(stdout, ansiForegroundColorCode(instructionsInk.foreground, instructionsInk.bright))
  defer: write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))
  writeLine(stdout, "\nYou have been challenged to a showdown by Black Bart, one of")
  writeLine(stdout, "the meanest desperadoes west of the Allegheny mountains.")
  writeLine(stdout, "\nWhile you are walking down a dusty, deserted side street,")
  writeLine(stdout, "Black Bart emerges from a saloon one hundred paces away.")
  write(stdout, "\nBy agreement, you each have ", initialBullets, " bullets in your six-guns.")
  writeLine(stdout, "\nYour marksmanship equals his. At the start of the walk nei-")
  writeLine(stdout, "ther of you can possibly hit the other, and at the end of")
  writeLine(stdout, "the walk, neither can miss. the closer you get, the better")
  writeLine(stdout, "your chances of hitting black Bart, but he also has beter")
  writeLine(stdout, "chances of hitting you.")

# Game loop {{{1
# =============================================================

proc pluralSuffix(n: int): string =
  case n:
  of 1: return ""
  else: return "s"

proc printShellsLeft() =
  if playerBullets == opponentBullets:
    writeLine(stdout, "Both of you have ", playerBullets, " bullets.")
  else:
    writeLine(stdout, "You now have ", playerBullets, " bullet", pluralSuffix(playerBullets), " to Black Bart's ", opponentBullets, " bullet", pluralSuffix(opponentBullets), ".")

proc printCheck() =
  writeLine(stdout, "******************************************************")
  writeLine(stdout, "*                                                    *")
  writeLine(stdout, "*                 BANK OF DODGE CITY                 *")
  writeLine(stdout, "*                  CASHIER'S RECEIT                  *")
  writeLine(stdout, "*                                                    *")
  writeLine(stdout, fmt"* CHECK NO. {rand(1000 - 1):04}                   AUGUST ", 10 + rand(10 - 1), "TH, 1889 *")
  writeLine(stdout, "*                                                    *")
  writeLine(stdout, "*                                                    *")
  writeLine(stdout, "*       PAY TO THE BEARER ON DEMAND THE SUM OF       *")
  writeLine(stdout, "*                                                    *")
  writeLine(stdout, "* TWENTY THOUSAND DOLLARS-------------------$20,000  *")
  writeLine(stdout, "*                                                    *")
  writeLine(stdout, "******************************************************")

proc getReward() =
  writeLine(stdout, "As mayor of Dodge City, and on behalf of its citizens,")
  writeLine(stdout, "I extend to you our thanks, and present you with this")
  writeLine(stdout, "reward, a check for $20,000, for killing Black Bart.\n\n")
  printCheck()
  writeLine(stdout, "\n\nDon't spend it all in one place.")

proc moveTheOpponent() =
  var paces = 2 + rand(8 - 1)
  writeLine(stdout, "Black Bart moves ", paces, " paces.")
  distance -= paces

# Maybe move the opponent; if so, return `true`, otherwise return `false`. A
# true `silent` flag allows to omit the message when the opponent doesn't
# move.
#
proc maybeMoveTheOpponent(silent = false): bool =
  if rand(1) == 0: # 50% chances
    moveTheOpponent()
    return true
  else:
    if not silent:
      writeLine(stdout, "Black Bart stands still.")
    return false

proc missedShot(): bool =
  result = rand(1.0) * 10 <= float(distance / 10)

# Handle the opponent's shot and return a flag with the result: if the
# opponent kills the player, return `true`; otherwise return `false`.
#
proc theOpponentFiresAndKills(): bool =
  writeLine(stdout, "Black Bart fires…")
  opponentBullets -= 1
  if missedShot():
    writeLine(stdout, "A miss…")
    case opponentBullets:
    of 3:
      writeLine(stdout, "Whew, were you lucky. That bullet just missed your head.")
    of 2:
      writeLine(stdout, "But Black Bart got you in the right shin.")
    of 1:
      writeLine(stdout, "Though Black Bart got you on the left side of your jaw.")
    of 0:
      writeLine(stdout, "Black Bart must have jerked the trigger.")
    else:
      discard
  else:
    if strategy == "j":
      writeLine(stdout, "That trick just saved yout life. Black Bart's bullet")
      writeLine(stdout, "was stopped by the wood sides of the trough.")
    else:
      writeLine(stdout, "Black Bart shot you right through the heart that time.")
      writeLine(stdout, "You went kickin' with your boots on.")
      return true
  result = false

# Handle the opponent's strategy and return a flag with the result: if the
# opponent runs or kills the player, return `true`; otherwise return `false`.
#
proc theOpponentKillsOrRuns(): bool =
  if distance >= 10 or playerBullets == 0:
    if maybeMoveTheOpponent(silent = true):
      return false
  if opponentBullets > 0:
    return theOpponentFiresAndKills()
  else:
    if playerBullets > 0:
      if rand(1) == 0: # 50% chances
        writeLine(stdout, "Now is your chance, Black Bart is out of bullets.")
      else:
        writeLine(stdout, "Black Bart just hi-tailed it out of town rather than face you")
        writeLine(stdout, "without a loaded gun. You can rest assured that Black Bart")
        writeLine(stdout, "won't ever show his face around this town again.")
        return true
  result = false

proc play() =

  distance = initialDistance
  var wateringTroughs = 0
  playerBullets = initialBullets
  opponentBullets = initialBullets

  block showdown:
    while true:

      writeLine(stdout, "You are now ", distance, " paces apart from Black Bart.")
      printShellsLeft()
      write(stdout, ansiForegroundColorCode(instructionsInk.foreground, instructionsInk.bright))
      writeLine(stdout, "\nStrategies:")
      writeLine(stdout, "  [A]dvance")
      writeLine(stdout, "  [S]tand still")
      writeLine(stdout, "  [F]ire")
      writeLine(stdout, "  [J]ump behind the watering trough")
      writeLine(stdout, "  [G]ive up")
      writeLine(stdout, "  [T]urn tail and run")
      write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))

      strategy = toLower(inputString("What is your strategy? "))

      case strategy:

      of "a": # advance

        while true:
          var paces = inputInt("How many paces do you advance? ")
          if paces < 0:
            writeLine(stdout, "None of this negative stuff, partner, only positive numbers.")
          elif paces > 10:
            writeLine(stdout, "Nobody can walk that fast.")
          else:
            distance -= paces
            break

      of "s": # stand still

        writeLine(stdout, "That move made you a perfect stationary target.")

      of "f": # fire

        if playerBullets == 0:

          writeLine(stdout, "You don't have any bullets left.")

        else:

          playerBullets -= 1
          if missedShot():
            case playerBullets:
            of 2:
              writeLine(stdout, "Grazed Black Bart in the right arm.")
            of 1:
              writeLine(stdout, "He's hit in the left shoulder, forcing him to use his right")
              writeLine(stdout, "hand to shoot with.")
            else:
              discard
            writeLine(stdout, "What a lousy shot.")
            if playerBullets == 0:
              writeLine(stdout, "Nice going, ace, you've run out of bullets.")
              if opponentBullets != 0:
                writeLine(stdout, "Now Black Bart won't shoot until you touch noses.")
                writeLine(stdout, "You better think of something fast (like run).")
          else:
            writeLine(stdout, "What a shot, you got Black Bart right between the eyes.")
            pressAnyKey("\nPress any key to get your reward. ")
            clearScreen()
            getReward()
            break showdown

      of "j": # jump

        if wateringTroughs == maxWateringTroughs:
          writeLine(stdout, "How many watering troughs do you think are on this street?")
          strategy = ""
        else:
          wateringTroughs += 1
          writeLine(stdout, "You jump behind the watering trough.")
          writeLine(stdout, "Not a bad maneuver to threw Black Bart's strategy off.")

      of "g": # give up

        writeLine(stdout, "Black Bart accepts. The conditions are that he won't shoot you")
        writeLine(stdout, "if you take the first stage out of town and never come back.")
        if yes("Agreed? "):
          writeLine(stdout, "A very wise decision.")
          break showdown
        else:
          writeLine(stdout, "Oh well, back to the showdown.")

      of "t": # turn tail and run

        # The more bullets of the opponent, the less chances to escape.
        if rand(opponentBullets + 2 - 1) == 0:
          writeLine(stdout, "Man, you ran so fast even dogs couldn't catch you.")
        else:
          case opponentBullets:
          of 0:
            writeLine(stdout, "You were lucky, Black Bart can only throw his gun at you, he")
            writeLine(stdout, "doesn't have any bullets left. You should really be dead.")
          of 1:
            writeLine(stdout, "Black Bart fires his last bullet…")
            writeLine(stdout, "He got you right in the back. That's what you deserve, for running.")
          of 2:
            writeLine(stdout, "Black Bart fires and got you twice: in your back")
            writeLine(stdout, "and your ass. Now you can't even rest in peace.")
          of 3:
            writeLine(stdout, "Black Bart unloads his gun, once in your back")
            writeLine(stdout, "and twice in your ass. Now you can't even rest in peace.")
          of 4:
            writeLine(stdout, "Black Bart unloads his gun, once in your back")
            writeLine(stdout, "and three times in your ass. Now you can't even rest in peace.")
          else:
            discard
          opponentBullets = 0
        break showdown

      else:

        writeLine(stdout, "You sure aren't going to live very long if you can't even follow directions.")

      # end of strategy case

      if theOpponentKillsOrRuns():
        break

      if playerBullets + opponentBullets == 0:
        writeLine(stdout, "The showdown must end, because nobody has bullets left.")
        break

      writeLine(stdout, "")

  # end of showdown block

# Main {{{1
# =============================================================

randomize()

clearScreen()
printCredits()

pressAnyKey("\nPress any key to read the instructions. ")
clearScreen()
printInstructions()

pressAnyKey("\nPress any key to start. ")
clearScreen()
play()

• Todas las versiones de High Noon

Math

#[
Math

Original version in BASIC:
  Example included in Vintage BASIC 1.0.3.
  http://www.vintage-basic.net

This version in Nim:
  Copyright (c) 2023, 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2023-08-26, 2025-01-20.

Last modified: 20250731T1954+0200.
]#

import std/math
import std/strutils

var n: float
while true:
  try:
    write(stdout, "Enter a number: ")
    n = parseFloat(readLine(stdin))
    break
  except ValueError:
    writeLine(stdout, "Real number expected.")

echo "ABS(", n, ") = abs(", n, ") = ", abs(n)
echo "ATN(", n, ") = arctan(", n, ") = ", arctan(n)
echo "COS(", n, ") = cos(", n, ") = ", cos(n)
echo "EXP(", n, ") = exp(", n, ") = ", exp(n)
echo "INT(", n, ") = int(", n, ") = ", int(n)
echo "LOG(", n, ") = log(", n, ", E) = ", log(n, E)
echo "SGN(", n, ") = sgn(", n, ") = ", sgn(n)
echo "SQR(", n, ") = sqrt(", n, ") = ", sqrt(n)
echo "TAN(", n, ") = tan(", n, ") = ", tan(n)

• Todas las versiones de Math

Mugwump

#[
Mugwump

Original version in BASIC:
  Written by Bud Valenti's students of Project SOLO (Pittsburg, Pennsylvania, USA).
  Slightly modified by Bob Albrecht of People's Computer Company.
  Published by Creative Computing (Morristown, New Jersey, USA), 1978.
  - https://www.atariarchives.org/basicgames/showpage.php?page=114
  - http://vintage-basic.net/games.html

This version in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2025-01-20.

Last modified: 20250404T0159+0200.
]#

import std/math
import std/random
import std/strutils
import std/terminal
import std/unicode

proc cursorHome() =
  setCursorPos(0, 0)

proc clearScreen() =
  eraseScreen()
  cursorHome()

const gridSize = 10
const turns = 10
const mugwumps = 4

type Mugwump = tuple[
  x: int,
  y: int,
  hidden: bool,
  ]

var mugwump: array[mugwumps, Mugwump]
var found: int # counter

# Wait until the user enters a string and return it.
#
proc getString(prompt: string): string =
  write(stdout, prompt)
  result = readLine(stdin)

# Print the given prompt, wait until the user enters a valid integer and
# return it.
#
proc getNumber(prompt: string): int =
  var n: int
  while true:
    try:
      write(stdout, prompt)
      n = parseInt(readLine(stdin))
      break
    except ValueError:
      discard
  result = n

# Return `true` if the given string is "yes" or a synonym.
#
proc isYes(s: string): bool  =
  result = toLower(s) in ["ok", "y", "yeah", "yes"]

# Return `true` if the given string is "no" or a synonym.
#
proc isNo(s: string): bool  =
  result = toLower(s) in ["n", "no", "nope"]

# Print the given prompt, wait until the user enters a valid yes/no string,
# and return `true` for "yes" or `false` for "no".
#
proc yes(prompt: string): bool =
  while true:
    var answer = getString(prompt)
    if isYes(answer):
        return true
    if isNo(answer):
        return false

# Return a plural ending (default: "s") if the given number is greater than 1;
# otherwise return a singular ending (default: an empty string).
#
proc plural(n: int, plural = "s", singular = ""): string =
  result = if n > 1: plural else: singular

# Clear the screen, print the credits and ask the user to press enter.
#
proc printCredits() =
  clearScreen()
  writeLine(stdout, "Mugwump\n")
  writeLine(stdout, "Original version in BASIC:")
  writeLine(stdout, "    Written by Bud Valenti's students of Project SOLO (Pittsburg, Pennsylvania, USA).")
  writeLine(stdout, "    Slightly modified by Bob Albrecht of People's Computer Company.")
  writeLine(stdout, "    Published by Creative Computing (Morristown, New Jersey, USA), 1978.")
  writeLine(stdout, "    - https://www.atariarchives.org/basicgames/showpage.php?page=114")
  writeLine(stdout, "    - http://vintage-basic.net/games.html\n")
  writeLine(stdout, "This version in Nim:")
  writeLine(stdout, "    Copyright (c) 2025, Marcos Cruz (programandala.net)")
  writeLine(stdout, "    SPDX-License-Identifier: Fair")
  write(stdout, "\nPress Enter to read the instructions. ")
  discard readLine(stdin)

# Clear the screen, print the instructions and ask the user to press enter.
#
proc printInstructions() =
  clearScreen()
  writeLine(stdout, "Mugwump\n")
  writeLine(stdout, "The object of this game is to find four mugwumps")
  writeLine(stdout, "hidden on a 10 by 10 grid.  Homebase is position 0,0.")
  writeLine(stdout, "Any guess you make must be two numbers with each")
  writeLine(stdout, "number between 0 and 9, inclusive.  First number")
  writeLine(stdout, "is distance to right of homebase and second number")
  writeLine(stdout, "is distance above homebase.\n")
  var tries: string = plural(turns, "tries", "try")
  writeLine(stdout, "You get ", turns, " ", tries, ".  After each try, you will see")
  writeLine(stdout, "how far you are from each mugwump.")
  write(stdout, "\nPress Enter to start. ")
  discard readLine(stdin)

# Init the mugwumps' positions, `hidden` flags and count.
#
proc hideMugwumps() =
  for m in 0 ..< mugwumps:
    mugwump[m].x = rand(gridSize - 1)
    mugwump[m].y = rand(gridSize - 1)
    mugwump[m].hidden = true
  found = 0 # counter

# Print the given prompt, wait until the user enters a valid coord and return
# it.
#
proc getCoord(prompt: string): int =
  while true:
    result = getNumber(prompt)
    if result < 0 or result >= gridSize:
      writeLine(stdout, "Invalid value ", result, ": not in range [0, ", gridSize - 1, "].")
    else:
      break

# Return `true` if the given mugwump is hidden in the given coords.
#
proc isHere(m: int, x: int, y: int): bool =
  result = mugwump[m].hidden and mugwump[m].x == x and mugwump[m].y == y

# Return the distance between the given mugwump and the given coords.
#
proc distance(m: int, x: int, y: int): int =
  result = int(sqrt(
    pow(float(mugwump[m].x - x), 2) +
    pow(float(mugwump[m].y - y), 2)))

# Run the game.
#
proc play() =
  var x: int
  var y: int
  var turn: int # counter
  while true: # game
    clearScreen()
    hideMugwumps()
    block playing:
      for turn in 1 ..< turns:
        writeLine(stdout, "Turn number ", turn, "\n")
        writeLine(stdout, "What is your guess (in range [0, ", gridSize - 1, "])?")
        x = getCoord("Distance right of homebase (x-axis): ")
        y = getCoord("Distance above homebase (y-axis): ")
        writeLine(stdout, "\nYour guess is (", x, ", ", y, ").")
        for m in 0 ..< mugwumps:
          if isHere(m, x, y):
            mugwump[m].hidden = false
            found += 1
            writeLine(stdout, "You have found mugwump ", m, "!")
            if found == mugwumps:
              break playing
        for m in 0 ..< mugwumps:
          if mugwump[m].hidden:
            writeLine(stdout, "You are ", distance(m, x, y), " units from mugwump ", m, ".")
        writeLine(stdout, "")
    if found == mugwumps:
      writeLine(stdout, "\nYou got them all in ", turn, " turn", plural(turn), "!")
      writeLine(stdout, "\nThat was fun! let's play again…")
      writeLine(stdout, "Four more mugwumps are now in hiding.")
    else:
      var tries: string = plural(turns, "tries", "try")
      writeLine(stdout, "\nSorry, that's ", turns, " ", tries, ".")
      writeLine(stdout, "\nHere is where they're hiding:")
      for m in 0 ..< mugwumps:
        if mugwump[m].hidden:
          writeLine(stdout, "Mugwump ", m, " is at (", mugwump[m].x, ", ", mugwump[m].y, ").")
    writeLine(stdout, "")
    if not yes("Do you want to play again? "):
      break

printCredits()
printInstructions()
play()

• Todas las versiones de Mugwump

Name

#[
Name

Original version in BASIC:
  Example included in Vintage BASIC 1.0.3.
  http://www.vintage-basic.net

This version in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written in 2025-01-16.

Last modified: 20250404T0158+0200.
]#

import std/strutils

proc main() =

  write(stdout, "What is your name? ")
  let name = readLine(stdin)

  var number: int
  while true:
    write(stdout, "Enter a number: ")
    try:
      number = parseInt(readLine(stdin))
      if number >= 0:
        break
      writeLine(stdout, "Positive integer expected.")
    except:
      writeLine(stdout, "Integer expected.")

  for _ in 1 .. number:
    writeLine(stdout, "Hello, ", name)

main()

• Todas las versiones de Name

Poetry

#[
Poetry

Original version in BASIC:
  Unknown author.
  Modified and reworked by Jim Bailey, Peggy Ewing, and Dave Ahl at DEC.
  Published in "BASIC Computer Games", Creative Computing (Morristown, New Jersey, USA), 1978.
  https://archive.org/details/Basic_Computer_Games_Microcomputer_Edition_1978_Creative_Computing
  https://github.com/chaosotter/basic-games/tree/master/games/BASIC%20Computer%20Games/Poetry
  http://vintage-basic.net/games.html

This remake in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2025-01-16.

Last modified: 20250121T0253+0100.
]#

import os
import std/random
import std/terminal

const inputInk =  fgGreen
const titleInk = fgRed

proc cursorHome() =
  setCursorPos 0, 0

proc clearScreen() =
  eraseScreen()
  cursorHome()

proc pressAnyKey() =
  setForegroundColor(inputInk)
  write(stdout, "\nPress any Enter key to start. ")
  setForegroundColor(fgDefault)
  discard getch()

proc printCredits() =

  setForegroundColor(titleInk)
  writeLine(stdout, "Poetry")
  setForegroundColor(fgDefault)

  writeLine(stdout, "\nOriginal version in BASIC:")
  writeLine(stdout, "    Unknown author.")
  writeLine(stdout, "    Published in \"BASIC Computer Games\",")
  writeLine(stdout, "    Creative Computing (Morristown, New Jersey, USA), 1978.\n")

  writeLine(stdout, "This improved remake in Nim:")
  writeLine(stdout, "    Copyright (c) 2025, Marcos Cruz (programandala.net)")
  writeLine(stdout, "    SPDX-License-Identifier: Fair")

proc isEven(x: int): bool =
  return x mod 2 == 0

const MAXPHRASESANDVERSES = 20

# counters:
var action = 0
var phrase = 0
var phrasesAndVerses = 0
var verseChunks = 0

proc verse() =

  var manageTheVerseContinuation = true
  var maybeAddComma = true

  case action
  of 0, 1:
      case phrase:
      of 0: write(stdout, "MIDNIGHT DREARY")
      of 1: write(stdout, "FIERY EYES")
      of 2: write(stdout, "BIRD OR FIEND")
      of 3: write(stdout, "THING OF EVIL")
      of 4: write(stdout, "PROPHET")
      else: discard
  of 2:
      case phrase:
      of 0:
        write(stdout, "BEGUILING ME")
        verseChunks = 2
      of 1:
        write(stdout, "THRILLED ME")
      of 2:
        write(stdout, "STILL SITTING…")
        maybeAddComma = false
      of 3:
        write(stdout, "NEVER FLITTING")
        verseChunks = 2
      of 4:
        write(stdout, "BURNED")
      else:
        discard
  of 3:
      case phrase:
      of 0:
        write(stdout, "AND MY SOUL")
      of 1:
        write(stdout, "DARKNESS THERE")
      of 2:
        write(stdout, "SHALL BE LIFTED")
      of 3:
        write(stdout, "QUOTH THE RAVEN")
      of 4:
        if verseChunks != 0:
          write(stdout, "SIGN OF PARTING")
      else:
        discard
  of 4:
      case phrase:
      of 0: write(stdout, "NOTHING MORE")
      of 1: write(stdout, "YET AGAIN")
      of 2: write(stdout, "SLOWLY CREEPING")
      of 3: write(stdout, "…EVERMORE")
      of 4: write(stdout, "NEVERMORE")
      else: discard
  of 5:
      action = 0
      writeLine(stdout, "")
      if phrasesAndVerses > MAXPHRASESANDVERSES:
        writeLine(stdout, "")
        verseChunks = 0
        phrasesAndVerses = 0
        action = 2
        return
      else:
        manageTheVerseContinuation = false
  else: discard

  if manageTheVerseContinuation:

    sleep(250) # ms

    if maybeAddComma and not (verseChunks == 0 or rand(1.0) > 0.19):
      write(stdout, ",")
      verseChunks = 2

    if rand(1.0) > 0.65:
      writeLine(stdout, "")
      verseChunks = 0
    else:
      write(stdout, " ")
      verseChunks += 1

  action += 1
  phrase = rand(5)
  phrasesAndVerses += 1

  if not (verseChunks > 0 or isEven(action)):
    write(stdout, "     ")

proc play() =
  while true:
    verse()

clearScreen()
printCredits()
pressAnyKey()
clearScreen()
play()

• Todas las versiones de Poetry

Russian Roulette

# Russian Roulette
# 
# Original version in BASIC:
#   Creative Computing (Morristown, New Jersey, USA), ca. 1980.
# 
# This version in Nim:
#   Copyright (c) 2023, Marcos Cruz (programandala.net)
#   SPDX-License-Identifier: Fair
#
# Written in 2023-09-14/17.
#
# Last modified: 20250405T0304+0200.

import std/random
import std/terminal

proc cursorHome() =
  setCursorPos 0, 0

proc clearScreen() =
  eraseScreen()
  cursorHome()

# Prompt the user to enter a command and return it.
proc command(prompt: string = "> "): char =
  write stdout, prompt
  return getch()

proc pressAnyKeyToStart() =
  write stdout, "Press any key to start. "
  discard getch()

proc printCredits =
  echo "Russian Roulette\n"
  echo "Original version in BASIC:"
  echo "    Creative Computing (Morristown, New Jersey, USA), ca. 1980.\n"
  echo "This version in Nim:"
  echo "    Copyright (c) 2023, Marcos Cruz (programandala.net)"
  echo "    SPDX-License-Identifier: Fair\n"
  pressAnyKeyToStart()

proc printInstructions =
  echo "Here is a revolver."
  echo "Press 'f' to spin chamber and pull trigger."
  echo "Press 'g' to give up, and play again."
  echo "Press 'q' to quit.\n"

proc play: bool =
  random.randomize()
  while true: # game loop
    clearScreen()
    printInstructions()
    var times = 0
    while true: # play loop
      case command():
      of 'f': # fire
        if random.rand(100) > 83:
          echo "Bang! You're dead!"
          echo "Condolences will be sent to your relatives."
          break # next game
        else:
          times += 1
          if times > 10:
            echo "You win!"
            echo "Let someone else blow his brains out."
            break # next game
          else:
            echo "Click."
      of 'g': # give up
        echo "Chicken!"
        break # next game
      of 'q': # quit
        return false
      else:
        echo "Invalid key."
        printInstructions()
        continue
    pressAnyKeyToStart()

clearScreen()
printCredits()
discard play()
echo "Bye!"

• Todas las versiones de Russian Roulette

Seance

#[
Seance

Original version in BASIC:
  By Chris Oxlade, 1983.
  https://archive.org/details/seance.qb64
  https://github.com/chaosotter/basic-games

This version in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2025-01-21.

Last modified: 20250121T1531+0100.
]#

import os
import std/math
import std/random
import std/strutils
import std/terminal
import std/unicode

proc cursorHome() =
  setCursorPos(0, 0)

proc clearScreen() =
  eraseScreen()
  cursorHome()

const maxScore = 50

const maxMessageLength = 6
const minMessageLength = 3

const baseCharacter = int('@')
const planchette = '*'

const firstLetterNumber = 1
const lastLetterNumber = 26

type Ink = tuple [
  foreground: ForegroundColor,
  bright: bool,
  ]

const boardInk: Ink = (fgCyan, true)
const defaultInk: Ink = (fgWhite, false)
const inputInk: Ink = (fgGreen, true)
const instructionsInk: Ink = (fgYellow, false)
const mistakeEffectInk: Ink = (fgRed, false)
const planchetteInk: Ink = (fgYellow, false)
const titleInk: Ink = (fgRed, false)

const mistakeEffectPause = 3 # seconds

const boardX = 29 # screen column
const boardY = 5 # screen line
const boardWidth = 8 # characters displayed on the top and bottom borders
const boardHeight = 5 # characters displayed on the left and right borders
const boardPad = 1 # blank characters separating the board from its left and right borders

const boardBottomY = boardHeight + 1 # relative to the board
const boardActualWidth = boardWidth + 2 * boardPad # screen columns

const inputX = boardX
const inputY = boardY + boardBottomY + 4

const messagesY = inputY

# Print the given prompt and wait until the user enters a string.
#
proc input(prompt: string = ""): string =
  write(stdout, ansiForegroundColorCode(inputInk.foreground, inputInk.bright))
  defer: write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))
  write(stdout, prompt)
  result = readLine(stdin)

# Print the given prompt and wait until the user presses Enter.
#
proc pressEnter(prompt: string) =
  discard input(prompt)

# Return the x coordinate to print the given text centered on the board.
#
proc boardCenteredX(text: string): int =
  result = boardX + int((boardActualWidth - len(text)) / 2)

# Print the given text on the given row, centered on the board.
#
proc printBoardCentered(text: string, y: int) =
  setCursorPos(boardCenteredX(text), y)
  writeLine(stdout, text)

const title = "Seance"

# Print the title at the current cursor position.
#
proc printTitle() =
  write(stdout, ansiForegroundColorCode(titleInk.foreground, titleInk.bright))
  writeLine(stdout, title)
  write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))

# Print the title on the given row, centered on the board.
#
proc printBoardCenteredTitle(y: int) =
  write(stdout, ansiForegroundColorCode(titleInk.foreground, titleInk.bright))
  printBoardCentered(title, y)
  write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))

proc printCredits() =
  printTitle()
  writeLine(stdout, "\nOriginal version in BASIC:")
  writeLine(stdout, "    Written by Chris Oxlade, 1983.")
  writeLine(stdout, "    https://archive.org/details/seance.qb64")
  writeLine(stdout, "    https://github.com/chaosotter/basic-games")
  writeLine(stdout, "This version in Nim:")
  writeLine(stdout, "    Copyright (c) 2025, Marcos Cruz (programandala.net)")
  writeLine(stdout, "    SPDX-License-Identifier: Fair")

proc printInstructions() =
  printTitle()
  write(stdout, ansiForegroundColorCode(instructionsInk.foreground, instructionsInk.bright))
  defer: write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))
  writeLine(stdout, "\nMessages from the Spirits are coming through, letter by letter.  They want you")
  writeLine(stdout, "to remember the letters and type them into the computer in the correct order.")
  writeLine(stdout, "If you make mistakes, they will be angry -- very angry...")
  writeLine(stdout, "")
  writeLine(stdout, "Watch for stars on your screen -- they show the letters in the Spirits'")
  writeLine(stdout, "messages.")

# Print the given letter at the given board coordinates.
#
proc printCharacter(y, x: int, a: char) =
  setCursorPos(x + boardX, y + boardY)
  writeLine(stdout, a)

proc printBoard() =
  write(stdout, ansiForegroundColorCode(boardInk.foreground, boardInk.bright))
  defer: write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))
  for i in 1 .. boardWidth:
    printCharacter(0, i + 1, char(baseCharacter + i)) # top border
    printCharacter(boardBottomY, i + 1, char(baseCharacter + lastLetterNumber - boardHeight - i + 1)) # bottom border
  for i in 1 .. boardHeight:
    printCharacter(i , 0, char(baseCharacter + lastLetterNumber - i + 1)) # left border
    printCharacter(i , 3 + boardWidth, char(baseCharacter + boardWidth + i)) # right border
  writeLine(stdout, "")

proc eraseLineRight() =
  write(stdout, "\e[K")

# Erase the given line to the right of the given column.
#
proc eraseLineRightFrom(line, column: int) =
  setCursorPos(column, line)
  eraseLineRight()

# Wait the given number of seconds.
#
proc waitSeconds(seconds: int) =
  sleep(seconds * 1000)

# Print the given mistake effect, wait a configured number of seconds and
# finally erase it.
#
proc printMistakeEffect(effect: string) =
  var x = boardCenteredX(effect)
  hideCursor()
  setCursorPos(x, messagesY)
  write(stdout, ansiForegroundColorCode(mistakeEffectInk.foreground, mistakeEffectInk.bright))
  writeLine(stdout, effect)
  defer: write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))
  waitSeconds(mistakeEffectPause)
  eraseLineRightFrom(messagesY, x)
  showCursor()

# Return a new message of the given length, after marking its letters on the
# board.
#
proc message(length: int): string =

  var y: int
  var x: int
  var message = ""
  hideCursor()

  for _ in 1 .. length:
    var letterNumber = rand(firstLetterNumber .. lastLetterNumber)
    var letter = char(baseCharacter + letterNumber)
    message = message & letter
    if letterNumber <= boardWidth:
      # top border
      y = 1
      x = letterNumber + 1
    elif letterNumber <= boardWidth + boardHeight:
      # right border
      y = letterNumber - boardWidth
      x = 2 + boardWidth
    elif letterNumber <= boardWidth + boardHeight + boardWidth:
      # bottom border
      y = boardBottomY - 1
      x = 2 + boardWidth + boardHeight + boardWidth - letterNumber
    else:
      # left border
      y = 1 + lastLetterNumber - letterNumber
      x = 1
    write(stdout, ansiForegroundColorCode(planchetteInk.foreground, planchetteInk.bright))
    printCharacter(y, x, planchette)
    write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))
    waitSeconds(1)
    printCharacter(y, x, ' ')

  showCursor()
  result = message

# Accept a string from the user, erase it from the screen and return it.
#
proc messageUnderstood(): string =
  setCursorPos(inputX, inputY)
  defer: eraseLineRightFrom(inputY, inputX)
  result = toUpper(input("? "))

proc play() =

  var score = 0
  var mistakes = 0
  printBoardCenteredTitle(1)
  printBoard()

  while true:
    var messageLength = rand(minMessageLength .. maxMessageLength)
    if message(messageLength) != messageUnderstood():
      mistakes += 1
      case mistakes:
      of 1:
        printMistakeEffect("The table begins to shake!")
      of 2:
        printMistakeEffect("The light bulb shatters!")
      of 3:
        printMistakeEffect("Oh, no!  A pair of clammy hands grasps your neck!")
        return
      else:
        discard
    else:
      score += messageLength
      if score >= maxScore:
        printBoardCentered("Whew!  The spirits have gone!", messagesY)
        printBoardCentered("You live to face another day!", messagesY + 1)
        return

randomize()

write(stdout, ansiForegroundColorCode(defaultInk.foreground, defaultInk.bright))
clearScreen()
printCredits()

pressEnter("\nPress the Enter key to read the instructions. ")
clearScreen()
printInstructions()

pressEnter("\nPress the Enter key to start. ")
clearScreen()
play()
writeLine(stdout, "\n")

• Todas las versiones de Seance

Sine Wave

#[
Sine Wave

Original version in BASIC:
  Creative Computing (Morristown, New Jersey, USA), ca. 1980.

This version in Nim:
  Copyright (c) 2023, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written in 2023-01, 2023-08, 2023-09.

Last modified: 20250405T0304+0200.
]#

import std/math
import std/strutils
import std/terminal

proc cursorHome() =
  setCursorPos 0, 0

proc clearScreen() =
  eraseScreen()
  cursorHome()

proc showCredits() =
  echo "Sine Wave\n"
  echo "Original version in BASIC:"
  echo "    Creative computing (Morristown, New Jersey, USA), ca. 1980.\n"
  echo "This version in Nim:"
  echo "    Copyright (c) 2023, Marcos Cruz (programandala.net)"
  echo "    SPDX-License-Identifier: Fair\n"
  echo "Press any key to start the program."
  discard getch()

var word: array[2, string] = ["", ""]

proc getWords() =
  for i in 0 .. 1:
    while word[i] == "":
      write(stdout, "Enter the ", if (i == 0 ): "first" else: "second", " word: ")
      word[i] = strip(readLine(stdin))

proc draw() =
  var even = false
  var angle = 0.0
  while angle <= 40.0:
    write(stdout, repeat(' ', int(26 + 25 * sin(angle))))
    echo word[ord(even)]
    even = not even
    angle += 0.25

clearScreen()
showCredits()
clearScreen()
getWords()
clearScreen()
draw()

• Todas las versiones de Sine Wave
• Tamaño del ejecutable de Sine Wave

Slots

#[
Slots
  A slot machine simulation.

Original version in BASIC:
  Creative Computing (Morristown, New Jersey, USA).
  Produced by Fred Mirabelle and Bob Harper on 1973-01-29.

This version in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2025-01-21.

Last modified: 20250404T0159+0200.
]#

import std/monotimes
import std/random
import std/sequtils
import std/strutils
import std/terminal
import std/times
import std/unicode

const reels = 3
const images = 6
const image: array[images, string] = [" BAR  ", " BELL ", "ORANGE", "LEMON ", " PLUM ", "CHERRY"]
const bar = 0 # position of "BAR" in `image`.
const colors = images

type ImageColor = tuple [
  foreground: ForegroundColor,
  bright: bool,
  ]

var color: array[colors, ImageColor] = [
  (fgWhite, false),
  (fgCyan, false),
  (fgYellow, false),
  (fgYellow, true),
  (fgWhite, true),
  (fgRed, true),
  ]

const maxBet = 100
const minBet = 1

proc cursorHome() =
  setCursorPos(0, 0)

proc clearScreen() =
  eraseScreen()
  cursorHome()

proc pressEnter(prompt: string) =
  write(stdout, prompt)
  discard readLine(stdin)

proc printCredits() =
  clearScreen()
  writeLine(stdout, "Slots")
  writeLine(stdout, "A slot machine simulation.\n")
  writeLine(stdout, "Original version in BASIC:")
  writeLine(stdout, "    Creative computing (Morristown, New Jersey, USA).")
  writeLine(stdout, "    Produced by Fred Mirabelle and Bob Harper on 1973-01-29.\n")
  writeLine(stdout, "This version in Nim:")
  writeLine(stdout, "    Copyright (c) 2025, Marcos Cruz (programandala.net)")
  writeLine(stdout, "    SPDX-License-Identifier: Fair\n")
  pressEnter("Press Enter for instructions.")

proc printInstructions() =
  clearScreen()
  writeLine(stdout, "You are in the H&M casino, in front of one of our")
  write(stdout, "one-arm bandits. Bet from ", minBet, " to ", maxBet, " USD (or 0 to quit).\n\n")
  pressEnter("Press Enter to start.")

proc won(prize: int, bet: int): int =
  case prize:
  of   2: writeLine(stdout, "DOUBLE!")
  of   5: writeLine(stdout, "*DOUBLE BAR*")
  of  10: writeLine(stdout, "**TOP DOLLAR**")
  of 100: writeLine(stdout, "***JACKPOT***")
  else: discard
  writeLine(stdout, "You won!")
  result = (prize + 1) * bet

proc showStandings(usd: int) =
  writeLine(stdout, "Your standings are ", usd, " USD.")

proc printReels(reel: array[reels, int]) =
  cursorHome()
  for r in reel:
    write(stdout, ansiForegroundColorCode(color[r].foreground, color[r].bright))
    write(stdout, "[", image[r], "] ")
  resetAttributes(stdout)
  writeLine(stdout, "")

proc initReels(reel: var array[reels, int]) =
  for i in 0 ..< reels:
    reel[i] = rand(0 ..< images)

proc spinReels(reel: var array[reels, int]) =
  const milliseconds = 1500
  hideCursor()
  var start = getMonoTime()
  while inMilliseconds(getMonoTime() - start) < milliseconds:
    initReels(reel)
    printReels(reel)
  showCursor()

# Return the number of equals and bars in the given `reel` array.
#
proc prize(reel: array[reels, int]): (int, int) =
  var equals = reels - len(deduplicate(reel, isSorted = false))
  equals += int(equals > 0)
  var bars = count(reel, bar)
  result = (equals, bars)

proc readIntOrZero(prompt: string): int =
  while true:
    try:
      write(stdout, prompt)
      result = parseInt(readLine(stdin))
      break
    except ValueError:
      result = 0

proc play() =

  var standings = 0
  var bet = 0
  var reel: array[reels, int] = [1, 2, 3]
  var equals = 0
  var bars = 0

  initReels(reel)

  block playing:
    while true: # play loop

      while true: # bet loop

        clearScreen()
        printReels(reel)
        bet = readIntOrZero("Your bet (or 0 to quit): ")

        if bet > maxBet:
            writeLine(stdout, "House limits are ", maxBet, " USD.")
            pressEnter("Press Enter to try again.")
        elif bet < minBet:
            writeLine(stdout, "Type \"q\" to confirm you want to quit.")
            if toLower(readLine(stdin)) == "q":
              break playing
        else:
            break # bet loop

        # end of bet check

      clearScreen()
      spinReels(reel)
      (equals, bars) = prize(reel)
      case equals:
      of 3:
          if bars == 3:
            standings += won(100, bet)
          else:
            standings += won(10, bet)
      of 2:
          if bars == 2:
            standings += won(5, bet)
          else:
            standings += won(2, bet)
      else:
          writeLine(stdout, "You lost.")
          standings -= bet
      showStandings(standings)
      pressEnter("Press Enter to continue.")

      # end of bet loop

    # end of play loop

  # end of play block

  showStandings(standings)
  if standings < 0:
      writeLine(stdout, "Pay up!  Please leave your money on the terminal.")
  elif standings == 0:
      writeLine(stdout, "Hey, you broke even.")
  else:
      writeLine(stdout, "Collect your winnings from the H&M cashier.")

printCredits()
printInstructions()
play()

• Todas las versiones de Slots

Stars

#[
Stars

Original version in BASIC:
  Example included in Vintage BASIC 1.0.3.
  http://www.vintage-basic.net

This version in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2025-01-16.

Last modified: 20250404T0159+0200.
]#

import std/strutils
import std/unicode

proc main() =

  write(stdout, "What is your name? ")
  let name = readLine(stdin)
  writeLine(stdout, "Hello, ", name, ".")

  while true:
    var number: int
    while true:
      write(stdout, "How many stars do you want? ")
      try:
        number = parseInt(readLine(stdin))
        if number >= 0:
          break
        writeLine(stdout, "Positive integer expected.")
      except:
        writeLine(stdout, "Integer expected.")
    writeLine(stdout, repeat('*', number))
    write(stdout, "Do you want more stars? ")
    case toLower(readLine(stdin)):
    of "ok", "yeah", "yes", "y":
      discard
    else:
      break

main()

• Todas las versiones de Stars

Strings

#[
Strings

Original version in BASIC:
  Example included in Vintage BASIC 1.0.3.
  http://www.vintage-basic.net

This version in Nim:
  Copyright (c) 2023, 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written on 2023-08-27, 2025-01-20.

Last modified: 20250405T0304+0200.
]#

import std/strutils

write(stdout, "Enter a string: ")
let s = readLine(stdin)

var n: int
while true:
  try:
    write(stdout, "Enter a number: ")
    n = parseInt(readLine(stdin))
    break
  except ValueError:
    writeLine(stdout, "Integer expected.")

echo ""

echo "ASC(\"", s, "\") --> int(char(", s, "[0])) --> ", int(char(s[0]))
echo "CHR$(", n, ") --> char(", n, ") --> '", char(n), "'"
echo "LEFT$(\"", s, "\", ", n, ") --> \"", s, "\"[0 ..< ", n, "] --> ", s[0 ..< n]
echo "MID$(\"", s, "\", ", n, ") --> \"", s, "\"[", n, "-1 .. ^1] --> ", s[n-1 .. ^1]
echo "MID$(\"", s, "\", ", n, ", 3) --> \"", s, "\"[", n, "-1 ..< ", n, "+3-1] --> ", s[n-1 ..< n+3-1]
echo "RIGHT$(\"", s, "\", ", n, ") --> \"", s, "\"[^", n, " .. ^1] --> ", s[^n .. ^1]
echo "LEN(\"", s, "\") --> \"", s, "\".len --> ",s.len
echo "VAL(\"", s, "\") --> (try: parseInt(\"", s, "\") except: 0) --> ", (try: parseInt(s) except: 0)
echo "STR$(", n, ") --> $", n, " --> \"", $n, "\""
echo "SPC(", n, ") --> strutils.repeat(' ', ", n, ") --> \"", strutils.repeat(' ',n), "\""

• Todas las versiones de Strings

Xchange

#[
Xchange

Original version in BASIC:
  Written by Thomas C. McIntire, 1979.
  Published in "The A to Z Book of Computer Games", 1979.
  https://archive.org/details/The_A_to_Z_Book_of_Computer_Games/page/n269/mode/2up
  https://github.com/chaosotter/basic-games

This improved remake in Nim:
  Copyright (c) 2025, Marcos Cruz (programandala.net)
  SPDX-License-Identifier: Fair

Written in 2025-01-21/22.

Last modified: 20250405T0304+0200.
]#

import std/strformat
import std/random
import std/strutils
import std/terminal
import std/unicode

# Terminal {{{1
# =============================================================

proc cursorHome() =
  setCursorPos(0, 0)

proc clearScreen() =
  eraseScreen()
  cursorHome()

proc eraseLineRight() =
  write(stdout, "\e[K")

proc eraseDown() =
  # Erases the screen from the current line down to the bottom of the screen.
  #
  # This is defined in std/terminal but deactivated, because it does not have
  # equivalent in Windows.
  write(stdout, "\e[J")

const black = 0
const red = 1
const green = 2
const yellow = 3
const blue = 4
const magenta = 5
const cyan = 6
const white = 7
const default = 9

const foreground = +30 # color offset
const background = +40 # color offset
const bright = +60 # foreground and background offset

const normal = 0
const bold = 1 # bold text (or bright on terminals not supporting)
const dim = 2 # dim text
const italic = 3 # italic (or reverse on terminals not supporting)
const underlined = 4
const blinking = 5 # blinking/bold text
const rapidBlinking = 6 # rapid blinking/bold text (not widely supported)
const reversed = 7
const hidden = 8
const crossedout = 9 # strikethrough

const styleOff = +20 # style offset to turn it off

const notBold = 21 # or double underlined on some terminals
const notDim = 22
const notItalic = 23
const notUnderlined = 24
const notBlinking = 25
const notReversed = 27
const notHidden = 28
const notCrossedout = 29

proc ansiStyleCode(fg: int = default, bg: int = default, style: int = normal): string =
  result = &"\e[0;{style};{fg + foreground};{bg + background}m"

proc setStyle(style: string) =
  write(stdout, style)

proc setStyles(fg: int = default, bg: int = default, style: int = normal) =
  setStyle(ansiStyleCode(fg, bg, style))

# Globals {{{1
# =============================================================

const boardStyle = ansiStyleCode(cyan + bright)
const defaultStyle = ansiStyleCode(default, default, normal)
const inputStyle = ansiStyleCode(green + bright)
const instructionsStyle = ansiStyleCode(yellow)
const titleStyle = ansiStyleCode(red)

const blank = "*"

const gridHeight = 3 # cell rows
const gridWidth = 3 # cell columns

const cells = gridWidth * gridHeight

var pristineGrid: array[cells, string]

const gridsRow = 3 # screen row where the grids are printed
const gridsColumn = 5 # screen column where the left grid is printed
const cellsGap = 2 # distance between the grid cells, in screen rows or columns
const gridsGap = 16 # screen columns between equivalent cells of the grids

const maxPlayers = 4

var grid: array[maxPlayers, array[cells, string]]

var isPlaying: array[maxPlayers, bool]

var players: int

const quitCommand = "X"

# User input {{{1
# =============================================================

# Print the given prompt and return the integer entered by the
# user; if the user input is not a valid integer, return a zero
# instead.
#
proc inputInt(prompt: string): int =
  setStyle(inputStyle)
  defer: setStyle(defaultStyle)
  while true:
    try:
      write(stdout, prompt)
      result = parseInt(readLine(stdin))
      break
    except ValueError:
      result = 0

# Print the given prompt and wait until the user enters a string.
#
proc inputString(prompt: string = ""): string =
  setStyle(inputStyle)
  defer: setStyle(defaultStyle)
  write(stdout, prompt)
  result = readLine(stdin)

# Print the given prompt and wait until the user presses Enter.
#
proc pressEnter(prompt: string) =
  discard inputString(prompt)

# Return `true` if the given string is "yes" or a synonym.
#
proc isYes(s: string): bool  =
  return toLower(s) in ["ok", "y", "yeah", "yes"]

# Return `true` if the given string is "no" or a synonym.
#
proc isNo(s: string): bool  =
  return toLower(s) in ["n", "no", "nope"]

# Print the given prompt, wait until the user enters a valid yes/no string,
# and return `true` for "yes" or `false` for "no".
#
proc yes(prompt: string): bool  =
  while true:
    write(stdout, prompt)
    var answer = readLine(stdin)
    if isYes(answer):
      return true
    if isNo(answer):
      return false

# Title, instructions and credits {{{1
# =============================================================

# Print the title at the current cursor position.
#
proc printTitle() =
  setStyle(titleStyle)
  writeLine(stdout, "Xchange")
  setStyle(defaultStyle)

# Print the credits at the current cursor position.
#
proc printCredits() =
  printTitle()
  writeLine(stdout, "\nOriginal version in BASIC:")
  writeLine(stdout, "    Written by Thomas C. McIntire, 1979.")
  writeLine(stdout, "    Published in \"The A to Z Book of Computer Games\", 1979.")
  writeLine(stdout, "    https://archive.org/details/The_A_to_Z_Book_of_Computer_Games/page/n269/mode/2up")
  writeLine(stdout, "    https://github.com/chaosotter/basic-games")
  writeLine(stdout, "This improved remake in Nim:")
  writeLine(stdout, "    Copyright (c) 2025, Marcos Cruz (programandala.net)")
  writeLine(stdout, "    SPDX-License-Identifier: Fair")

# Print the instructions at the current cursor position.
#
proc printInstructions() =
  printTitle()
  setStyle(instructionsStyle)
  defer: setStyle(defaultStyle)
  writeLine(stdout, "\nOne or two may play.  If two, you take turns.  A grid looks like this:\n")
  setStyle(boardStyle)
  writeLine(stdout, "    F G D")
  writeLine(stdout, "    A H ", blank)
  writeLine(stdout, "    E B C\n")
  setStyle(instructionsStyle)
  writeLine(stdout, "But it should look like this:\n")
  setStyle(boardStyle)
  writeLine(stdout, "    A B C")
  writeLine(stdout, "    D E F")
  writeLine(stdout, "    G H ", blank, "\n")
  setStyle(instructionsStyle)
  writeLine(stdout, "You may exchange any one letter with the '", blank, "', but only one that's adjacent:")
  writeLine(stdout, "above, below, left, or right.  Not all puzzles are possible, and you may enter")
  writeLine(stdout, "'", quitCommand, "' to give up.\n")
  writeLine(stdout, "Here we go...")

# Grids {{{1
# =============================================================

# Print the given player's grid title.
#
proc printGridTitle(player: int) =
  setCursorPos(gridsColumn + (player * gridsGap), gridsRow)
  write(stdout, "Player ", player + 1)

# Return the cursor position of the given player's grid cell.
#
proc cellPosition(player, cell: int): (int, int) =
  let gridRow = int(cell / gridHeight)
  let gridColumn: int = cell mod gridWidth
  let titleMargin = if players > 1: 2 else: 0
  let row = gridsRow + titleMargin + gridRow
  let column = gridsColumn + (gridColumn * cellsGap) + (player * gridsGap)
  result = (column, row)

# Return the cursor position of the given player's grid prompt.
#
proc gridPromptPosition(player: int): (int, int) =
  let gridRow = int(cells / gridHeight)
  let gridColumn = cells mod gridWidth
  let titleMargin = if players > 1: 2 else: 0
  let row = gridsRow + titleMargin + gridRow + 1
  let column = gridsColumn + (gridColumn * cellsGap) + (player * gridsGap)
  result = (column, row)

# Print the given player's grid, in the given or default color.
#
proc printGrid(player: int, color = boardStyle) =
  if players > 1:
    printGridTitle(player)
  setStyle(color)
  defer: setStyle(defaultStyle)
  for cell in 0 ..< cells:
    var (column, row) = cellPosition(player, cell)
    setCursorPos(column, row)
    write(stdout, grid[player][cell])

# Print the current players' grids.
#
proc printGrids() =
  for player in 0 ..< players:
    if isPlaying[player]:
      printGrid(player)
  writeLine(stdout, "")
  eraseDown()

# Scramble the grid of the given player.
#
proc scrambleGrid(player: int) =
  for cell in 0 ..< cells:
    var randomCell = rand(cells - 1)
    var tempCell = grid[player][cell]
    grid[player][cell] = grid[player][randomCell]
    grid[player][randomCell] = tempCell

# Init the grids.
#
proc initGrids() =
  grid[0] = pristineGrid
  scrambleGrid(0)
  for player in 0 + 1 ..< players:
    grid[player] = grid[0]

# Messages {{{1
# =============================================================

# Return a message prefix for the given player.
#
proc playerPrefix(player: int): string =
  result = if players > 1: fmt"Player {player + 1}: " else: ""

# Return the cursor position of the given player's messages, adding the given
# row increment, which defaults to zero.
#
proc messagePosition(player: int, rowInc = 0): (int, int) =
  var (_, promptRow) = gridPromptPosition(player)
  result = (0, promptRow + 2 + rowInc)

# Print the given message about the given player, adding the given row
# increment, which defaults to zero, to the default cursor coordinates.
#
proc printMessage(message: string, player: int, rowInc = 0) =
  var (column, row) = messagePosition(player, rowInc)
  setCursorPos(column, row)
  write(stdout, playerPrefix(player), message)
  eraseLineRight()
  writeLine(stdout, "")

# Erase the last message about the given player.
#
proc eraseMessage(player: int) =
  var (column, row) = messagePosition(player)
  setCursorPos(column, row)
  eraseLineRight()

# Game loop {{{1
# =============================================================

# Return a message with the players range.
#
proc playersRangeMessage(): string =
  if maxPlayers == 2:
    return "1 or 2"
  else:
    return fmt"from 1 to {maxPlayers}"

# Return the number of players, asking the user if needed.
#
proc numberOfPlayers(): int =
  var players = 0
  printTitle()
  writeLine(stdout, "")
  if maxPlayers == 1:
    players = 1
  else:
    while players < 1 or players > maxPlayers:
      players = inputInt(fmt"Number of players ({playersRangeMessage()}): ")
  result = players

# Is the given cell the first one on a grid row?
#
proc isFirstCellOfAGridRow(cell: int): bool =
  result = cell mod gridWidth == 0

# Is the given cell the last one on a grid row?
#
proc isLastCellOfAGridRow(cell: int): bool =
  result = (cell + 1) mod gridWidth == 0

# Are the given cells adjacent?
#
proc areCellsAdjacent(cell_1, cell_2: int): bool =
  if cell_2 == cell_1 + 1 and not isFirstCellOfAGridRow(cell_2):
    return true
  elif cell_2 == cell_1 + gridWidth:
    return true
  elif cell_2 == cell_1 - 1  and not isLastCellOfAGridRow(cell_2):
    return true
  elif cell_2 == cell_1 - gridWidth:
    return true
  result = false

# Is the given player's character cell a valid move, i.e. is it adjacent to
# the blank cell? If so, return the blank cell of the grid and `true`;
# otherwise return a fake cell and `false`.
#
proc isLegalMove(player, charCell: int): (int, bool) =
  const nowhere = -1
  for blankCell, cellContent in grid[player]:
    if cellContent == blank:
      if areCellsAdjacent(charCell, blankCell):
        return (blankCell, true)
      break
  printMessage(&"Illegal move \"{grid[player][charCell]}\".", player)
  result = (nowhere, false)

# Is the given player's command valid, i.e. a grid character? If so, return
# its position in the grid and `true`; otherwise print an error message and
# return a fake position and `false`.
#
proc isValidCommand(player: int, command: string): (int, bool) =
  const nowhere = -1
  if command != blank:
    for position, cellContent in grid[player]:
      if cellContent == command:
        return (position, true)
  printMessage(&"Invalid character \"{command}\".", player)
  result = (nowhere, false)

# Forget the given player, who quitted.
#
proc forgetPlayer(player: int) =
  isPlaying[player] = false
  printGrid(player, defaultStyle)

# Play the turn of the given player.
#
proc playTurn(player: int) =
  var blankPosition: int
  var characterPosition: int

  if isPlaying[player]:

    while true:
      var command: string
      var ok = false
      while not ok:
        var (column, row) = gridPromptPosition(player)
        setCursorPos(column, row)
        eraseLineRight()
        setCursorPos(column, row)
        command = toUpper(strip(inputString("Move: ")))
        if command == quitCommand:
          forgetPlayer(player)
          return
        (characterPosition, ok) = isValidCommand(player, command)
      (blankPosition, ok) = isLegalMove(player, characterPosition)
      if ok:
        break
    eraseMessage(player)
    grid[player][blankPosition] = grid[player][characterPosition]
    grid[player][characterPosition] = blank

# Play the turns of all players.
#
proc playTurns() =
  for player in 0 ..< players:
    playTurn(player)

# Is someone playing?
#
proc isSomeonePlaying(): bool =
  for player in 0 ..< players:
    if isPlaying[player]:
      return true
  result = false

# Has someone won? If so, print a message for every winner and return `true`;
# otherwise just return `false`.
#
proc hasSomeoneWon(): bool =
  var winners = 0
  for player in 0 ..< players:
    if isPlaying[player]:
      if grid[player] == pristineGrid:
        winners += 1
        if winners > 0:
          var too = if winners > 1: ", too" else: ""
          printMessage(
            fmt"You're the winner{too}!",
            player,
            rowInc = winners - 1)
  result = winners > 0

# Init the game.
#
proc initGame() =
  clearScreen()
  players = numberOfPlayers()
  for player in 0 ..< players:
    isPlaying[player] = true
  clearScreen()
  printTitle()
  initGrids()
  printGrids()

# Play the game.
#
proc play() =
  initGame()
  while isSomeonePlaying():
    playTurns()
    printGrids()
    if hasSomeoneWon():
      break

# Main {{{1
# =============================================================

# Init the program, i.e. just once before the first game.
#
proc initOnce() =
  randomize()

 # Init the pristine grid.
  const firstCharCode = int('A')
  for cell in 0 ..< cells - 1:
    pristineGrid[cell] = $char(firstCharCode + cell)
  pristineGrid[cells - 1] = blank

# Return `true` if the player does not want to play another game; otherwise
# return `false`.
#
proc enough(): bool =
  var (column, row) = gridPromptPosition(player = 0)
  setCursorPos(column, row)
  result = not yes("Another game? ")

initOnce()
clearScreen()
printCredits()
pressEnter("\nPress the Enter key to read the instructions. ")
clearScreen()
printInstructions()
pressEnter("\nPress the Enter key to start. ")
while true:
  play()
  if enough():
    break
writeLine(stdout, "So long…")

• Todas las versiones de Xchange

Páginas relacionadas

Basics off

Metaproyecto sobre los proyectos «Basics of…».

Basics of 8th

Conversión de antiguos programas de BASIC a 8th para aprender los rudimentos de este lenguaje.

Basics of Ada

Conversión de antiguos programas de BASIC a Ada para aprender los rudimentos de este lenguaje.

Basics of Arturo

Conversión de antiguos programas de BASIC a Arturo para aprender los rudimentos de este lenguaje.

Basics of C#

Conversión de antiguos programas de BASIC a C# para aprender los rudimentos de este lenguaje.

Basics of C3

Conversión de antiguos programas de BASIC a C3 para aprender los rudimentos de este lenguaje.

Basics of Chapel

Conversión de antiguos programas de BASIC a Chapel para aprender los rudimentos de este lenguaje.

Basics of Clojure

Conversión de antiguos programas de BASIC a Clojure para aprender los rudimentos de este lenguaje.

Basics of Crystal

Conversión de antiguos programas de BASIC a Crystal para aprender los rudimentos de este lenguaje.

Basics of D

Conversión de antiguos programas de BASIC a D para aprender los rudimentos de este lenguaje.

Basics of Elixir

Conversión de antiguos programas de BASIC a Elixir para aprender los rudimentos de este lenguaje.

Basics of F#

Conversión de antiguos programas de BASIC a F# para aprender los rudimentos de este lenguaje.

Basics of Factor

Conversión de antiguos programas de BASIC a Factor para aprender los rudimentos de este lenguaje.

Basics of FreeBASIC

Conversión de antiguos programas de BASIC a FreeBASIC para aprender los rudimentos de este lenguaje.

Basics of Gleam

Conversión de antiguos programas de BASIC a Gleam para aprender los rudimentos de este lenguaje.

Basics of Go

Conversión de antiguos programas de BASIC a Go para aprender los rudimentos de este lenguaje.

Basics of Hare

Conversión de antiguos programas de BASIC a Hare para aprender los rudimentos de este lenguaje.

Basics of Haxe

Conversión de antiguos programas de BASIC a Haxe para aprender los rudimentos de este lenguaje.

Basics of Icon

Conversión de antiguos programas de BASIC a Icon para aprender los rudimentos de este lenguaje.

Basics of Io

Conversión de antiguos programas de BASIC a Io para aprender los rudimentos de este lenguaje.

Basics of Janet

Conversión de antiguos programas de BASIC a Janet para aprender los rudimentos de este lenguaje.

Basics of Julia

Conversión de antiguos programas de BASIC a Julia para aprender los rudimentos de este lenguaje.

Basics of Kotlin

Conversión de antiguos programas de BASIC a Kotlin para aprender los rudimentos de este lenguaje.

Basics of Lobster

Conversión de antiguos programas de BASIC a Lobster para aprender los rudimentos de este lenguaje.

Basics of Lua

Conversión de antiguos programas de BASIC a Lua para aprender los rudimentos de este lenguaje.

Basics of Nature

Conversión de antiguos programas de BASIC a Nature para aprender los rudimentos de este lenguaje.

Basics of Neat

Conversión de antiguos programas de BASIC a Neat para aprender los rudimentos de este lenguaje.

Basics of Neko

Conversión de antiguos programas de BASIC a Neko para aprender los rudimentos de este lenguaje.

Basics of Nelua

Conversión de antiguos programas de BASIC a Nelua para aprender los rudimentos de este lenguaje.

Basics of Nit

Conversión de antiguos programas de BASIC a Nit para aprender los rudimentos de este lenguaje.

Basics of Oberon-07

Conversión de antiguos programas de BASIC a Oberon-07 para aprender los rudimentos de este lenguaje.

Basics of OCaml

Conversión de antiguos programas de BASIC a OCaml para aprender los rudimentos de este lenguaje.

Basics of Odin

Conversión de antiguos programas de BASIC a Odin para aprender los rudimentos de este lenguaje.

Basics of Pike

Conversión de antiguos programas de BASIC a Pike para aprender los rudimentos de este lenguaje.

Basics of Pony

Conversión de antiguos programas de BASIC a Pony para aprender los rudimentos de este lenguaje.

Basics of Python

Conversión de antiguos programas de BASIC a Python para aprender los rudimentos de este lenguaje.

Basics of Racket

Conversión de antiguos programas de BASIC a Racket para aprender los rudimentos de este lenguaje.

Basics of Raku

Conversión de antiguos programas de BASIC a Raku para aprender los rudimentos de este lenguaje.

Basics of Retro

Conversión de antiguos programas de BASIC a Retro para aprender los rudimentos de este lenguaje.

Basics of Rexx

Conversión de antiguos programas de BASIC a Rexx para aprender los rudimentos de este lenguaje.

Basics of Ring

Conversión de antiguos programas de BASIC a Ring para aprender los rudimentos de este lenguaje.

Basics of Rust

Conversión de antiguos programas de BASIC a Rust para aprender los rudimentos de este lenguaje.

Basics of Scala

Conversión de antiguos programas de BASIC a Scala para aprender los rudimentos de este lenguaje.

Basics of Scheme

Conversión de antiguos programas de BASIC a Scheme para aprender los rudimentos de este lenguaje.

Basics of Styx

Conversión de antiguos programas de BASIC a Styx para aprender los rudimentos de este lenguaje.

Basics of Swift

Conversión de antiguos programas de BASIC a Swift para aprender los rudimentos de este lenguaje.

Basics of V

Conversión de antiguos programas de BASIC a V para aprender los rudimentos de este lenguaje.

Basics of Vala

Conversión de antiguos programas de BASIC a Vala para aprender los rudimentos de este lenguaje.

Basics of Zig

Conversión de antiguos programas de BASIC a Zig para aprender los rudimentos de este lenguaje.

Enlaces externos relacionados

• Nim