# wildfire.awk version 1 by Ben Collver

# drop_zone(c, r) returns:
#
#     1 when c,r is in left edge
#     2 when c,r is in zone
#     3 when c,r is next to right edge

function drop_zone(c, r,     col, row, i, j, retval) {
    retval = 0
    for (i = -1; i <= 1; i++) {
        row = rows[r + i]
        for (j = -2; j <= 1; j++) {
            col = cols[c + j]
            if (qcol == col && qrow == row) {
                if (j == -2) {
                    retval = 3
                } else if (j == 1) {
                    retval = 1
                } else {
                    retval = 2
                }
                break
            }
        }
    }
    return retval
}

function end_game(     c, cell, col, r, rating, row, woods) {
    woods = 0
    for (r = 1; r <= rownum; r++) {
        row = rows[r]
        for (c = 1; c <= colnum; c++) {
            col = cols[c]
            cell = grid[row "," col]
            if (cell == 10) {
                woods++
            }
        }
    }
    rating = woods + 30
    if (rating > 100) {
        rating = 100
    }
    printf "Your rating is %s.\n", rating
    return
}

function init(     c, col, colstr, i, r, row, rowstr) {
    colstr = "ABCDEFGHI"
    rowstr = "123456789"
    colnum = split(colstr, cols, "")
    rownum = split(rowstr, rows, "")
    for (r = 1; r <= rownum; r++) {
        row = rows[r]
        rmap[row] = r
        for (c = 1; c <= colnum; c++) {
            col = cols[c]
            cmap[col] = c
            grid[row "," col] = 10
        }
    }
    for (i = 1; i <= 3; i++) {
        r = int(9 * rand() + 1)
        c = int(9 * rand() + 1)
        row = rows[r]
        col = cols[c]
        grid[row "," col] = 9
    }
    prompt = "Enter command (or \"?\"): "
    queue = ""
    qcol = ""
    qrow = ""
    turn = 1
    return
}

function print_error(msg) {
    print ""
    print "Error: " msg
    print ""
    print_prompt()
    return
}

function print_grid(     c, cell, col, pad, r, row, zone) {
    printf "\nTurn #%d\n\n", turn
    printf "  "
    for (c = 1; c <= colnum; c++) {
        printf " %s", cols[c]
    }
    printf "\n"
    for (r = 1; r <= rownum; r++) {
        row = rows[r]
        printf "%s ", row
        for (c = 1; c <= colnum; c++) {
            col = cols[c]
            pad = " "
            if (queue == "drop") {
                zone = drop_zone(c, r)
                if (zone == 1) {
                    pad = "["
                } else if (zone == 2) {
                    pad = "_"
                } else if (zone == 3) {
                    pad = "]"
                }
            }
            cell = grid[row "," col]
            if (cell == 10) {
                if (queue == "back" && qcol == col && qrow == row) {
                    printf pad "B"
                } else {
                    printf pad "."
                }
            } else if (cell > 0 && cell < 3) {
                printf pad "+"
            } else if (cell > 2 && cell < 10) {
                printf pad "*"
            } else {
                printf pad " "
            }
        }
        printf "\n"
    }
    print ""
    print_prompt()
    return
}

function print_help() {
    print ""
    print "Wildfire Commands"
    print "================="
    print ""
    print "?                -- Show this message"
    print "back [row] [col] -- Write order for backfire at location"
    print "drop [row] [col] -- Write order to drop foam at location"
    print "map              -- Print grid map"
    print "quit             -- Quit game"
    print "send             -- Dispatch written order"
    print ""
    print_prompt()
    return
}

function print_prompt() {
    printf prompt
    return
}

function queue_backfire(row, col) {
   if (!(row in rmap)) {
       print_error("invalid row: " row)
   } else if (!(col in cmap)) {
       print_error("invalid column: " col)
   } else if (grid[row "," col] != 10) {
       print_error("no forest there")
   } else {
       queue = "back"
       qcol = col
       qrow = row
       print_grid()
   }
   return
}

function queue_drop(row, col) {
   if (!(row in rmap)) {
       print_error("invalid row: " row)
   } else if (!(col in cmap)) {
       print_error("invalid column: " col)
   } else {
       queue = "drop"
       qcol = col
       qrow = row
       print_grid()
   }
   return
}

function run_turn(    a, b, c, cell, col, fires, i, j, r, row) {
    # spread fire
    for (r = 1; r <= rownum; r++) {
        row = rows[r]
        for (c = 1; c <= colnum; c++) {
            col = cols[c]
            cell = grid[row "," col]
            if (cell > 2 && cell < 10) {
               i = int(3 * rand() - 1)
               j = int(3 * rand() - 1)
               a = r + i
               b = c + j
               if (a in rows && b in cols) {
                   col = cols[b]
                   row = rows[a]
                   cell = grid[row "," col]
                   if (cell == 10 && rand() > .3) {
                       grid[row "," col] = 11
                   }
               }
            }
        }
    }

    # process one turn and count remaining fires
    fires = 0
    for (r = 1; r <= rownum; r++) {
        row = rows[r]
        for (c = 1; c <= colnum; c++) {
            col = cols[c]
            cell = grid[row "," col]
            if (cell == 11) {
                cell = 9
            }
            if (cell > 0 && cell < 10) {
                cell = cell - 1
                if (cell > 0) {
                    fires++
                }
            }
            grid[row "," col] = cell
        }
    }

    return fires
}

function send_backfire() {
    if (grid[qrow "," qcol] == 10) {
        grid[qrow "," qcol] = 2
    }
    return
}

function send_drop(     a, b, cell, col, i, j, row) {
    for (i = -1; i <= 1; i++) {
        for (j = -1; j <= 1; j++) {
            a = rmap[qrow] + i
            b = cmap[qcol] + j
            if (a in rows && b in cols) {
                row = rows[a]
                col = cols[b]
                cell = grid[row "," col]
                if (cell > 0 && cell != 10 && rand() < .5) {
                    grid[row "," col] = cell - 3
                }
            }
        }
    }
    return
} 

BEGIN {
    init()
    print_grid()
}

{
    $0 = toupper($0)
}

$1 == "BACK" || $1 == "B" {
    queue_backfire($2, $3)
    next
}

$0 == "QUIT" || $0 == "Q" {
    exit
}

$1 == "DROP" || $1 == "D" {
    queue_drop($2, $3)
    next
}

$0 == "HELP" || $0 == "?" {
    print_help()
    next
}

$0 == "MAP" || $0 == "M" {
    print_grid()
    next
}

$0 == "SEND" || $0 == "S" {
    if (length(queue) == 0) {
        print_error("No dispatch to send")
    } else if (queue == "back") {
        send_backfire()
    } else if (queue == "drop") {
        send_drop()
    } else {
        print_error("Unknown dispatch: " queue)
    }
    queue = ""
    result = run_turn()
    if (result == 0) {
        end_game()
        exit
    } else {
        turn = turn + 1
        print_grid()
    }
    next
}

{
    print_error("Unknown command: " $0)
}