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.
220 lines
8.5 KiB
220 lines
8.5 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 |
|
while 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.matrix[ny][nx] and not (nx, ny) == self.position_before: |
|
neighbors.append((nx, ny)) |
|
if not neighbors: |
|
self.position_before = self.position |
|
self.position_before = self.position |
|
return neighbors[random.randint(0, len(neighbors) - 1)] |
|
|
|
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.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] |
|
|
|
# Calculate render position if not yet set (first frame) |
|
if not hasattr(self, 'render_x'): |
|
self._calculate_render_position() |
|
|
|
# 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 _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") |