feat(controller): add cat AI state machine, kinematics, and paw targeting logic
This commit is contained in:
@@ -0,0 +1,561 @@
|
||||
"""
|
||||
Cat Controller and State Machine for Catser.
|
||||
|
||||
Faithfully implements Workcat's motion physics, life-action state machine,
|
||||
and targeting kinematics:
|
||||
- States: WALK, ALERT, RUN, PAW, RELEASE, DRAG, FALL, HAPPY, SIT, SLEEP, STRETCH, TAIL.
|
||||
- Target tracking: Calculates trajectory so front paw reaches [X] close button
|
||||
at exactly PAW_CONTACT_FRAME (frame 14).
|
||||
- Life actions: Weighted probabilistic transitions between standing, sitting,
|
||||
sleeping (with 'z' indicator), stretching, and tail flicking.
|
||||
- Petting & Drag: Interactive mouse control with physics gravity fall.
|
||||
"""
|
||||
|
||||
import time
|
||||
import math
|
||||
import random
|
||||
import logging
|
||||
from enum import Enum, auto
|
||||
from typing import Optional, Tuple, Callable
|
||||
|
||||
from PIL import Image
|
||||
|
||||
from .config import (
|
||||
Config,
|
||||
Coat,
|
||||
GAIT_FRAME_COUNT,
|
||||
WALK_SPEED,
|
||||
WALK_STRIDE,
|
||||
RUN_SPEED,
|
||||
RUN_STRIDE,
|
||||
GAIT_CADENCE,
|
||||
PAW_FPS,
|
||||
PAW_FRAME_COUNT,
|
||||
PAW_CONTACT_FRAME,
|
||||
CONTACT_RATIO_X,
|
||||
CONTACT_RATIO_Y,
|
||||
ALERT_HOLD_MS,
|
||||
RELEASE_SETTLE_MS,
|
||||
HAPPY_MS,
|
||||
BLINK_DURATION_MS,
|
||||
BLINK_INTERVAL_MIN_MS,
|
||||
BLINK_INTERVAL_MAX_MS,
|
||||
APPROACH_MIN_MS,
|
||||
APPROACH_MAX_MS,
|
||||
ACTION_WEIGHTS,
|
||||
LIFE_ACTION_INTERVAL_MS,
|
||||
SETTLED_ACTION_INTERVAL_MS,
|
||||
SIT_MIN_MS,
|
||||
SIT_MAX_MS,
|
||||
SLEEP_MIN_MS,
|
||||
SLEEP_MAX_MS,
|
||||
LIFE_MOTION_FPS,
|
||||
LIFE_MOTION_FRAME_COUNT,
|
||||
)
|
||||
from .assets_manager import AssetsManager
|
||||
from .window_manager import WindowManager, WindowInfo
|
||||
|
||||
logger = logging.getLogger("catser.controller")
|
||||
|
||||
|
||||
class CatState(Enum):
|
||||
"""Cat behavior state machine enum."""
|
||||
WALK = auto()
|
||||
ALERT = auto()
|
||||
RUN = auto()
|
||||
PAW = auto()
|
||||
DRAG = auto()
|
||||
FALL = auto()
|
||||
RELEASE = auto()
|
||||
HAPPY = auto()
|
||||
SIT = auto()
|
||||
SLEEP = auto()
|
||||
STRETCH = auto()
|
||||
TAIL = auto()
|
||||
|
||||
|
||||
class CatController:
|
||||
"""
|
||||
Coordinates cat position, animations, state transitions, targeting, and physics.
|
||||
"""
|
||||
|
||||
def __init__(self, config: Config, assets: AssetsManager):
|
||||
self.config = config
|
||||
self.assets = assets
|
||||
|
||||
# Screen boundaries
|
||||
work_area = WindowManager.get_work_area()
|
||||
self.screen_left = work_area[0]
|
||||
self.screen_top = work_area[1]
|
||||
self.screen_right = work_area[2]
|
||||
self.screen_bottom = work_area[3]
|
||||
|
||||
# Floor position: Cat walks on top of the taskbar / bottom of work area
|
||||
self.floor_y = float(self.screen_bottom - self.config.cat_height)
|
||||
|
||||
# Position & motion
|
||||
self.x = float(self.screen_left + 100)
|
||||
self.y = self.floor_y
|
||||
self.direction = 1.0 # 1.0 = right, -1.0 = left
|
||||
self.facing_left = False
|
||||
self.lift = 0.0 # Height above floor in pixels
|
||||
|
||||
# State machine
|
||||
self.state = CatState.WALK
|
||||
self.state_start_time = time.time()
|
||||
self.walk_start_time = time.time()
|
||||
|
||||
# Blinking
|
||||
self.is_blinking = False
|
||||
self.next_blink_time = time.time() + random.uniform(BLINK_INTERVAL_MIN_MS, BLINK_INTERVAL_MAX_MS) / 1000.0
|
||||
|
||||
# Targeting & Attack run
|
||||
self.target_window: Optional[WindowInfo] = None
|
||||
self.target_close_coords: Optional[Tuple[int, int]] = None
|
||||
self.run_start_pos = (0.0, 0.0)
|
||||
self.run_target_pos = (0.0, 0.0)
|
||||
self.run_duration = 0.8
|
||||
self.on_contact_callback: Optional[Callable[[WindowInfo], None]] = None
|
||||
self.contact_triggered = False
|
||||
|
||||
# Paw timeline
|
||||
self.paw_start_time = 0.0
|
||||
|
||||
# Drag & Fall
|
||||
self.drag_start_cursor = (0, 0)
|
||||
self.drag_start_pos = (0.0, 0.0)
|
||||
self.fall_start_y = 0.0
|
||||
self.fall_duration = 0.4
|
||||
|
||||
# Life action timer
|
||||
self.last_action_type = "standing"
|
||||
self.settle_duration = 5.0
|
||||
self.next_life_action_time = time.time() + 8.0
|
||||
|
||||
# Speeds in px/s
|
||||
self.walk_speed_px = (WALK_SPEED / config.cat_width) * (config.cat_width * 5.0)
|
||||
self.run_speed_px = (RUN_SPEED / config.cat_width) * (config.cat_width * 4.0)
|
||||
|
||||
# ==========================================================================
|
||||
# State Transitions & Targeting
|
||||
# ==========================================================================
|
||||
|
||||
def set_state(self, new_state: CatState) -> None:
|
||||
"""Transitions to a new state and resets state timer."""
|
||||
if self.state == new_state:
|
||||
return
|
||||
logger.debug(f"Cat state: {self.state.name} -> {new_state.name}")
|
||||
self.state = new_state
|
||||
self.state_start_time = time.time()
|
||||
if new_state == CatState.WALK:
|
||||
self.walk_start_time = time.time()
|
||||
|
||||
def target_window_for_close(self, window_info: WindowInfo, on_contact: Callable[[WindowInfo], None]) -> bool:
|
||||
"""
|
||||
Commands the cat to target a distraction window.
|
||||
Enters ALERT phase, then RUNS to the window's close button [X],
|
||||
swipes it with its paw, and triggers on_contact callback.
|
||||
"""
|
||||
# Don't interrupt while being dragged or mid-strike
|
||||
if self.state in (CatState.DRAG, CatState.PAW):
|
||||
return False
|
||||
|
||||
self.target_window = window_info
|
||||
self.on_contact_callback = on_contact
|
||||
self.contact_triggered = False
|
||||
|
||||
# Wake up if sleeping or sitting
|
||||
if self.state in (CatState.SLEEP, CatState.SIT):
|
||||
self.set_state(CatState.WALK)
|
||||
|
||||
close_x, close_y = window_info.close_button
|
||||
self.target_close_coords = (close_x, close_y)
|
||||
|
||||
# Face towards the target
|
||||
cat_center_x = self.x + self.config.cat_width / 2.0
|
||||
self.facing_left = (close_x < cat_center_x)
|
||||
self.direction = -1.0 if self.facing_left else 1.0
|
||||
|
||||
# Transition to ALERT state (cat perks up with '!' indicator)
|
||||
self.set_state(CatState.ALERT)
|
||||
return True
|
||||
|
||||
def _start_attack_run(self) -> None:
|
||||
"""Begins diagonal run/jump trajectory toward the close button."""
|
||||
if not self.target_close_coords:
|
||||
self.set_state(CatState.WALK)
|
||||
return
|
||||
|
||||
tx, ty = self.target_close_coords
|
||||
w = float(self.config.cat_width)
|
||||
h = float(self.config.cat_height)
|
||||
|
||||
# Workcat contact offset formula:
|
||||
# Aligns the cat so that at Frame 14 the paw tip is on (tx, ty)
|
||||
if self.facing_left:
|
||||
dest_x = tx - w * (1.0 - CONTACT_RATIO_X)
|
||||
else:
|
||||
dest_x = tx - w * CONTACT_RATIO_X
|
||||
dest_y = ty - h * CONTACT_RATIO_Y
|
||||
|
||||
# Clamp within desktop boundaries
|
||||
dest_x = max(float(self.screen_left), min(float(self.screen_right - w), dest_x))
|
||||
dest_y = max(float(self.screen_top), min(float(self.screen_bottom - h), dest_y))
|
||||
|
||||
self.run_start_pos = (self.x, self.y)
|
||||
self.run_target_pos = (dest_x, dest_y)
|
||||
|
||||
# Calculate distance and scale speed so sprint duration is within 620-1150ms
|
||||
dist = math.hypot(dest_x - self.x, dest_y - self.y)
|
||||
natural_sec = dist / max(100.0, self.run_speed_px)
|
||||
self.run_duration = max(APPROACH_MIN_MS / 1000.0, min(APPROACH_MAX_MS / 1000.0, natural_sec))
|
||||
|
||||
self.set_state(CatState.RUN)
|
||||
|
||||
def _trigger_paw_strike(self) -> None:
|
||||
"""Starts the 17-frame paw swipe animation at 24fps."""
|
||||
self.set_state(CatState.PAW)
|
||||
self.paw_start_time = time.time()
|
||||
self.contact_triggered = False
|
||||
|
||||
# ==========================================================================
|
||||
# Mouse Drag & Pet Interaction
|
||||
# ==========================================================================
|
||||
|
||||
def on_mouse_down(self, cursor_x: int, cursor_y: int) -> None:
|
||||
"""Called when user presses mouse button down on the cat."""
|
||||
if self.state == CatState.PAW:
|
||||
return
|
||||
|
||||
self.drag_start_cursor = (cursor_x, cursor_y)
|
||||
self.drag_start_pos = (self.x, self.y)
|
||||
# Wake up immediately if sleeping or sitting
|
||||
if self.state in (CatState.SLEEP, CatState.SIT):
|
||||
self.set_state(CatState.WALK)
|
||||
|
||||
def on_mouse_move(self, cursor_x: int, cursor_y: int) -> None:
|
||||
"""Tracks dragging when mouse moves beyond threshold."""
|
||||
dx = cursor_x - self.drag_start_cursor[0]
|
||||
dy = cursor_y - self.drag_start_cursor[1]
|
||||
dist = math.hypot(dx, dy)
|
||||
|
||||
if self.state != CatState.DRAG:
|
||||
if dist >= 7: # DRAG_THRESHOLD_PX
|
||||
self.set_state(CatState.DRAG)
|
||||
|
||||
if self.state == CatState.DRAG:
|
||||
new_x = self.drag_start_pos[0] + dx
|
||||
new_y = self.drag_start_pos[1] + dy
|
||||
# Keep on screen
|
||||
self.x = max(float(self.screen_left), min(float(self.screen_right - self.config.cat_width), new_x))
|
||||
self.y = max(float(self.screen_top), min(float(self.screen_bottom - self.config.cat_height), new_y))
|
||||
self.lift = max(0.0, self.floor_y - self.y)
|
||||
|
||||
def on_mouse_up(self, cursor_x: int, cursor_y: int) -> None:
|
||||
"""Handles drop after dragging or petting click."""
|
||||
if self.state == CatState.DRAG:
|
||||
# Drop the cat with gravity
|
||||
self.set_state(CatState.FALL)
|
||||
self.fall_start_y = self.y
|
||||
self.fall_duration = max(0.2, min(0.6, math.sqrt((self.floor_y - self.y) / 500.0)))
|
||||
elif self.state != CatState.PAW:
|
||||
# Clicked without dragging -> Pet the cat!
|
||||
self.set_state(CatState.HAPPY)
|
||||
|
||||
# ==========================================================================
|
||||
# Frame Update Loop
|
||||
# ==========================================================================
|
||||
|
||||
def update(self, dt: float) -> Image.Image:
|
||||
"""
|
||||
Updates kinematics, state machine, and renders the active composite frame.
|
||||
Returns 32-bit RGBA PIL Image.
|
||||
"""
|
||||
now = time.time()
|
||||
coat = self.config.coat
|
||||
|
||||
# Handle Blinking
|
||||
if now >= self.next_blink_time and not self.is_blinking:
|
||||
if self.state not in (CatState.SLEEP, CatState.HAPPY):
|
||||
self.is_blinking = True
|
||||
self.next_blink_time = now + (BLINK_DURATION_MS / 1000.0)
|
||||
elif self.is_blinking and now >= self.next_blink_time:
|
||||
self.is_blinking = False
|
||||
self.next_blink_time = now + random.uniform(BLINK_INTERVAL_MIN_MS, BLINK_INTERVAL_MAX_MS) / 1000.0
|
||||
|
||||
face_type = "happy" if self.state == CatState.HAPPY else ("blink" if self.is_blinking else "open")
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: WALK (roaming the desktop floor)
|
||||
# ----------------------------------------------------------------------
|
||||
if self.state == CatState.WALK:
|
||||
elapsed = now - self.walk_start_time
|
||||
# 30 frames cycle
|
||||
fps = (GAIT_FRAME_COUNT * WALK_SPEED * GAIT_CADENCE) / WALK_STRIDE # ~21.6 fps
|
||||
frame_idx = int(elapsed * fps) % max(len(self.assets.walk_path_strings), 1)
|
||||
|
||||
# Move horizontally
|
||||
step = self.direction * self.walk_speed_px * dt
|
||||
self.x += step
|
||||
|
||||
# Bounce at screen edges
|
||||
margin = 15.0
|
||||
if self.x >= self.screen_right - self.config.cat_width - margin:
|
||||
self.x = self.screen_right - self.config.cat_width - margin
|
||||
self.direction = -1.0
|
||||
self.facing_left = True
|
||||
elif self.x <= self.screen_left + margin:
|
||||
self.x = self.screen_left + margin
|
||||
self.direction = 1.0
|
||||
self.facing_left = False
|
||||
|
||||
# Check life actions
|
||||
if now >= self.next_life_action_time:
|
||||
self._choose_life_action()
|
||||
|
||||
img = self.assets.get_walk_frame(frame_idx, coat, self.facing_left, face_type)
|
||||
return self._composite_with_shadow(img, self.lift)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: ALERT (spotted target window)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.ALERT:
|
||||
elapsed_ms = (now - self.state_start_time) * 1000.0
|
||||
if elapsed_ms >= ALERT_HOLD_MS:
|
||||
self._start_attack_run()
|
||||
|
||||
# Display paw frame 0 (alert stance) + alert bubble
|
||||
base = self.assets.get_paw_frame(0, coat, self.facing_left)
|
||||
return self._composite_with_alert(base)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: RUN (sprinting / jumping toward [X])
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.RUN:
|
||||
elapsed = now - self.state_start_time
|
||||
progress = min(1.0, elapsed / max(0.01, self.run_duration))
|
||||
|
||||
# Linear interpolation of trajectory to target close button
|
||||
self.x = self.run_start_pos[0] + (self.run_target_pos[0] - self.run_start_pos[0]) * progress
|
||||
self.y = self.run_start_pos[1] + (self.run_target_pos[1] - self.run_start_pos[1]) * progress
|
||||
self.lift = max(0.0, self.floor_y - self.y)
|
||||
|
||||
# Fast run stride frames
|
||||
run_fps = (GAIT_FRAME_COUNT * RUN_SPEED * GAIT_CADENCE) / RUN_STRIDE
|
||||
frame_idx = int(elapsed * run_fps) % max(len(self.assets.walk_path_strings), 1)
|
||||
|
||||
if progress >= 1.0:
|
||||
self._trigger_paw_strike()
|
||||
|
||||
img = self.assets.get_walk_frame(frame_idx, coat, self.facing_left, face_type)
|
||||
return self._composite_with_shadow(img, self.lift)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: PAW (17 frames strike swipe)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.PAW:
|
||||
elapsed = now - self.paw_start_time
|
||||
frame_idx = int(elapsed * PAW_FPS)
|
||||
|
||||
# Frame 14 is the contact frame where paw strikes [X]
|
||||
if frame_idx >= PAW_CONTACT_FRAME and not self.contact_triggered:
|
||||
self.contact_triggered = True
|
||||
if self.on_contact_callback and self.target_window:
|
||||
try:
|
||||
self.on_contact_callback(self.target_window)
|
||||
except Exception as e:
|
||||
logger.error(f"Error in on_contact_callback: {e}")
|
||||
|
||||
# End of paw sequence
|
||||
if frame_idx >= PAW_FRAME_COUNT:
|
||||
# Settle and fall back to floor
|
||||
self.set_state(CatState.FALL)
|
||||
self.fall_start_y = self.y
|
||||
self.fall_duration = max(0.2, math.sqrt(max(0.1, self.floor_y - self.y) / 400.0))
|
||||
return self.assets.get_paw_frame(0, coat, self.facing_left)
|
||||
|
||||
img = self.assets.get_paw_frame(frame_idx, coat, self.facing_left)
|
||||
return self._composite_with_shadow(img, self.lift)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: DRAG (user picked up cat by scruff)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.DRAG:
|
||||
img = self.assets.get_scruff_frame(coat)
|
||||
return self._composite_with_shadow(img, self.lift)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: FALL (gravity drop after drag or jumping)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.FALL:
|
||||
elapsed = now - self.state_start_time
|
||||
t = min(1.0, elapsed / max(0.01, self.fall_duration))
|
||||
# Quadratic acceleration (gravity)
|
||||
self.y = self.fall_start_y + (self.floor_y - self.fall_start_y) * (t * t)
|
||||
self.lift = max(0.0, self.floor_y - self.y)
|
||||
|
||||
if t >= 1.0:
|
||||
self.y = self.floor_y
|
||||
self.lift = 0.0
|
||||
self.set_state(CatState.RELEASE)
|
||||
|
||||
img = self.assets.get_paw_frame(0, coat, self.facing_left)
|
||||
return self._composite_with_shadow(img, self.lift)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: RELEASE (landing settle after falling)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.RELEASE:
|
||||
elapsed_ms = (now - self.state_start_time) * 1000.0
|
||||
if elapsed_ms >= RELEASE_SETTLE_MS:
|
||||
self.set_state(CatState.WALK)
|
||||
|
||||
img = self.assets.get_paw_frame(0, coat, self.facing_left)
|
||||
return self._composite_with_shadow(img, 0.0)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: HAPPY (petting purr & floating heart)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.HAPPY:
|
||||
elapsed_ms = (now - self.state_start_time) * 1000.0
|
||||
if elapsed_ms >= HAPPY_MS:
|
||||
self.set_state(CatState.TAIL)
|
||||
|
||||
# Walk frame 0 with happy smiling face
|
||||
base = self.assets.get_walk_frame(0, coat, self.facing_left, "happy")
|
||||
# Floating heart particle
|
||||
progress = min(1.0, elapsed_ms / HAPPY_MS)
|
||||
heart_alpha = 1.0 - progress
|
||||
heart = self.assets.get_heart_particle(size=28, alpha=heart_alpha)
|
||||
|
||||
canvas = Image.new("RGBA", (self.config.cat_width, self.config.cat_height), (0, 0, 0, 0))
|
||||
canvas.paste(base, (0, 0), base)
|
||||
# Heart floats upwards
|
||||
hx = int(self.config.cat_width * 0.65)
|
||||
hy = int(self.config.cat_height * 0.15 - progress * 20.0)
|
||||
canvas.paste(heart, (hx, max(0, hy)), heart)
|
||||
return self._composite_with_shadow(canvas, 0.0)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: SIT (sitting idle)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.SIT:
|
||||
elapsed = now - self.state_start_time
|
||||
if elapsed >= self.settle_duration:
|
||||
self.set_state(CatState.WALK)
|
||||
# Sitting stance using walk frame 0
|
||||
img = self.assets.get_walk_frame(0, coat, self.facing_left, face_type)
|
||||
return self._composite_with_shadow(img, 0.0)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: SLEEP (sleeping with 'z' snoring)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.SLEEP:
|
||||
elapsed = now - self.state_start_time
|
||||
if elapsed >= self.settle_duration:
|
||||
self.set_state(CatState.WALK)
|
||||
|
||||
base = self.assets.get_walk_frame(0, coat, self.facing_left, "blink")
|
||||
# Animated zzz particle
|
||||
zzz = self.assets.get_zzz_indicator(size=22)
|
||||
canvas = Image.new("RGBA", (self.config.cat_width, self.config.cat_height), (0, 0, 0, 0))
|
||||
canvas.paste(base, (0, 0), base)
|
||||
zx = int(self.config.cat_width * 0.65)
|
||||
zy = int(self.config.cat_height * 0.10 + math.sin(elapsed * 2.0) * 4.0)
|
||||
canvas.paste(zzz, (zx, max(0, zy)), zzz)
|
||||
return self._composite_with_shadow(canvas, 0.0)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: STRETCH (37 frames stretch)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.STRETCH:
|
||||
elapsed = now - self.state_start_time
|
||||
frame_idx = int(elapsed * LIFE_MOTION_FPS)
|
||||
if frame_idx >= LIFE_MOTION_FRAME_COUNT:
|
||||
self.set_state(CatState.WALK)
|
||||
return self.assets.get_walk_frame(0, coat, self.facing_left, face_type)
|
||||
|
||||
img = self.assets.get_stretch_frame(frame_idx, coat, self.facing_left)
|
||||
return self._composite_with_shadow(img, 0.0)
|
||||
|
||||
# ----------------------------------------------------------------------
|
||||
# State: TAIL (37 frames tail flick)
|
||||
# ----------------------------------------------------------------------
|
||||
elif self.state == CatState.TAIL:
|
||||
elapsed = now - self.state_start_time
|
||||
frame_idx = int(elapsed * LIFE_MOTION_FPS)
|
||||
if frame_idx >= LIFE_MOTION_FRAME_COUNT:
|
||||
self.set_state(CatState.WALK)
|
||||
return self.assets.get_walk_frame(0, coat, self.facing_left, face_type)
|
||||
|
||||
img = self.assets.get_tail_frame(frame_idx, coat, self.facing_left)
|
||||
return self._composite_with_shadow(img, 0.0)
|
||||
|
||||
# Fallback
|
||||
return self.assets.get_walk_frame(0, coat, self.facing_left, face_type)
|
||||
|
||||
# ==========================================================================
|
||||
# Life Action Scheduling
|
||||
# ==========================================================================
|
||||
|
||||
def _choose_life_action(self) -> None:
|
||||
"""Selects next autonomous idle action based on Workcat action weights."""
|
||||
posture = "sitting" if self.state == CatState.SIT else "standing"
|
||||
weights = ACTION_WEIGHTS.get(posture, ACTION_WEIGHTS["standing"])
|
||||
actions = list(weights.keys())
|
||||
total = sum(weights.values())
|
||||
|
||||
cursor = random.uniform(0.0, total)
|
||||
chosen = "walk"
|
||||
for act in actions:
|
||||
cursor -= weights[act]
|
||||
if cursor <= 0:
|
||||
chosen = act
|
||||
break
|
||||
|
||||
if chosen == "sit":
|
||||
self.settle_duration = random.uniform(SIT_MIN_MS, SIT_MAX_MS) / 1000.0
|
||||
self.set_state(CatState.SIT)
|
||||
self.next_life_action_time = time.time() + self.settle_duration + (SETTLED_ACTION_INTERVAL_MS / 1000.0)
|
||||
elif chosen == "sleep":
|
||||
self.settle_duration = random.uniform(SLEEP_MIN_MS, SLEEP_MAX_MS) / 1000.0
|
||||
self.set_state(CatState.SLEEP)
|
||||
self.next_life_action_time = time.time() + self.settle_duration + (SETTLED_ACTION_INTERVAL_MS / 1000.0)
|
||||
elif chosen == "stretch":
|
||||
self.set_state(CatState.STRETCH)
|
||||
self.next_life_action_time = time.time() + (LIFE_MOTION_FRAME_COUNT / LIFE_MOTION_FPS) + 6.0
|
||||
else:
|
||||
self.set_state(CatState.WALK)
|
||||
self.next_life_action_time = time.time() + (LIFE_ACTION_INTERVAL_MS / 1000.0)
|
||||
|
||||
# ==========================================================================
|
||||
# Compositing Helpers
|
||||
# ==========================================================================
|
||||
|
||||
def _composite_with_shadow(self, sprite: Image.Image, lift: float) -> Image.Image:
|
||||
"""Draws soft contact shadow underneath the cat sprite."""
|
||||
w = self.config.cat_width
|
||||
h = self.config.cat_height
|
||||
canvas = Image.new("RGBA", (w, h), (0, 0, 0, 0))
|
||||
|
||||
lift_ratio = min(1.0, lift / max(1.0, self.floor_y))
|
||||
shadow = self.assets.get_shadow(w, lift_ratio)
|
||||
sx = (w - shadow.width) // 2
|
||||
sy = h - shadow.height - 1
|
||||
canvas.paste(shadow, (sx, sy), shadow)
|
||||
|
||||
# Cat sprite on top
|
||||
canvas.paste(sprite, (0, 0), sprite)
|
||||
return canvas
|
||||
|
||||
def _composite_with_alert(self, sprite: Image.Image) -> Image.Image:
|
||||
"""Paints alert exclamation mark bubble above the cat's head."""
|
||||
w = self.config.cat_width
|
||||
h = self.config.cat_height
|
||||
canvas = self._composite_with_shadow(sprite, 0.0)
|
||||
|
||||
alert_bubble = self.assets.get_alert_bubble(size=30)
|
||||
ax = int(w * 0.70) if not self.facing_left else int(w * 0.05)
|
||||
ay = 2
|
||||
canvas.paste(alert_bubble, (ax, ay), alert_bubble)
|
||||
return canvas
|
||||
Reference in New Issue
Block a user