101 lines
2.9 KiB
Odin
101 lines
2.9 KiB
Odin
/*
|
|
----------------
|
|
Phase 10 Tracker
|
|
----------------
|
|
|
|
This program helps the user keep track of a game of Phase 10 as it is being
|
|
played. It will keep track of players and their scores over the course of the
|
|
game, inferring which phase they are on based on their score.
|
|
|
|
To use the program, first you will input the first names of all of the
|
|
players, seperated by spaces. Then, after each round is finished, you will
|
|
enter the score of each player's hand, again seperated by spaces and in the
|
|
same order that the names were supplied.
|
|
*/
|
|
package main
|
|
|
|
import "core:fmt"
|
|
import "core:os"
|
|
import "core:mem"
|
|
import "core:strings"
|
|
import "core:strconv"
|
|
|
|
// Return a slice of space delimited strings from stdin
|
|
getSpaceDelimetedItems :: proc(backingBuffer: []byte) -> []string {
|
|
count, _ := os.read(os.stdin, backingBuffer)
|
|
response := string(backingBuffer[:count - 1]) // leave off the newline
|
|
items, _ := strings.split(response, " ")
|
|
return items
|
|
}
|
|
|
|
// Prompt user for names of all players
|
|
getNames :: proc(backingBuffer: []byte) -> []string {
|
|
fmt.print("Enter Names: ")
|
|
return getSpaceDelimetedItems(backingBuffer)
|
|
}
|
|
|
|
// Prompt user to enter scores for each player
|
|
addScores :: proc(scores: [][dynamic]int, names: []string) {
|
|
buf: [2048]byte
|
|
fmt.print(" ")
|
|
for name in names {
|
|
fmt.print(name, "")
|
|
}
|
|
fmt.println()
|
|
fmt.print("Scores: ")
|
|
newScores := getSpaceDelimetedItems(buf[:])
|
|
defer delete(newScores)
|
|
for score, index in newScores {
|
|
intScore, _ := strconv.parse_int(score)
|
|
append(&(scores[index]), intScore)
|
|
}
|
|
}
|
|
|
|
main :: proc() {
|
|
// Set up memory tracker
|
|
// track: mem.Tracking_Allocator
|
|
// mem.tracking_allocator_init(&track, context.allocator)
|
|
// context.allocator = mem.tracking_allocator(&track)
|
|
//
|
|
// defer {
|
|
// if len(track.allocation_map) > 0 {
|
|
// fmt.eprintf("=== %v allocations not freed: ===\n", len(track.allocation_map))
|
|
// for _, entry in track.allocation_map {
|
|
// fmt.eprintf(" - %v bytes @ %v\n", entry.size, entry.location)
|
|
// }
|
|
// }
|
|
// mem.tracking_allocator_destroy(&track)
|
|
// }
|
|
|
|
// Prompt for names
|
|
buf: [2048]byte
|
|
names := getNames(buf[:])
|
|
defer delete(names)
|
|
|
|
// Show names to user
|
|
for name in names {
|
|
fmt.println("Name:", name)
|
|
}
|
|
|
|
// Create lists of scores for each player. Each element will by a dynamic
|
|
// array of scores per player.
|
|
scores : [dynamic][dynamic]int
|
|
for name in names {
|
|
scorelist: [dynamic]int
|
|
append(&scores, scorelist)
|
|
}
|
|
defer {
|
|
for scorelist in scores {
|
|
delete(scorelist)
|
|
}
|
|
delete(scores)
|
|
}
|
|
|
|
// Main loop of adding scores
|
|
fmt.println(scores)
|
|
addScores(scores[:], names)
|
|
addScores(scores[:], names)
|
|
addScores(scores[:], names)
|
|
fmt.println(scores)
|
|
}
|