You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
344 lines
13 KiB
344 lines
13 KiB
from .unit import Unit |
|
from .points import Point |
|
from engine.collision_system import CollisionLayer |
|
|
|
import random |
|
import uuid |
|
|
|
# Costanti |
|
AGE_THRESHOLD = 200 |
|
SPEED_REDUCTION = 0.5 |
|
PREGNANCY_DURATION = 500 |
|
BABY_INTERVAL = 50 |
|
|
|
|
|
class Rat(Unit): |
|
def __init__(self, game, position=(0,0), id=None): |
|
super().__init__(game, position, id, collision_layer=CollisionLayer.RAT) |
|
# Specific attributes for rats |
|
self.speed = 0.10 # Rats are slower |
|
self.fight = False |
|
self.gassed = 0 |
|
self.direction = "DOWN" # Default direction |
|
# Initialize position using pathfinding |
|
self.position = self.find_next_position() |
|
|
|
def calculate_rat_direction(self): |
|
x, y = self.position |
|
x_before, y_before = self.position_before |
|
if x > x_before: |
|
return "RIGHT" |
|
elif x < x_before: |
|
return "LEFT" |
|
elif y > y_before: |
|
return "DOWN" |
|
elif y < y_before: |
|
return "UP" |
|
else: |
|
return "DOWN" |
|
|
|
def find_next_position(self): |
|
neighbors = [] |
|
x, y = self.position |
|
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: |
|
nx, ny = x + dx, y + dy |
|
if not self.game.map.in_bounds(nx, ny): |
|
continue |
|
if self.game.map.is_traversable(nx, ny) and (nx, ny) != self.position_before: |
|
neighbors.append((nx, ny)) |
|
|
|
if not neighbors: |
|
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: |
|
nx, ny = x + dx, y + dy |
|
if not self.game.map.in_bounds(nx, ny): |
|
continue |
|
if self.game.map.is_traversable(nx, ny): |
|
neighbors.append((nx, ny)) |
|
|
|
if not neighbors: |
|
print(f"[flow] rat fallback: no traversable neighbors from position={self.position}", flush=True) |
|
return self.position |
|
|
|
self.position_before = self.position |
|
return random.choice(neighbors) |
|
|
|
def choked(self): |
|
self.game.render_engine.play_sound("CHOKE.WAV") |
|
self.die(score=10) |
|
|
|
def move(self): |
|
if self.gassed > 35: |
|
self.choked() |
|
return |
|
self.age += 1 |
|
if self.age == AGE_THRESHOLD: |
|
self.speed *= SPEED_REDUCTION |
|
if getattr(self, "pregnant", False): |
|
self.procreate() |
|
if self.stop: |
|
self.stop -= 1 |
|
return |
|
if self.partial_move < 1: |
|
self.partial_move = round(self.partial_move + self.speed, 2) |
|
if self.partial_move >= 1: |
|
self.partial_move = 0 |
|
self.position = self.find_next_position() |
|
self.direction = self.calculate_rat_direction() |
|
|
|
# Pre-calculate render position for draw() - optimization |
|
self._update_render_position() |
|
|
|
def _update_render_position(self): |
|
"""Pre-calculate rendering position and bbox during move() to optimize draw()""" |
|
sex = self.sex if self.age > AGE_THRESHOLD else "BABY" |
|
|
|
# Get cached image size instead of calling get_image_size() |
|
image_size = self.game.rat_image_sizes[sex][self.direction] |
|
|
|
# Calculate partial movement offset |
|
if self.direction in ["UP", "DOWN"]: |
|
partial_x = 0 |
|
partial_y = self.partial_move * self.game.cell_size * (1 if self.direction == "DOWN" else -1) |
|
else: |
|
partial_x = self.partial_move * self.game.cell_size * (1 if self.direction == "RIGHT" else -1) |
|
partial_y = 0 |
|
|
|
# Calculate final render position |
|
self.render_x = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x |
|
self.render_y = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y |
|
|
|
# Update bbox for collision system |
|
self.bbox = (self.render_x, self.render_y, self.render_x + image_size[0], self.render_y + image_size[1]) |
|
|
|
def collisions(self): |
|
""" |
|
Optimized collision detection using the vectorized collision system. |
|
Uses spatial hashing and numpy for efficient checks with 200+ units. |
|
""" |
|
OVERLAP_TOLERANCE = self.game.cell_size // 4 |
|
|
|
# Only adult rats can collide for reproduction/fighting |
|
if self.age < AGE_THRESHOLD: |
|
return |
|
|
|
# Get collisions from the optimized collision system |
|
collisions = self.game.collision_system.get_collisions_for_unit( |
|
self.id, |
|
CollisionLayer.RAT, |
|
tolerance=OVERLAP_TOLERANCE |
|
) |
|
|
|
# Process each collision |
|
for _, other_id in collisions: |
|
other_unit = self.game.get_unit_by_id(other_id) |
|
|
|
# Skip if not another Rat |
|
if not isinstance(other_unit, Rat): |
|
continue |
|
|
|
if not other_unit or other_unit.age < AGE_THRESHOLD: |
|
continue |
|
|
|
# Check if units are actually moving towards each other |
|
if self.position != other_unit.position_before: |
|
continue |
|
|
|
# Both units still exist in game |
|
if self.id in self.game.units and other_id in self.game.units: |
|
if self.sex == other_unit.sex and self.fight: |
|
# Same sex + fight mode = combat |
|
self.die(other_unit) |
|
elif self.sex != other_unit.sex: |
|
# Different sex = reproduction |
|
if "fuck" in dir(self): |
|
self.fuck(other_unit) |
|
|
|
def die(self, unit=None, score=10): |
|
"""Handle rat death and spawn points.""" |
|
target_unit = unit if unit else self |
|
death_position = target_unit.position_before |
|
|
|
# Use base class cleanup |
|
if target_unit.id in self.game.units: |
|
self.game.units.pop(target_unit.id) |
|
|
|
# Rat-specific behavior: spawn points |
|
if score not in [None, 0]: |
|
self.game.add_point(score) |
|
self.game.spawn_unit(Point, death_position, value=score) |
|
|
|
# Add blood stain directly to background |
|
self.game.add_blood_stain(death_position) |
|
|
|
def draw(self): |
|
"""Optimized draw using pre-calculated positions from move()""" |
|
sex = self.sex if self.age > AGE_THRESHOLD else "BABY" |
|
image = self.game.rat_assets_textures[sex][self.direction] |
|
image_size = self.game.rat_image_sizes[sex][self.direction] |
|
|
|
# Calculate render position if not yet set (first frame) |
|
if not hasattr(self, 'render_x'): |
|
self._calculate_render_position() |
|
|
|
# Match the original game: the visibility test uses the rat's center point, |
|
# not the sprite's top-left corner. |
|
center_x = int(self.render_x + image_size[0] / 2) |
|
center_y = int(self.render_y + image_size[1] / 2) |
|
cell_x = center_x // self.game.cell_size |
|
cell_y = center_y // self.game.cell_size |
|
|
|
if self.game.map.in_bounds(cell_x, cell_y): |
|
if self.game.map.is_tunnel(cell_x, cell_y): |
|
if self._draw_partially_hidden_in_tunnel(image, image_size, center_x, center_y, cell_x, cell_y): |
|
return |
|
return |
|
if not self.game.map.is_empty(cell_x, cell_y): |
|
return |
|
|
|
# Use pre-calculated positions |
|
self.game.render_engine.draw_image(self.render_x, self.render_y, image, anchor="nw", tag="unit") |
|
# bbox already updated in _update_render_position() |
|
#self.game.render_engine.draw_rectangle(self.bbox[0], self.bbox[1], self.bbox[2] - self.bbox[0], self.bbox[3] - self.bbox[1], "unit") |
|
|
|
def _draw_partially_hidden_in_tunnel(self, image, image_size, center_x, center_y, cell_x, cell_y): |
|
direction = self._get_tunnel_entrance_direction(cell_x, cell_y) |
|
if direction is None: |
|
return False |
|
|
|
local_x = center_x - cell_x * self.game.cell_size |
|
local_y = center_y - cell_y * self.game.cell_size |
|
half_cell = self.game.cell_size / 2 |
|
|
|
if direction == "UP": |
|
visible_ratio = max(0.0, min(1.0, (half_cell - local_y) / half_cell)) |
|
visible_height = int(round(image_size[1] * visible_ratio)) |
|
if visible_height <= 0: |
|
return False |
|
self.game.render_engine.draw_image( |
|
self.render_x, |
|
self.render_y, |
|
image, |
|
anchor="nw", |
|
tag="unit", |
|
source_rect=(0, 0, image_size[0], visible_height), |
|
dest_size=(image_size[0], visible_height), |
|
) |
|
return True |
|
|
|
if direction == "DOWN": |
|
visible_ratio = max(0.0, min(1.0, (local_y - half_cell) / half_cell)) |
|
visible_height = int(round(image_size[1] * visible_ratio)) |
|
if visible_height <= 0: |
|
return False |
|
source_y = image_size[1] - visible_height |
|
draw_y = self.render_y + source_y |
|
self.game.render_engine.draw_image( |
|
self.render_x, |
|
draw_y, |
|
image, |
|
anchor="nw", |
|
tag="unit", |
|
source_rect=(0, source_y, image_size[0], visible_height), |
|
dest_size=(image_size[0], visible_height), |
|
) |
|
return True |
|
|
|
if direction == "LEFT": |
|
visible_ratio = max(0.0, min(1.0, (half_cell - local_x) / half_cell)) |
|
visible_width = int(round(image_size[0] * visible_ratio)) |
|
if visible_width <= 0: |
|
return False |
|
self.game.render_engine.draw_image( |
|
self.render_x, |
|
self.render_y, |
|
image, |
|
anchor="nw", |
|
tag="unit", |
|
source_rect=(0, 0, visible_width, image_size[1]), |
|
dest_size=(visible_width, image_size[1]), |
|
) |
|
return True |
|
|
|
visible_ratio = max(0.0, min(1.0, (local_x - half_cell) / half_cell)) |
|
visible_width = int(round(image_size[0] * visible_ratio)) |
|
if visible_width <= 0: |
|
return False |
|
source_x = image_size[0] - visible_width |
|
draw_x = self.render_x + source_x |
|
self.game.render_engine.draw_image( |
|
draw_x, |
|
self.render_y, |
|
image, |
|
anchor="nw", |
|
tag="unit", |
|
source_rect=(source_x, 0, visible_width, image_size[1]), |
|
dest_size=(visible_width, image_size[1]), |
|
) |
|
return True |
|
|
|
def _get_tunnel_entrance_direction(self, cell_x, cell_y): |
|
directions = [ |
|
("UP", 0, -1), |
|
("DOWN", 0, 1), |
|
("LEFT", -1, 0), |
|
("RIGHT", 1, 0), |
|
] |
|
|
|
empty_neighbors = [] |
|
for direction, dx, dy in directions: |
|
neighbor_x = cell_x + dx |
|
neighbor_y = cell_y + dy |
|
if self.game.map.in_bounds(neighbor_x, neighbor_y) and self.game.map.is_empty(neighbor_x, neighbor_y): |
|
empty_neighbors.append(direction) |
|
|
|
if len(empty_neighbors) != 1: |
|
return None |
|
return empty_neighbors[0] |
|
|
|
def _calculate_render_position(self): |
|
"""Calculate render position and bbox (used when render_x not yet set)""" |
|
sex = self.sex if self.age > AGE_THRESHOLD else "BABY" |
|
image_size = self.game.render_engine.get_image_size( |
|
self.game.rat_assets_textures[sex][self.direction] |
|
) |
|
|
|
partial_x, partial_y = 0, 0 |
|
if self.direction in ["UP", "DOWN"]: |
|
partial_y = self.partial_move * self.game.cell_size * (1 if self.direction == "DOWN" else -1) |
|
else: |
|
partial_x = self.partial_move * self.game.cell_size * (1 if self.direction == "RIGHT" else -1) |
|
|
|
self.render_x = self.position_before[0] * self.game.cell_size + (self.game.cell_size - image_size[0]) // 2 + partial_x |
|
self.render_y = self.position_before[1] * self.game.cell_size + (self.game.cell_size - image_size[1]) // 2 + partial_y |
|
self.bbox = (self.render_x, self.render_y, self.render_x + image_size[0], self.render_y + image_size[1]) |
|
|
|
class Male(Rat): |
|
def __init__(self, game, position=(0,0), id=None): |
|
super().__init__(game, position, id) |
|
self.sex = "MALE" |
|
|
|
def fuck(self, unit): |
|
if not unit.pregnant: |
|
self.game.render_engine.play_sound("SEX.WAV") |
|
self.stop = 100 |
|
unit.stop = 200 |
|
unit.pregnant = PREGNANCY_DURATION |
|
unit.babies = random.randint(1, 3) |
|
|
|
class Female(Rat): |
|
def __init__(self, game, position=(0,0), id=None): |
|
super().__init__(game, position, id) |
|
self.sex = "FEMALE" |
|
self.pregnant = False |
|
self.babies = 0 |
|
|
|
def procreate(self): |
|
self.pregnant -= 1 |
|
if self.pregnant == self.babies * BABY_INTERVAL: |
|
self.babies -= 1 |
|
self.stop = 20 |
|
if self.partial_move > 0.2: |
|
self.game.spawn_rat(self.position) |
|
else: |
|
self.game.spawn_rat(self.position_before) |
|
self.game.render_engine.play_sound("BIRTH.WAV") |