Yuma Yuma (YuYuma)
📎 1 file 2,382 chars
📄
pasted-code-1792444108259.txt
txt 48 lines
▶
Mod Name: Snappy First-Person

Description:
Create a Fabric mod for Minecraft that overhauls first-person hand and held-item animations. The goal is to create an immersive experience that feels much closer to vanilla, but with enhanced feedback and "game feel."

Crucial Aesthetic Direction:
The animations must be SHARP, SNAPPY, and MINIMALIST. Do NOT make them floaty, overly smooth, or bouncy like typical animation mods. Use fast, aggressive interpolation curves (e.g., exponential decay for returning to the idle position). They should feel grounded and responsive.

Technical Requirements:

    Use Mixins to hook into net.minecraft.client.renderer.ItemInHandRenderer (or HeldItemRenderer depending on mappings).

    Do NOT use or require custom 3D models or textures. Rely entirely on vanilla hand and item rendering.

    Ensure the code is performance-friendly and compatible with other mods that might change item rendering.

Features to Implement:

    Snappy Movement Sway:

        When walking or running, the item should bob subtly but with sharp, distinct movements, not a smooth sinusoidal wave.

        Strafing left and right should cause a slight, quick tilt of the item, snapping back into place instantly when stopping.

    Camera Turn Lag (Inertia):

        When looking around quickly, the hand/item should lag behind the camera slightly, but snap back to center VERY fast (fast damping). No lingering floaty feelings.

    Impactful Swings (Punchy-style):

        Modify the attack swing animation. It should have a sharp wind-up, a fast strike, and a very quick recovery.

        Different weapon classes (sword, axe, pickaxe, empty hand) should have slightly different, distinct snappy timings.

    Environment & Action Reactions:

        Crouching: Items should drop down snappily.

        Using items (eating, blocking): Make the transition into the use-state fast and solid.

        Jumping/Landing: A slight, sharp downward dip in the item position when landing on the ground.

    Idle Breathing:

        A very subtle, slow, mechanical breathing motion when standing completely still, so the hands don't feel frozen in place, but keep it minimal.

Configuration:
Include a simple config file (JSON or standard Fabric config) to tweak global animation speed, swing intensity, and toggle specific features like camera lag or idle breathing.
Kodari AI
KodariOct 19 at 9:20 pm 3
SnappyFirstPerson
Creates a Fabric Minecraft mod overhauling first-person hand and held-item animations with sharp, snappy, minimalist movement. Uses Mixins to hook ItemInHandRenderer for aggressive interpolation curves and fast exponential decay. Implements dynamic movement sway, instant camera turn lag with rapid damping, impactful weapon-specific swing timings, snappy crouch/use/jump reactions, and subtle idle breathing. Relies entirely on vanilla models and textures. Includes a JSON config for tweaking animation speed, swing intensity, and toggling specific features like camera lag or idle breathing while remaining performance-friendly and compatible with other rendering mods.
  1. Build the Fabric 26.3 mod scaffold and config.

  2. Add client-only mixins for snappy first-person motion and punchier swings.

  3. Register the mixins and document the survival-free client mod setup.

Created Snappy First-Person, a client-only Fabric 26.3 mod with sharp movement sway, camera-turn lag, distinct punchy swing accents for empty hands, swords, pickaxes, and axes, plus crouch, use, landing, and subtle idle reactions. It uses vanilla rendering with no custom models or textures.

The editable config/snappy-first-person.properties is generated on first launch. It includes global animation speed, swing intensity, and individual feature toggles.

No survival items or blocks are added; the mod changes only the client’s first-person animations.

Yuma Yuma (YuYuma)
📎 1 file 1,565 chars
📄
pasted-code-1792445393973.txt
txt 15 lines
▶
The mod loads successfully in Minecraft 26.3 without crashing, but there are ZERO visual changes in-game. The log shows no errors, which means it's a silent failure. The Mixin is likely failing to find the target method but is being ignored because it's not marked as required.

Please fix the following:

    Force Mixin Crash: Open mixins.json and change "required": false to "required": true for our mixin. This way, the game WILL crash on launch if the target method signature is wrong. This will give us the exact error log we need.

    Check Target Method: The method signature for ItemInHandRenderer in recent versions is highly specific. Verify the exact method name and descriptor (e.g., renderItem, renderHandsWithItems). Use @Inject(at = @At("HEAD"), method = "Lnet/minecraft/client/renderer/ItemInHandRenderer;renderHandsWithItems(...)V", cancellable = true) and ensure the mapping is correct.

    Add Debug Logging: Add LOGGER.info("SNAPPY ANIMATIONS MIXIN APPLIED!") at the very beginning of the injected method. I need to see this in the console.

    Hardcode Math: Temporarily remove any checks for walking/jumping. Just apply a massive offset (e.g., matrices.translate(0.0, 0.5, 0.0)) in the mixin. If the item still doesn't move, the mixin is not applying at all.

    Check Dependencies: Ensure the mod doesn't require Cloth Config or Mod Menu to initialize its config. If it does, either bundle a simple JSON config without external dependencies or hardcode the default values.

