Programming Praxis

At slightly over two hundred lines, not counting the random number generator from the Standard Prelude, this is a big program, so we leave a lot of details unmentioned. But though it is large, none of the pieces are hard, so we can rush right through. We begin at the beginning, with the function that prints the welcome message:

(define (welcome)
  (define (spaces n) (make-string n #\space))
  (for-each display `(
    ,(spaces 32) "HAMURABI" #\newline ,(spaces 15)
    "CREATIVE COMPUTING MORRISTOWN, NEW JERSEY"
    #\newline #\newline #\newline #\newline
    "TRY YOUR HAND AT GOVERNING ANCIENT SUMERIA" #\newline
    "FOR A TEN-YEAR TERM OF OFFICE." #\newline #\newline)))

Here is the main routine, which controls the progress of the game and makes all the calculations:

(define (hamurabi)

      ; loop for next year
      (when (not done?) (set! plague? (< (rand) 0.15)) (loop (+ year 1))))))

Hopefully the comments make clear what is happening. The program begins by printing a welcome message and initializing a bunch of global variables, then enters a loop with one year per iteration. The done? variable is set whenever there needs to be an early termination, due to high starvation or invalid data entry, and each of the pieces begins by checking done? so the remaining work is skipped and the loop terminates if the game is over.

The first block in the main loop checks plague? and reports the current status:

(define (report year deaths births plague? pop acres yield rats stores)
  (for-each display `(
    #\newline #\newline
    "HAMURABI:  I BEG TO REPORT TO YOU," #\newline
    "IN YEAR " ,year ", " ,deaths " PEOPLE STARVED, "
    ,births " CAME TO THE CITY," #\newline))
  (when plague?
    (display "A HORRIBLE PLAGUE STRUCK!  HALF THE PEOPLE DIED.") (newline))
  (for-each display `(
    "POPULATION IS NOW " ,pop #\newline
    "THE CITY OWNS " ,acres " ACRES." #\newline
    "YOU HARVESTED " ,yield " BUSHELS PER ACRE." #\newline
    "RATS ATE " ,rats " BUSHELS." #\newline
    "YOU NOW HAVE " ,stores " BUSHELS IN STORE." #\newline #\newline)))

The second block checks for normal termination at the end of ten years. Here is terminate, which writes the termination header, followed by the series of four messages that terminate might write, followed by the so-long exit message (note that #\bel is specific to Chez Scheme, and other Scheme systems may use a different mnemonic):

(define (terminate pcnt-starved total-deaths acres pop)
  (let ((land (quotient acres pop)))
    (for-each display `(
      "IN YOUR 10-YEAR TERM OF OFFICE, "
      ,(inexact->exact (round pcnt-starved))
      " PERCENT OF THE" #\newline
      "POPULATION STARVED PER YEAR ON AVERAGE, I.E., A TOTAL OF"
      #\newline ,total-deaths " PEOPLE DIED!!" #\newline
      "YOU STARTED WITH 10 ACRES PER PERSON AND ENDED WITH "
      ,land " ACRES PER PERSON." #\newline #\newline))
    (cond ((or (< 33 pcnt-starved) (< land 7)) (fink))
          ((or (< 10 pcnt-starved) (< land 9)) (nero))
          ((or (< 3 pcnt-starved) (< land 10)) (not-bad pop))
          (else (fantastic)))))

(define (so-long)
  (do ((n 1 (+ n 1))) ((< 10 n)) (display #\bel))
  (newline) (display "SO LONG FOR NOW.") (newline) (newline))

The third block asks the player to buy or sell land. First the price of land is randomly chosen, then the player is asked to buy land, and if he declines, he is asked to sell land. When buying, there is a check to be sure the player has sufficient grain to make the purchase, and when selling, there is a check to be sure the player owns the requested number of acres. If land is exchanged, both the number of acres owned and the number of bushels of grain in the silos are updated. Note that get-buy-sell returns #f to terminate the game if the player enters a negative number of acres:

(define (get-price)
  (let ((price (+ (randint 10) 17)))
    (for-each display `(
      "LAND IS TRADING AT " ,price " BUSHELS PER ACRE." #\newline))
    price))

(define (get-sell acres)
  (display "HOW MANY ACRES DO YOU WISH TO SELL? ")
  (let ((q (read)))
    (cond ((negative? q) #f) ((< q acres) q)
          (else (no-acres acres) (get-sell acres)))))

The fourth block asks the player how much to feed the people and updates the number of bushels of grain in the silos. The only calculation is whether or not there is sufficient grain on hand to meet the request:

(define (get-feed stores)
  (newline) (display "HOW MANY BUSHELS DO YOU WISH TO FEED YOUR PEOPLE? ")
  (let ((q (read)))
    (cond ((negative? q) #f)
          ((< stores q) (no-stores stores) (get-feed stores))
          (else q))))

The fifth block calculates the harvest and sets the ending number of bushels of grain in the silos. Each person can farm ten acres, and each acre requires half a bushel for seed; inputs are checked for validity against both constraints. The yield per acre planted is calculated randomly, as is the amount of grain eaten by rats. Note that stores is updated twice, once to reduce grain when it is planted, and once to increase grain when it is harvested (less the amount eaten by rats):

(define (get-plant acres stores pop)
  (newline) (display "HOW MANY ACRES DO YOU WISH TO PLANT WITH SEED? ")
  (let ((q (read)))
    (cond ((negative? q) #f) ((zero? q) q)
          ((< acres q) (no-acres acres) (get-plant acres stores pop))
          ((< stores (quotient q 2))
            (no-stores stores) (get-plant acres stores pop))
          ((< (* pop 10) q) (no-people pop) (get-plant acres stores pop))
          (else q))))

The previous three blocks all call the functions shown below to inform the user he has violated some constraint and ask him to re-enter a valid amount; also shown below is the function that terminates the program for invalid input:

(define (no-stores stores)
  (for-each display `(
    "HAMURABI:  THINK AGAIN.  YOU HAVE ONLY " ,stores
    " BUSHELS OF GRAIN.  NOW THEN," #\newline)))

(define (quit)
  (newline) (display "HAMURABI:  I CANNOT DO WHAT YOU WISH.") (newline)
  (display "GET YOURSELF ANOTHER STEWARD!!!!!") (newline) (so-long))

The sixth block calculates the ending population. Births are calculated randomly, deaths are calculated based on a requirement of twenty bushels of grain to feed one person for a year. The total number of deaths due to starvation and the percentage starved are accumulated for reporting at the end of the game; note that deaths due to plague don’t count against the steward. Finally, the steward is impeached if too many people starve in any one year; the earlier “national fink” message is reused for this purpose. Here’s the message that reports the impeachment:

(define (impeach deaths)
  (for-each display `(
    #\newline "YOU STARVED " ,deaths " PEOPLE IN ONE YEAR!!!" #\newline))
  (fink))

Finally, the seventh block calculates a fifteen percent probability of plague and loops for the next year.

A complete sample game is given on the next page. You can see the code assembled at http://programmingpraxis.codepad.org/kx22J8TE.

Pages: 1 2 3 4