242 lines
9.9 KiB
Python
242 lines
9.9 KiB
Python
|
```python
|
|||
|
|
import re
|
|||
|
|
import random
|
|||
|
|
from typing import Any, Dict, Optional, Tuple, List
|
|||
|
|
|
|||
|
|
import textarena as ta
|
|||
|
|
|
|||
|
|
|
|||
|
|
class StellarOrchardEnv(ta.Env):
|
|||
|
|
"""
|
|||
|
|
Stellar Orchard – Turn-based deterministic horticulture strategy game
|
|||
|
|
Implements Stage 1 specification of "Stellar Orchard" environment.
|
|||
|
|
"""
|
|||
|
|
|
|||
|
|
def __init__(self, max_turns: int = 10):
|
|||
|
|
self.max_turns = max_turns
|
|||
|
|
# Grammar – exactly per Stage 1
|
|||
|
|
self.patterns = {
|
|||
|
|
"Plant": re.compile(r"^Plant:(A[1-5]|B[1-5])$"),
|
|||
|
|
"Nurture": re.compile(r"^Nurture:(A[1-5]|B[1-5])$"),
|
|||
|
|
"Harvest": re.compile(r"^Harvest:(A[1-5]|B[1-5])$"),
|
|||
|
|
"Pass": re.compile(r"^Pass$"),
|
|||
|
|
}
|
|||
|
|
self.weather_types = ["Radiant Skies", "Lunar Mist", "Crystal Winds"]
|
|||
|
|
|
|||
|
|
# ----------------------------------------------------------------------
|
|||
|
|
# Helper: Extract boxed content
|
|||
|
|
def _extract_answer_content(self, action: str) -> str:
|
|||
|
|
"""Extract literal content inside \\boxed{{...}}."""
|
|||
|
|
match = re.search(r"\\boxed\{\{(.*?)\}\}", action, re.DOTALL)
|
|||
|
|
if match:
|
|||
|
|
return match.group(1).strip()
|
|||
|
|
# fallback to direct content
|
|||
|
|
return action.strip()
|
|||
|
|
|
|||
|
|
# ----------------------------------------------------------------------
|
|||
|
|
def reset(self, num_players: int, seed: Optional[int] = None):
|
|||
|
|
"""
|
|||
|
|
Resets the environment to an initial state.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
num_players: Must be 2 for Stellar Orchard.
|
|||
|
|
seed: Optional deterministic seed.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
None
|
|||
|
|
"""
|
|||
|
|
if num_players != 2:
|
|||
|
|
raise ValueError("Stellar Orchard requires exactly 2 players.")
|
|||
|
|
|
|||
|
|
self.state = ta.TwoPlayerState(num_players=num_players, seed=seed, max_turns=self.max_turns, error_allowance=1)
|
|||
|
|
random.seed(seed)
|
|||
|
|
|
|||
|
|
# deterministic environment setup
|
|||
|
|
soil_fertility = {f"A{i}": random.uniform(0.5, 1.0) for i in range(1, 6)}
|
|||
|
|
soil_fertility.update({f"B{i}": random.uniform(0.5, 1.0) for i in range(1, 6)})
|
|||
|
|
weather_pattern = self.weather_types[seed % len(self.weather_types)] if seed is not None else random.choice(self.weather_types)
|
|||
|
|
|
|||
|
|
plots: Dict[str, Dict[str, Any]] = {}
|
|||
|
|
for pid, owner in [("A", "A"), ("B", "B")]:
|
|||
|
|
for i in range(1, 6):
|
|||
|
|
plots[f"{pid}{i}"] = {"owner": owner, "status": "empty", "growth_level": 0}
|
|||
|
|
|
|||
|
|
game_state = {
|
|||
|
|
"turn_number": 0,
|
|||
|
|
"max_turns": self.max_turns,
|
|||
|
|
"active_player": "Solar Gardener",
|
|||
|
|
"plots": plots,
|
|||
|
|
"energy_points": {"A": 0, "B": 0},
|
|||
|
|
"soil_fertility": soil_fertility,
|
|||
|
|
"weather_pattern": weather_pattern,
|
|||
|
|
"transcript": [],
|
|||
|
|
"winner": None,
|
|||
|
|
"random_seed": seed if seed is not None else random.randint(0, 100000),
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
role_mapping = {0: "Solar Gardener", 1: "Lunar Gardener"}
|
|||
|
|
self.state.reset(game_state=game_state, player_prompt_function=self._generate_player_prompt, role_mapping=role_mapping)
|
|||
|
|
|
|||
|
|
self.state.add_observation("Welcome to Stellar Orchard!", ta.ObservationType.GAME_MESSAGE)
|
|||
|
|
self.state.add_observation(f"Weather pattern: {weather_pattern}", ta.ObservationType.GAME_MESSAGE)
|
|||
|
|
return None
|
|||
|
|
|
|||
|
|
# ----------------------------------------------------------------------
|
|||
|
|
def _generate_player_prompt(self, player_id: int, game_state: Dict[str, Any]) -> str:
|
|||
|
|
"""Construct a prompt for a player according to design spec."""
|
|||
|
|
role = "Solar Gardener" if player_id == 0 else "Lunar Gardener"
|
|||
|
|
player_key = "A" if player_id == 0 else "B"
|
|||
|
|
opposite_key = "B" if player_id == 0 else "A"
|
|||
|
|
|
|||
|
|
# summarize plots
|
|||
|
|
plot_summary = "\n".join(
|
|||
|
|
[f"{pid}: {info['status']} (growth {info['growth_level']})" for pid, info in game_state["plots"].items() if info["owner"] == player_key]
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
soil_summary = ", ".join([f"{pid}:{game_state['soil_fertility'][pid]:.2f}" for pid in game_state["soil_fertility"] if pid.startswith(player_key)])
|
|||
|
|
|
|||
|
|
ep = game_state["energy_points"][player_key]
|
|||
|
|
weather = game_state["weather_pattern"]
|
|||
|
|
remaining_turns = game_state["max_turns"] - game_state["turn_number"]
|
|||
|
|
|
|||
|
|
valid_actions = (
|
|||
|
|
"Possible actions this turn:\n"
|
|||
|
|
" - Plant:<plot>\n"
|
|||
|
|
" - Nurture:<plot>\n"
|
|||
|
|
" - Harvest:<plot>\n"
|
|||
|
|
" - Pass"
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
instr = (
|
|||
|
|
f"You are the {role}, a cosmic horticulturist tending glowing alien trees on Selora.\n"
|
|||
|
|
f"Your goal is to maximize Energy Points (EP) by cultivating your plots before the season ends.\n\n"
|
|||
|
|
f"Current Weather: {weather}\n"
|
|||
|
|
f"Soil Fertility (your plots): {soil_summary}\n"
|
|||
|
|
f"Your Energy Points: {ep}\n"
|
|||
|
|
f"Your Orchard Status:\n{plot_summary}\n\n"
|
|||
|
|
f"Turn: {game_state['turn_number']} | Remaining turns: {remaining_turns}\n\n"
|
|||
|
|
f"{valid_actions}\n\n"
|
|||
|
|
"Put your final answer within \\boxed{{}} at the end of your response.\n\n"
|
|||
|
|
"Example valid response:\n"
|
|||
|
|
"I will plant my first tree in A2.\n"
|
|||
|
|
"\\boxed{{Plant:A2}}\n\n"
|
|||
|
|
"Example invalid response:\n"
|
|||
|
|
"Let's go!\n"
|
|||
|
|
"\\boxed{{Grow:A2}} # Invalid keyword"
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
return instr
|
|||
|
|
|
|||
|
|
# ----------------------------------------------------------------------
|
|||
|
|
def step(self, action: str) -> Tuple[bool, ta.Info]:
|
|||
|
|
"""
|
|||
|
|
Perform a single turn step with validation and deterministic game update.
|
|||
|
|
"""
|
|||
|
|
player_id = self.state.current_player_id
|
|||
|
|
player_symbol = "A" if player_id == 0 else "B"
|
|||
|
|
role_name = "Solar Gardener" if player_symbol == "A" else "Lunar Gardener"
|
|||
|
|
|
|||
|
|
self.state.add_observation(action, ta.ObservationType.PLAYER_ACTION, from_id=player_id, to_id=-1)
|
|||
|
|
game_state = self.state.game_state
|
|||
|
|
|
|||
|
|
literal = self._extract_answer_content(action)
|
|||
|
|
|
|||
|
|
# record transcript
|
|||
|
|
game_state["transcript"].append({"player": player_symbol, "action": literal})
|
|||
|
|
|
|||
|
|
# validation
|
|||
|
|
valid_type = None
|
|||
|
|
for k, pat in self.patterns.items():
|
|||
|
|
if pat.match(literal):
|
|||
|
|
valid_type = k
|
|||
|
|
break
|
|||
|
|
if valid_type is None:
|
|||
|
|
self.state.set_invalid_move(reason="Invalid format")
|
|||
|
|
return self.state.step()
|
|||
|
|
|
|||
|
|
# process the deterministic mechanics
|
|||
|
|
plots = game_state["plots"]
|
|||
|
|
action_valid = True
|
|||
|
|
reason_if_invalid = ""
|
|||
|
|
target_plot = None
|
|||
|
|
if valid_type != "Pass":
|
|||
|
|
target_plot = literal.split(":")[1]
|
|||
|
|
|
|||
|
|
if not target_plot.startswith(player_symbol):
|
|||
|
|
action_valid = False
|
|||
|
|
reason_if_invalid = "Plot not owned by player."
|
|||
|
|
|
|||
|
|
if not action_valid:
|
|||
|
|
self.state.set_invalid_move(reason=reason_if_invalid)
|
|||
|
|
return self.state.step()
|
|||
|
|
|
|||
|
|
# Logic for each action type
|
|||
|
|
if valid_type == "Plant":
|
|||
|
|
plot = plots[target_plot]
|
|||
|
|
if plot["status"] != "empty":
|
|||
|
|
self.state.set_invalid_move(reason="Plot already occupied.")
|
|||
|
|
return self.state.step()
|
|||
|
|
plot["status"] = "seedling"
|
|||
|
|
plot["growth_level"] = 1
|
|||
|
|
elif valid_type == "Nurture":
|
|||
|
|
plot = plots[target_plot]
|
|||
|
|
if plot["status"] not in ["seedling", "growing"]:
|
|||
|
|
self.state.set_invalid_move(reason="No tree to nurture.")
|
|||
|
|
return self.state.step()
|
|||
|
|
if plot["growth_level"] >= 3:
|
|||
|
|
self.state.set_invalid_move(reason="Tree already fully grown.")
|
|||
|
|
return self.state.step()
|
|||
|
|
plot["growth_level"] += 1
|
|||
|
|
plot["status"] = "grown" if plot["growth_level"] >= 3 else "growing"
|
|||
|
|
elif valid_type == "Harvest":
|
|||
|
|
plot = plots[target_plot]
|
|||
|
|
if plot["status"] != "grown":
|
|||
|
|
self.state.set_invalid_move(reason="Tree not ready to harvest.")
|
|||
|
|
return self.state.step()
|
|||
|
|
# deterministic energy gain
|
|||
|
|
gain = int(10 * game_state["soil_fertility"][target_plot])
|
|||
|
|
game_state["energy_points"][player_symbol] += gain
|
|||
|
|
plot["status"] = "harvested"
|
|||
|
|
plot["growth_level"] = 0
|
|||
|
|
elif valid_type == "Pass":
|
|||
|
|
pass # nothing else happens
|
|||
|
|
|
|||
|
|
# increment turn number
|
|||
|
|
game_state["turn_number"] += 1
|
|||
|
|
game_state["active_player"] = "Solar Gardener" if player_symbol == "B" else "Lunar Gardener"
|
|||
|
|
|
|||
|
|
# terminal checks
|
|||
|
|
if self._check_terminal_conditions():
|
|||
|
|
return self.state.step()
|
|||
|
|
|
|||
|
|
done, info = self.state.step()
|
|||
|
|
return done, info
|
|||
|
|
|
|||
|
|
# ----------------------------------------------------------------------
|
|||
|
|
def _check_terminal_conditions(self) -> bool:
|
|||
|
|
"""Check game end (turn limit or all plots empty/harvested) and set outcome."""
|
|||
|
|
game_state = self.state.game_state
|
|||
|
|
if self.state.done:
|
|||
|
|
return True
|
|||
|
|
|
|||
|
|
plots = game_state["plots"]
|
|||
|
|
all_passive = all(p["status"] in ["empty", "harvested"] for p in plots.values())
|
|||
|
|
if all_passive or game_state["turn_number"] >= game_state["max_turns"]:
|
|||
|
|
ep = game_state["energy_points"]
|
|||
|
|
if ep["A"] == ep["B"]:
|
|||
|
|
self.state.set_draw(reason="Equal Energy Points. Draw.")
|
|||
|
|
else:
|
|||
|
|
winner = 0 if ep["A"] > ep["B"] else 1
|
|||
|
|
self.state.set_winner(player_id=winner, reason=f"Player {winner} had more Energy Points.")
|
|||
|
|
return True
|
|||
|
|
return False
|
|||
|
|
|
|||
|
|
# ----------------------------------------------------------------------
|
|||
|
|
def get_observation(self) -> Tuple[int, List]:
|
|||
|
|
"""Return current player's observation tuple."""
|
|||
|
|
return self.state.current_player_id, self.state.observations
|
|||
|
|
|
|||
|
|
def close(self) -> Tuple[Dict, Dict]:
|
|||
|
|
"""Finalize episode outputs."""
|
|||
|
|
return self.state.rewards, self.state.game_info
|
|||
|
|
```
|