Please output the updated mixins.json and the Mixin Java class.
Kodari AI
KodariOct 19 at 9:36 pm 1
  1. Inspect the existing mixin and its registration.

  2. Verify the 26.3 render hook and matrix APIs against the mounted source.

  3. Patch the hook as required and add a one-time activation log plus a visible diagnostic offset.

The 26.3 target is FirstPersonHandsAndItemsRenderer.submitHandsWithItems(...), not the older ItemInHandRenderer.renderHandsWithItems(...). The source confirms it uses the supplied pose stack.

snappy-first-person.client.mixins.json already has "required": true and "defaultRequire": 1, and fabric.mod.json registers it as a client mixin config, so I left it unchanged. I updated the mixin to log once and apply the requested temporary 0.5-block offset. The existing push/pop keeps that diagnostic transform scoped to the render call.

On launch, look for SNAPPY ANIMATIONS MIXIN APPLIED! and the visibly shifted hands/items. Remove the diagnostic offset after confirming the hook works.

Yuma Yuma (YuYuma)

The Mixin works! The item shifted up, and I can see a small jitter when walking. Now please remove the diagnostic 0.5-block offset and implement the FULL animation set as described.

Style Note: Do NOT make animations floaty/smooth like typical animation mods. Every transition should return to the idle pose FAST (aggressive damping). Aim for a "snappy shooter / stylized FPS" feel — quick, distinct poses, minimal overshoot, no lingering wobble.

Please implement these SEPARATE animation states, each with its own logic:

Idle: Very subtle breathing motion (small slow sine wave on Y-axis, amplitude ~0.005). Barely noticeable, just so hands aren't frozen.

Walk: Distinct rhythmic bob synced to player walk speed. Side-to-side (X) and up-down (Y) tilt. NOT a smooth sine — use a snappier curve. Amplitude should scale with movement speed.

Sprint: Stronger version of walk, plus a slight forward tilt (item angled more toward the ground) and a faster bob frequency.

Jump: When player jumps, item quickly dips down then returns. Sharp snap, not floaty.

Fall / Airborne: Item floats up slightly, swaying gently. Should feel "weightless".

Landing: Sharp downward dip on landing, then fast snap back to idle. This is the "impact" moment — should feel weighty.

Crouch: Item quickly lowers and tilts slightly. Snappy transition.

Attack Swing: Sharp wind-up (fast, ~2 ticks), fast strike, quick recovery. Different timing for sword/axe/pickaxe/fist. Add a small screen-shake-like rotation on hit.

Camera Lag (Inertia): When turning the camera quickly, item lags behind slightly. Return to center should be FAST — no lingering float. This is the immersive touch.

Item Use (eating/blocking): Item moves to a distinct "use pose" quickly, holds, then returns fast when released.

Configuration: Ensure ALL of these can be toggled and tuned via a JSON config file (amplitude, speed, enable/disable per state). Use a simple JSON config so I don't need extra dependencies like Cloth Config.

Kodari AI
KodariOct 19 at 10:20 pm 3
  1. Map the existing client mixin and config so the animation changes fit the current project.

  2. Verify the 26.3 render/player/pose APIs from source.

  3. Replace the diagnostic offset with configurable, state-specific snappy animations.

Implemented the full animation set and removed the temporary 0.5-block diagnostic offset.

Walking and sprinting now use speed-scaled, sharper bob and tilt; jumping, airborne motion, landing, crouching, item use, camera lag, and idle breathing each have separate behavior. Swings have distinct timing for swords, axes, pickaxes, and empty hands, with a brief impact rotation.

The mod now creates config/snappy-first-person.json on launch. Each state has an enable toggle and amplitude/speed controls, with a global animation speed; no Cloth Config or other dependency is required.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
gradle.properties
settings.gradle
Code
8 573
src/client/java/dev/kodari/snappyfirstperson/SnappyFirstPersonClient.java
package dev.kodari.snappyfirstperson;

import net.fabricmc.api.ClientModInitializer;

public final class SnappyFirstPersonClient implements ClientModInitializer {
	@Override
	public void onInitializeClient() {
		AnimationConfig.load();
	}
}