Add scripting language capabilities to tssr for setting up soccer games programmatically, add some example scripts in files suffixed .tsrc (tiny soccer sim rust C)

This commit is contained in:
mrkmntal 2026-09-24 20:02:13 -04:00
commit 5b41327649
4 changed files with 329 additions and 21 deletions

13
gnu-bsd-soccer.tsrc Executable file
View file

@ -0,0 +1,13 @@
#!/home/mrkmntal/tssr/target/release/tssr
string home = "GNU United";
string away = "BSD Athletic";
players["Richard Stallman"] = home;
players["Brian Fox"] = home;
players["Theo de Raadt"] = away;
players["Jordan Hubbard"] = away;
players["Ken Thompson"] = away;
match(home, away);

View file

@ -1,6 +1,10 @@
mod tsrc;
use rand::seq::SliceRandom;
use rand::Rng;
use std::env;
use std::path::Path;
use std::process;
const TEAM_NAMES: &[&str] = &[
"Man Page City",
@ -56,7 +60,7 @@ const LAST_NAMES: &[&str] = &[
];
struct Team {
name: &'static str,
name: String,
score: u8,
shots: u8,
shots_on_target: u8,
@ -75,14 +79,38 @@ fn gen_name(rng: &mut rand::rngs::ThreadRng) -> String {
format!("{} {}", first, last)
}
fn gen_match(rng: &mut rand::rngs::ThreadRng) -> Match {
let idx1 = rng.gen_range(0..TEAM_NAMES.len());
let mut idx2 = rng.gen_range(0..TEAM_NAMES.len());
while idx2 == idx1 {
idx2 = rng.gen_range(0..TEAM_NAMES.len());
}
let home_name = TEAM_NAMES[idx1];
let away_name = TEAM_NAMES[idx2];
fn pick_scorers(roster: &[String], count: usize, rng: &mut rand::rngs::ThreadRng) -> Vec<(String, u8)> {
(0..count)
.map(|_| {
let name = if roster.is_empty() {
gen_name(rng)
} else {
roster.choose(rng).unwrap().clone()
};
(name, rng.gen_range(1..=90u8))
})
.collect()
}
fn gen_match(
rng: &mut rand::rngs::ThreadRng,
script: Option<&tsrc::TsrcScript>,
) -> Match {
let (home_name, away_name) = match script {
Some(s) => {
let h = s.teams.get(&s.home_var).unwrap().clone();
let a = s.teams.get(&s.away_var).unwrap().clone();
(h, a)
}
None => {
let idx1 = rng.gen_range(0..TEAM_NAMES.len());
let mut idx2 = rng.gen_range(0..TEAM_NAMES.len());
while idx2 == idx1 {
idx2 = rng.gen_range(0..TEAM_NAMES.len());
}
(TEAM_NAMES[idx1].to_string(), TEAM_NAMES[idx2].to_string())
}
};
let home_score = rng.gen_range(0..=5u8);
let away_score = rng.gen_range(0..=5u8);
@ -93,13 +121,11 @@ fn gen_match(rng: &mut rand::rngs::ThreadRng) -> Match {
let home_on_target = rng.gen_range(1..=home_shots.min(10));
let away_on_target = rng.gen_range(1..=away_shots.min(10));
let home_scorers: Vec<(String, u8)> = (0..home_score)
.map(|_| (gen_name(rng), rng.gen_range(1..=90u8)))
.collect();
let home_roster = script.and_then(|s| s.roster.get(&home_name)).map(|v| v.as_slice()).unwrap_or(&[]);
let away_roster = script.and_then(|s| s.roster.get(&away_name)).map(|v| v.as_slice()).unwrap_or(&[]);
let away_scorers: Vec<(String, u8)> = (0..away_score)
.map(|_| (gen_name(rng), rng.gen_range(1..=90u8)))
.collect();
let home_scorers = pick_scorers(home_roster, home_score as usize, rng);
let away_scorers = pick_scorers(away_roster, away_score as usize, rng);
Match {
home: Team {
@ -127,8 +153,8 @@ fn pad_line(content: &str, inner_width: usize) -> String {
}
fn print_table(m: &Match) {
let home = m.home.name;
let away = m.away.name;
let home = &m.home.name;
let away = &m.away.name;
let score_line = format!("{home} {}-{} {away}", m.home.score, m.away.score);
let shots_col = format!("{:>4} {:>4}", m.home.shots, m.away.shots);
@ -218,23 +244,52 @@ fn print_json(m: &Match) {
}
fn print_usage() {
println!("Usage: tssr [--json] [--help]");
println!("Usage: tssr [--json] [--script <file>] [--help]");
println!();
println!("Options:");
println!(" --json Output match as JSON");
println!(" -h, --help Show this help message");
println!(" --script FILE Use a .tsrc script to define teams and players");
println!(" --json Output match as JSON");
println!(" -h, --help Show this help message");
println!();
println!("Run a .tsrc script directly with a shebang:");
println!(" #!/usr/bin/env tssr");
}
fn main() {
let args: Vec<String> = env::args().collect();
if args.iter().any(|a| a == "--help" || a == "-h") {
print_usage();
return;
}
let json_mode = args.iter().any(|a| a == "--json");
let script = if let Some(pos) = args.iter().position(|a| a == "--script") {
match args.get(pos + 1) {
Some(path) => Some(tsrc::parse_tsrc(path).unwrap_or_else(|e| {
eprintln!("{}", e);
process::exit(1);
})),
None => {
eprintln!("tsrc error: --script requires a file path");
process::exit(1);
}
}
} else {
args.iter()
.skip(1)
.find(|a| !a.starts_with("--") && Path::new(a).is_file())
.map(|path| {
tsrc::parse_tsrc(path).unwrap_or_else(|e| {
eprintln!("{}", e);
process::exit(1);
})
})
};
let mut rng = rand::thread_rng();
let m = gen_match(&mut rng);
let m = gen_match(&mut rng, script.as_ref());
if json_mode {
print_json(&m);

227
src/tsrc.rs Normal file
View file

@ -0,0 +1,227 @@
use std::collections::HashMap;
use std::fs;
pub struct TsrcScript {
pub teams: HashMap<String, String>,
pub roster: HashMap<String, Vec<String>>,
pub home_var: String,
pub away_var: String,
}
pub fn parse_tsrc(path: &str) -> Result<TsrcScript, String> {
let content = fs::read_to_string(path)
.map_err(|e| format!("tsrc error: cannot read '{}': {}", path, e))?;
let mut teams = HashMap::new();
let mut roster: HashMap<String, Vec<String>> = HashMap::new();
let mut match_found = false;
let mut home_var = String::new();
let mut away_var = String::new();
let mut var_lines: HashMap<String, usize> = HashMap::new();
let mut player_entries: HashMap<(String, String), usize> = HashMap::new();
for (line_num, raw_line) in content.lines().enumerate() {
let n = line_num + 1;
let line = raw_line.trim();
if line.is_empty() || line.starts_with("//") || line.starts_with("#!") {
continue;
}
if let Some(rest) = line.strip_prefix("string ") {
parse_string_decl(rest, n, &mut teams, &mut var_lines)?;
} else if let Some(rest) = line.strip_prefix("players") {
parse_player_insert(rest, n, &mut roster, &mut player_entries, &teams)?;
} else if let Some(rest) = line.strip_prefix("match") {
let rest = rest.trim_end_matches(';');
(home_var, away_var) = parse_match(rest, n, &teams)?;
match_found = true;
} else {
return Err(format!("tsrc error: unrecognized statement on line {}: '{}'", n, line));
}
}
if !match_found {
return Err("tsrc error: no match() directive found".to_string());
}
validate_script(&teams, &roster, &home_var, &away_var)?;
Ok(TsrcScript {
teams,
roster,
home_var,
away_var,
})
}
fn validate_script(
teams: &HashMap<String, String>,
roster: &HashMap<String, Vec<String>>,
home_var: &str,
away_var: &str,
) -> Result<(), String> {
let home_team = teams.get(home_var).unwrap();
let away_team = teams.get(away_var).unwrap();
if home_team == away_team {
return Err(format!(
"tsrc error: match() has the same team for both home and away (\"{}\")",
home_team
));
}
for (team_name, players) in roster {
if team_name != home_team && team_name != away_team {
return Err(format!(
"tsrc error: {} player(s) assigned to \"{}\" which is not a match team (home=\"{}\", away=\"{}\")",
players.len(), team_name, home_team, away_team
));
}
}
let home_count = roster.get(home_team).map(|v| v.len()).unwrap_or(0);
let away_count = roster.get(away_team).map(|v| v.len()).unwrap_or(0);
if home_count == 0 {
return Err(format!(
"tsrc error: \"{}\" ({}) has no players assigned",
home_team, home_var
));
}
if away_count == 0 {
return Err(format!(
"tsrc error: \"{}\" ({}) has no players assigned",
away_team, away_var
));
}
Ok(())
}
fn parse_string_decl(
s: &str,
n: usize,
teams: &mut HashMap<String, String>,
var_lines: &mut HashMap<String, usize>,
) -> Result<(), String> {
let s = s.trim();
let eq_pos = s.find('=')
.ok_or_else(|| format!("tsrc error: missing '=' on line {}", n))?;
let var_name = s[..eq_pos].trim();
let value_part = s[eq_pos + 1..].trim().trim_end_matches(';');
if !is_valid_ident(var_name) {
return Err(format!("tsrc error: invalid variable name '{}' on line {}", var_name, n));
}
if let Some(&first_line) = var_lines.get(var_name) {
return Err(format!(
"tsrc error: variable '{}' redefined on line {} (first seen on line {})",
var_name, n, first_line
));
}
let value = parse_string_literal(value_part, n)?;
var_lines.insert(var_name.to_string(), n);
teams.insert(var_name.to_string(), value);
Ok(())
}
fn parse_player_insert(
s: &str,
n: usize,
roster: &mut HashMap<String, Vec<String>>,
player_entries: &mut HashMap<(String, String), usize>,
teams: &HashMap<String, String>,
) -> Result<(), String> {
let s = s.trim();
let bracket_end = s.find(']')
.ok_or_else(|| format!("tsrc error: missing ']' on line {}", n))?;
let key_part = &s[1..bracket_end];
let after = &s[bracket_end + 1..];
let player_name = parse_string_literal(key_part.trim(), n)?;
let eq_pos = after.find('=')
.ok_or_else(|| format!("tsrc error: missing '=' on line {}", n))?;
let value_part = after[eq_pos + 1..].trim().trim_end_matches(';');
let team_name = if value_part.starts_with('"') {
parse_string_literal(value_part, n)?
} else {
let var_name = value_part.trim();
if !is_valid_ident(var_name) {
return Err(format!(
"tsrc error: expected string literal or variable on line {}",
n
));
}
match teams.get(var_name) {
Some(v) => v.clone(),
None => {
return Err(format!(
"tsrc error: undefined variable '{}' on line {} (declare it with `string {} = \"...\"` first)",
var_name, n, var_name
));
}
}
};
let key = (player_name.clone(), team_name.clone());
if let Some(&first_line) = player_entries.get(&key) {
return Err(format!(
"tsrc error: duplicate player \"{}\" on team \"{}\" (first seen on line {})",
player_name, team_name, first_line
));
}
player_entries.insert(key, n);
roster.entry(team_name).or_default().push(player_name);
Ok(())
}
fn parse_match(s: &str, n: usize, teams: &HashMap<String, String>) -> Result<(String, String), String> {
let s = s.trim();
if !s.starts_with('(') || !s.ends_with(')') {
return Err(format!("tsrc error: match() requires parentheses on line {}", n));
}
let inner = &s[1..s.len() - 1];
let comma_pos = inner.find(',')
.ok_or_else(|| format!("tsrc error: match() requires two arguments separated by ',' on line {}", n))?;
let var1 = inner[..comma_pos].trim();
let var2 = inner[comma_pos + 1..].trim();
if !is_valid_ident(var1) {
return Err(format!("tsrc error: invalid variable '{}' in match() on line {}", var1, n));
}
if !is_valid_ident(var2) {
return Err(format!("tsrc error: invalid variable '{}' in match() on line {}", var2, n));
}
if !teams.contains_key(var1) {
return Err(format!("tsrc error: undefined variable '{}' in match() on line {}", var1, n));
}
if !teams.contains_key(var2) {
return Err(format!("tsrc error: undefined variable '{}' in match() on line {}", var2, n));
}
Ok((var1.to_string(), var2.to_string()))
}
fn parse_string_literal(s: &str, n: usize) -> Result<String, String> {
let s = s.trim();
if s.len() < 2 || !s.starts_with('"') || !s.ends_with('"') {
return Err(format!("tsrc error: expected string literal on line {}", n));
}
Ok(s[1..s.len() - 1].to_string())
}
fn is_valid_ident(s: &str) -> bool {
if s.is_empty() { return false; }
s.chars().all(|c| c.is_alphanumeric() || c == '_')
}

13
test_match.tsrc Executable file
View file

@ -0,0 +1,13 @@
#!/home/mrkmntal/tssr/target/release/tssr
// Man Page City vs Libre Pool
string home = "Linux City";
string away = "Libre Pool";
players["John Davis"] = "Linux City";
players["Linus Torvalds"] = "Linux City";
players["Dan Garcia"] = "Libre Pool";
players["Sam Wilson"] = "Libre Pool";
players["Mike Jones"] = "Libre Pool";
match(home, away);