| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
| COLUMNS = 5 |
|
|
|
|
| class CardQEnvironment: |
| score_cap = 250 |
|
|
| def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON): |
| self.sticky_action_prob = sticky_action_prob |
| self.horizon = min(horizon, HORIZON) |
| self.seed(0) |
| self.reset() |
|
|
| def seed(self, seed: int) -> None: |
| self.random = np.random.default_rng(seed) |
|
|
| def reset(self) -> None: |
| self.player = self.random.integers(1, 14, (5, 5)) |
| self.player[0] = [1, 3, 3, 11, 13] |
| self.enemy = self.random.integers(1, 14, (5, 5)) |
| self.piles = [2, 12] |
| self.steps = self.last_action = self.player_pile = self.enemy_pile = 0 |
| self.shuffle_timer = self.shuffle_count = 0 |
| self.enemy_timer = 120.0 |
| self.enemy_column: int | None = None |
| self.center = self.target = 40.0 |
| self.multiplier = 1 |
| self.terminal = False |
|
|
| @classmethod |
| def normalize_score(cls, score: float) -> float: |
| return min(max(score, 0), cls.score_cap) / cls.score_cap |
|
|
| def _match(self, rank: int, preferred: int) -> int | None: |
| for index in (preferred, 1 - preferred): |
| if (rank - self.piles[index]) % 13 in (1, 12): |
| return index |
| return None |
|
|
| def _place(self, cards: np.ndarray, column: int, pile: int) -> None: |
| self.piles[pile] = int(cards[0, column]) |
| cards[:-1, column] = cards[1:, column] |
| cards[-1, column] = self.random.integers(1, 14) |
| self.shuffle_timer = self.shuffle_count = 0 |
|
|
| def act(self, action: int) -> tuple[float, bool]: |
| if self.terminal: |
| return 0.0, True |
| if self.random.random() < self.sticky_action_prob: |
| action = self.last_action |
| column = action - 1 if 1 <= action <= COLUMNS and action != self.last_action else None |
| self.last_action = action |
| self.steps += 1 |
| reward = 0 |
| for frame in range(FRAMES_PER_STEP): |
| reward += self._advance_frame(column if frame == 0 else None) |
| if self.terminal: |
| break |
| self.terminal |= self.steps >= self.horizon |
| return float(reward), self.terminal |
|
|
| def _advance_frame(self, column: int | None) -> int: |
| self.shuffle_timer += 1 |
| if self.shuffle_timer > 60: |
| player_can_play = any(self._match(rank, self.player_pile) is not None for rank in self.player[0]) |
| enemy_can_play = any(self._match(rank, self.enemy_pile) is not None for rank in self.enemy[0]) |
| if not player_can_play: |
| self.enemy_timer *= 0.3 |
| self.shuffle_count += 1 |
| if not (player_can_play or enemy_can_play) or self.shuffle_count > 2: |
| self.piles = self.random.integers(1, 14, 2).tolist() |
| self.shuffle_count = 0 |
| self.shuffle_timer = 0 |
|
|
| reward = 0 |
| if column is not None: |
| pile = self._match(self.player[0, column], self.player_pile) |
| if pile is None: |
| self.target += 5 |
| self.multiplier = 1 |
| self.shuffle_timer = self.shuffle_count = 0 |
| else: |
| self._place(self.player, column, pile) |
| self.player_pile = pile |
| self.target -= 5 |
| reward = self.multiplier |
| self.multiplier += 1 |
|
|
| self.enemy_timer -= 1 |
| if self.enemy_timer < 0: |
| self._enemy_turn() |
| self.center += (self.target - self.center) * 0.1 |
| if self.target < 16: |
| self.target += (16 - self.target) * 0.1 |
| self.terminal = self.center > 94 |
| return reward |
|
|
| def _enemy_turn(self) -> None: |
| self.enemy_timer = self.random.uniform(50, 70) |
| if self.enemy_column is not None: |
| pile = self._match(self.enemy[0, self.enemy_column], self.enemy_pile) |
| if pile is None: |
| self.enemy_timer *= 3 |
| else: |
| self._place(self.enemy, self.enemy_column, pile) |
| self.enemy_pile = pile |
| self.target += 5 |
| self.multiplier = 1 |
|
|
| self.enemy_column = None |
| start = int(self.random.integers(COLUMNS)) |
| for offset in range(COLUMNS): |
| column = (start + offset) % COLUMNS |
| pile = self._match(self.enemy[0, column], self.enemy_pile) |
| if pile is not None: |
| self.enemy_column = column |
| if pile != self.enemy_pile: |
| self.enemy_timer *= 1.5 |
| break |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| cards = np.concatenate((self.enemy[::-1], self.player)) |
| for bit in range(4): |
| state[:, :5, bit] = (cards & (1 << bit)) != 0 |
| state[4:6, :5, 4] = True |
| if self.enemy_column is not None: |
| state[4, self.enemy_column, 5] = True |
| for index, rank in enumerate(self.piles): |
| for bit in range(4): |
| state[4 + index, 5, bit] = bool(rank & (1 << bit)) |
| state[4 + index, 5, 4:6] = index == self.player_pile, index == self.enemy_pile |
| for row, value in enumerate((self.steps, self.multiplier, round(self.center), round(self.target), |
| round(self.enemy_timer), self.shuffle_timer, self.shuffle_count, self.last_action)): |
| for bit in range(10): |
| state[row, 6 + bit // 5, bit % 5] = bool(value & (1 << bit)) |
| return state |
|
|
