crimsonland 0.1.0.dev3__tar.gz → 0.1.0.dev5__tar.gz

{crimsonland-0.1.0.dev3 → crimsonland-0.1.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: crimsonland
-Version: 0.1.0.dev3
+Version: 0.1.0.dev5
 Requires-Dist: construct>=2.10.70
 Requires-Dist: pillow>=12.1.0
 Requires-Dist: platformdirs>=4.5.1

{crimsonland-0.1.0.dev3 → crimsonland-0.1.0.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crimsonland"
-version = "0.1.0.dev3"
+version = "0.1.0.dev5"
 requires-python = ">=3.13"
 dependencies = [
     "construct>=2.10.70",

{crimsonland-0.1.0.dev3 → crimsonland-0.1.0.dev5}/src/crimson/game_world.py

@@ -31,7 +31,7 @@ from .render.world_renderer import WorldRenderer
 from .audio_router import AudioRouter
 from .perks import PerkId
 from .projectiles import ProjectileTypeId
-from .sim.world_defs import BEAM_TYPES, CREATURE_ASSET
+from .sim.world_defs import BEAM_TYPES, CREATURE_ASSET, ION_TYPES
 from .sim.world_state import ProjectileHit, WorldState
 from .weapons import WEAPON_TABLE
 from .game_modes import GameMode
@@ -510,19 +510,8 @@ class GameWorld:
                         pos_y=float(target_y) + dir_y * dist * 20.0,
                         rand=rand,
                     )
-            elif type_id in BEAM_TYPES:
-                if self.ground is not None and self.fx_textures is not None:
-                    size = float(int(rand()) % 18 + 18)
-                    rotation = float(int(rand()) % 628) * 0.01
-                    self.fx_queue.add(
-                        effect_id=0x01,
-                        pos_x=float(hit_x),
-                        pos_y=float(hit_y),
-                        width=size,
-                        height=size,
-                        rotation=rotation,
-                        rgba=(0.7, 0.9, 1.0, 1.0),
-                    )
+            elif type_id in ION_TYPES:
+                pass
             elif not freeze_active:
                 for _ in range(3):
                     spread = float(int(rand()) % 0x14 - 10) * 0.1

{crimsonland-0.1.0.dev3 → crimsonland-0.1.0.dev5}/src/crimson/gameplay.py

@@ -64,8 +64,8 @@ class PlayerState:
     health: float = 100.0
     size: float = 50.0
 
-    move_speed_multiplier: float = 2.0
-    long_distance_runner_timer: float = 0.0
+    speed_multiplier: float = 2.0
+    move_speed: float = 0.0
     move_phase: float = 0.0
     heading: float = 0.0
     death_timer: float = 16.0
@@ -1592,6 +1592,7 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
 
     firing_during_reload = False
     ammo_cost = 1.0
+    is_fire_bullets = float(player.fire_bullets_timer) > 0.0
     if player.reload_timer > 0.0:
         if player.ammo <= 0 and player.experience > 0:
             if perk_active(player, PerkId.REGRESSION_BULLETS):
@@ -1616,7 +1617,7 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
         else:
             return
 
-    if player.ammo <= 0 and not firing_during_reload:
+    if player.ammo <= 0 and not firing_during_reload and not is_fire_bullets:
         player_start_reload(player, state)
         return
 
@@ -1624,20 +1625,18 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
     fire_bullets_weapon = weapon_entry_for_projectile_type_id(int(ProjectileTypeId.FIRE_BULLETS))
 
     shot_cooldown = float(weapon.shot_cooldown) if weapon.shot_cooldown is not None else 0.0
-    spread_inc = float(weapon.spread_heat_inc) if weapon.spread_heat_inc is not None else 0.0
-    spread_inc *= 1.3
-    if player.fire_bullets_timer > 0.0 and pellet_count == 1 and fire_bullets_weapon is not None:
+    spread_heat_base = float(weapon.spread_heat_inc) if weapon.spread_heat_inc is not None else 0.0
+    if is_fire_bullets and fire_bullets_weapon is not None and fire_bullets_weapon.spread_heat_inc is not None:
+        spread_heat_base = float(fire_bullets_weapon.spread_heat_inc)
+
+    if is_fire_bullets and pellet_count == 1 and fire_bullets_weapon is not None:
         shot_cooldown = (
             float(fire_bullets_weapon.shot_cooldown)
             if fire_bullets_weapon.shot_cooldown is not None
             else 0.0
         )
-        spread_inc = (
-            float(fire_bullets_weapon.spread_heat_inc)
-            if fire_bullets_weapon.spread_heat_inc is not None
-            else 0.0
-        )
-        spread_inc *= 1.3
+
+    spread_inc = spread_heat_base * 1.3
 
     if perk_active(player, PerkId.FASTSHOT):
         shot_cooldown *= 0.88
@@ -1657,6 +1656,7 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
     aim_jitter_x = aim_x + math.cos(dir_angle) * offset
     aim_jitter_y = aim_y + math.sin(dir_angle) * offset
     shot_angle = math.atan2(aim_jitter_y - float(player.pos_y), aim_jitter_x - float(player.pos_x)) + math.pi / 2.0
+    particle_angle = shot_angle - math.pi / 2.0
 
     muzzle_x = player.pos_x + player.aim_dir_x * 16.0
     muzzle_y = player.pos_y + player.aim_dir_y * 16.0
@@ -1676,7 +1676,7 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
             return 0.0013
         return 0.0015
 
-    if player.fire_bullets_timer > 0.0:
+    if is_fire_bullets:
         pellets = max(1, int(pellet_count))
         shot_count = pellets
         meta = _projectile_meta_for_type_id(ProjectileTypeId.FIRE_BULLETS)
@@ -1713,16 +1713,16 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
         state.secondary_projectiles.spawn(pos_x=muzzle_x, pos_y=muzzle_y, angle=shot_angle, type_id=4, owner_id=owner_id)
     elif weapon_id == WeaponId.FLAMETHROWER:
         # Flamethrower -> fast particle weapon (style 0), fractional ammo drain.
-        state.particles.spawn_particle(pos_x=muzzle_x, pos_y=muzzle_y, angle=dir_angle, intensity=1.0, owner_id=owner_id)
+        state.particles.spawn_particle(pos_x=muzzle_x, pos_y=muzzle_y, angle=particle_angle, intensity=1.0, owner_id=owner_id)
         ammo_cost = 0.1
     elif weapon_id == WeaponId.BLOW_TORCH:
         # Blow Torch -> fast particle weapon (style 1), fractional ammo drain.
-        particle_id = state.particles.spawn_particle(pos_x=muzzle_x, pos_y=muzzle_y, angle=dir_angle, intensity=1.0, owner_id=owner_id)
+        particle_id = state.particles.spawn_particle(pos_x=muzzle_x, pos_y=muzzle_y, angle=particle_angle, intensity=1.0, owner_id=owner_id)
         state.particles.entries[particle_id].style_id = 1
         ammo_cost = 0.05
     elif weapon_id == WeaponId.HR_FLAMER:
         # HR Flamer -> fast particle weapon (style 2), fractional ammo drain.
-        particle_id = state.particles.spawn_particle(pos_x=muzzle_x, pos_y=muzzle_y, angle=dir_angle, intensity=1.0, owner_id=owner_id)
+        particle_id = state.particles.spawn_particle(pos_x=muzzle_x, pos_y=muzzle_y, angle=particle_angle, intensity=1.0, owner_id=owner_id)
         state.particles.entries[particle_id].style_id = 2
         ammo_cost = 0.1
     elif weapon_id == WeaponId.BUBBLEGUN:
@@ -1833,15 +1833,17 @@ def player_fire_weapon(player: PlayerState, input_state: PlayerInput, dt: float,
         player.spread_heat = min(0.48, max(0.0, player.spread_heat + spread_inc))
 
     muzzle_inc = float(weapon.spread_heat_inc) if weapon.spread_heat_inc is not None else 0.0
+    if is_fire_bullets and pellet_count == 1 and fire_bullets_weapon is not None and fire_bullets_weapon.spread_heat_inc is not None:
+        muzzle_inc = float(fire_bullets_weapon.spread_heat_inc)
     player.muzzle_flash_alpha = min(1.0, player.muzzle_flash_alpha)
     player.muzzle_flash_alpha = min(1.0, player.muzzle_flash_alpha + muzzle_inc)
     player.muzzle_flash_alpha = min(0.8, player.muzzle_flash_alpha)
 
     player.shot_seq += 1
-    if not firing_during_reload and state.bonuses.reflex_boost <= 0.0:
+    if (not firing_during_reload) and state.bonuses.reflex_boost <= 0.0 and not is_fire_bullets:
         player.ammo = max(0.0, float(player.ammo) - float(ammo_cost))
-        if player.ammo <= 0.0:
-            player_start_reload(player, state)
+    if (not firing_during_reload) and player.ammo <= 0.0 and player.reload_timer <= 0.0:
+        player_start_reload(player, state)
 
 
 def player_update(player: PlayerState, input_state: PlayerInput, dt: float, state: GameplayState, *, world_size: float = 1024.0) -> None:
@@ -1885,35 +1887,50 @@ def player_update(player: PlayerState, input_state: PlayerInput, dt: float, stat
         player.aim_heading = math.atan2(aim_dir_y, aim_dir_x) + math.pi / 2.0
 
     # Movement.
-    move_x, move_y = _normalize(float(input_state.move_x), float(input_state.move_y))
-    moving = move_x != 0.0 or move_y != 0.0
-    runner_bonus = 0.0
-    if perk_active(player, PerkId.LONG_DISTANCE_RUNNER):
-        if moving:
-            player.long_distance_runner_timer = min(1.2, float(player.long_distance_runner_timer) + dt)
+    raw_move_x = float(input_state.move_x)
+    raw_move_y = float(input_state.move_y)
+    raw_mag = math.hypot(raw_move_x, raw_move_y)
+    moving_input = raw_mag > 0.2
+
+    if moving_input:
+        inv = 1.0 / raw_mag if raw_mag > 1e-9 else 0.0
+        move_x = raw_move_x * inv
+        move_y = raw_move_y * inv
+        player.heading = math.atan2(move_y, move_x) + math.pi / 2.0
+        if perk_active(player, PerkId.LONG_DISTANCE_RUNNER):
+            if player.move_speed < 2.0:
+                player.move_speed = float(player.move_speed + dt * 4.0)
+            player.move_speed = float(player.move_speed + dt)
+            if player.move_speed > 2.8:
+                player.move_speed = 2.8
         else:
-            player.long_distance_runner_timer = max(0.0, float(player.long_distance_runner_timer) - dt * 15.0)
-        runner_bonus = max(0.0, min(0.8, float(player.long_distance_runner_timer) - 0.4))
+            player.move_speed = float(player.move_speed + dt * 5.0)
+            if player.move_speed > 2.0:
+                player.move_speed = 2.0
     else:
-        player.long_distance_runner_timer = 0.0
+        player.move_speed = float(player.move_speed - dt * 15.0)
+        if player.move_speed < 0.0:
+            player.move_speed = 0.0
+        move_x = math.cos(player.heading - math.pi / 2.0)
+        move_y = math.sin(player.heading - math.pi / 2.0)
+
+    if player.weapon_id == WeaponId.MEAN_MINIGUN and player.move_speed > 0.8:
+        player.move_speed = 0.8
 
-    speed_multiplier = float(player.move_speed_multiplier + runner_bonus)
+    speed_multiplier = float(player.speed_multiplier)
     if player.speed_bonus_timer > 0.0:
         speed_multiplier += 1.0
-    speed = 120.0 * speed_multiplier
+
+    speed = player.move_speed * speed_multiplier * 25.0
+    if moving_input:
+        speed *= min(1.0, raw_mag)
     if perk_active(player, PerkId.ALTERNATE_WEAPON):
         speed *= 0.8
+
     player.pos_x = _clamp(player.pos_x + move_x * speed * dt, 0.0, float(world_size))
     player.pos_y = _clamp(player.pos_y + move_y * speed * dt, 0.0, float(world_size))
 
-    if moving:
-        player.heading = math.atan2(move_y, move_x) + math.pi / 2.0
-
-    move_dist = math.hypot(player.pos_x - prev_x, player.pos_y - prev_y)
-    if move_dist > 1e-9:
-        # Port of `move_phase += frame_dt * move_speed * 19.0` (player_update).
-        move_speed = move_dist / dt / 120.0
-        player.move_phase += dt * move_speed * 19.0
+    player.move_phase += dt * player.move_speed * 19.0
 
     stationary = abs(player.pos_x - prev_x) <= 1e-9 and abs(player.pos_y - prev_y) <= 1e-9
     reload_scale = 1.0

{crimsonland-0.1.0.dev3 → crimsonland-0.1.0.dev5}/src/crimson/projectiles.py

@@ -220,6 +220,7 @@ class ProjectilePool:
         damage_scale_by_type: dict[int, float] | None = None,
         damage_scale_default: float = 1.0,
         ion_aoe_scale: float = 1.0,
+        detail_preset: int = 5,
         rng: Callable[[], int] | None = None,
         runtime_state: object | None = None,
         players: list[PlayerDamageable] | None = None,
@@ -280,6 +281,12 @@ class ProjectilePool:
         if rng is None:
             rng = _rng_zero
 
+        effects = None
+        sfx_queue = None
+        if runtime_state is not None:
+            effects = getattr(runtime_state, "effects", None)
+            sfx_queue = getattr(runtime_state, "sfx_queue", None)
+
         hits: list[tuple[int, float, float, float, float, float, float]] = []
         margin = 64.0
 
@@ -292,6 +299,90 @@ class ProjectilePool:
         def _damage_type_for() -> int:
             return 1
 
+        def _spawn_ion_hit_effects(type_id: int, pos_x: float, pos_y: float) -> None:
+            if effects is None or not hasattr(effects, "spawn"):
+                return
+
+            ring_scale = 0.0
+            ring_strength = 0.0
+            burst_scale = 0.0
+            if type_id == int(ProjectileTypeId.ION_MINIGUN):
+                ring_scale = 1.5
+                ring_strength = 0.1
+                burst_scale = 0.8
+            elif type_id == int(ProjectileTypeId.ION_RIFLE):
+                ring_scale = 1.2
+                ring_strength = 0.4
+                burst_scale = 1.2
+            elif type_id == int(ProjectileTypeId.ION_CANNON):
+                ring_scale = 1.0
+                ring_strength = 1.0
+                burst_scale = 2.2
+                if isinstance(sfx_queue, list):
+                    sfx_queue.append("sfx_shockwave")
+            else:
+                return
+
+            detail = int(detail_preset)
+
+            # Port of `FUN_0042f270(pos, ring_scale, ring_strength)`: ring burst (effect_id=1).
+            effects.spawn(
+                effect_id=1,
+                pos_x=float(pos_x),
+                pos_y=float(pos_y),
+                vel_x=0.0,
+                vel_y=0.0,
+                rotation=0.0,
+                scale=1.0,
+                half_width=4.0,
+                half_height=4.0,
+                age=0.0,
+                lifetime=float(ring_strength) * 0.8,
+                flags=0x19,
+                color_r=0.6,
+                color_g=0.6,
+                color_b=0.9,
+                color_a=1.0,
+                rotation_step=0.0,
+                scale_step=float(ring_scale) * 45.0,
+                detail_preset=detail,
+            )
+
+            # Port of `FUN_0042f540(pos, burst_scale)`: burst cloud (effect_id=0).
+            burst = float(burst_scale) * 0.8
+            lifetime = min(burst * 0.7, 1.1)
+            half = burst * 32.0
+            count = int(half)
+            if detail < 3:
+                count //= 2
+
+            for _ in range(max(0, count)):
+                rotation = float(int(rng()) & 0x7F) * 0.049087387
+                vel_x = float((int(rng()) & 0x7F) - 0x40) * burst * 1.4
+                vel_y = float((int(rng()) & 0x7F) - 0x40) * burst * 1.4
+                scale_step = (float(int(rng()) % 100) * 0.01 + 0.1) * burst
+                effects.spawn(
+                    effect_id=0,
+                    pos_x=float(pos_x),
+                    pos_y=float(pos_y),
+                    vel_x=vel_x,
+                    vel_y=vel_y,
+                    rotation=rotation,
+                    scale=1.0,
+                    half_width=half,
+                    half_height=half,
+                    age=0.0,
+                    lifetime=float(lifetime),
+                    flags=0x1D,
+                    color_r=0.4,
+                    color_g=0.5,
+                    color_b=1.0,
+                    color_a=0.5,
+                    rotation_step=0.0,
+                    scale_step=scale_step,
+                    detail_preset=detail,
+                )
+
         def _apply_damage_to_creature(
             creature_index: int,
             damage: float,
@@ -598,6 +689,8 @@ class ProjectilePool:
                     if type_id == ProjectileTypeId.ION_RIFLE:
                         if runtime_state is not None and getattr(runtime_state, "shock_chain_projectile_id", -1) == proj_index:
                             proj.reserved = float(int(hit_idx) + 1)
+                    if type_id in (ProjectileTypeId.ION_MINIGUN, ProjectileTypeId.ION_RIFLE, ProjectileTypeId.ION_CANNON):
+                        _spawn_ion_hit_effects(int(type_id), target_x, target_y)
                     elif type_id == ProjectileTypeId.PLASMA_CANNON:
                         size = float(getattr(creature, "size", 50.0) or 50.0)
                         ring_radius = size * 0.5 + 1.0