Matteo Benedetto
4bab8d1a79
Four gameplay parameters are now driven by the selected difficulty, following the existing 'hard = harder for the player' philosophy: param easy normal hard gas_spread_speed 40 50 90 (higher = slower gas) weapon_refill_multiplier 1.3 1.0 0.6 (less ammo on hard) max_babies 2 3 5 (more pups on hard) mate_stop_male / female 120/240 100/200 60/120 (shorter stop on hard) Implementation: - engine/config.py: new keys on each DIFFICULTY_OPTIONS entry. - rats.py: _apply_difficulty() loads them onto the game (with __init__ defaults for safety); normal keeps the previous hardcoded values. - units/gas.py: Gas.speed reads game.gas_spread_speed (fallback 50). - engine/unit_manager.py: refill_ammo() scales per-frame refill chances by game.weapon_refill_multiplier (fallback 1.0). - units/rat.py: Male.fuck() uses game.mate_stop_male/mate_stop_female and random.randint(1, game.max_babies) (fallbacks to old values). All reads use getattr with the previous constant as fallback, so older configs / saved state keep working.
252 lines
10 KiB
Python
252 lines
10 KiB
Python
from .unit import Unit, UnitType
|
|
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, unit_type=None):
|
|
super().__init__(game, position, id, collision_layer=CollisionLayer.RAT, unit_type=unit_type)
|
|
# Specific attributes for rats
|
|
self.speed = 0.10 * getattr(self.game, "rat_speed_multiplier", 1.0)
|
|
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.graphics.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 spatial grid system.
|
|
"""
|
|
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.unit_manager.get_unit_by_id(other_id)
|
|
|
|
# Skip if not another Rat
|
|
if not other_unit or other_unit.type not in [UnitType.RAT_MALE, UnitType.RAT_FEMALE]:
|
|
continue
|
|
|
|
if other_unit.age < AGE_THRESHOLD:
|
|
continue
|
|
|
|
# Check if units are actually overlapping (same cell now or in transition).
|
|
# Accept any of: same current cell, same previous cell, or each entered
|
|
# the other's previous cell.
|
|
self_here = (self.position, self.position_before)
|
|
other_here = (other_unit.position, other_unit.position_before)
|
|
if not (set(self_here) & set(other_here)):
|
|
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 (only Male has fuck method)
|
|
if hasattr(self, 'fuck'):
|
|
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.scoring.add_point(score)
|
|
self.game.unit_manager.spawn_unit(Point, death_position, value=score)
|
|
|
|
# Add blood stain directly to background
|
|
self.game.graphics.add_blood_stain(death_position)
|
|
|
|
def draw(self):
|
|
"""Optimized draw using pre-calculated positions from move()"""
|
|
if self.id not in self.game.units:
|
|
return
|
|
sex = self.sex if self.age > AGE_THRESHOLD else "BABY"
|
|
image = self.game.graphics.rat_assets_textures[sex][self.direction]
|
|
image_size = self.game.graphics.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 not self.game.map.is_tunnel(cell_x, cell_y) and not self.game.map.is_empty(cell_x, cell_y):
|
|
# Inside a wall (or otherwise non-visible cell): don't draw the rat.
|
|
return
|
|
|
|
# Draw the rat (single animation frame). Applies to open cells, tunnel
|
|
# entrances, and internal tunnel passages alike.
|
|
frame = min(3, int(self.partial_move * 4))
|
|
source_rect = (frame * image_size[0], 0, image_size[0], image_size[1])
|
|
self.game.render_engine.draw_image(self.render_x, self.render_y, image, anchor="nw", tag="unit", source_rect=source_rect)
|
|
|
|
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.graphics.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, unit_type=UnitType.RAT_MALE)
|
|
self.sex = "MALE"
|
|
|
|
def fuck(self, unit):
|
|
if not unit.pregnant:
|
|
self.game.render_engine.play_sound("SEX.WAV")
|
|
self.stop = getattr(self.game, "mate_stop_male", 100)
|
|
unit.stop = getattr(self.game, "mate_stop_female", 200)
|
|
unit.pregnant = PREGNANCY_DURATION
|
|
unit.babies = random.randint(1, getattr(self.game, "max_babies", 3))
|
|
|
|
class Female(Rat):
|
|
def __init__(self, game, position=(0,0), id=None):
|
|
super().__init__(game, position, id, unit_type=UnitType.RAT_FEMALE)
|
|
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.unit_manager.spawn_rat(self.position)
|
|
else:
|
|
self.game.unit_manager.spawn_rat(self.position_before)
|
|
self.game.render_engine.play_sound("BIRTH.WAV") |