Asset Store newest packages

• A variaty of visuals, such as dots, lines, circles, and spheres.
• A simple API requiring no setup.
• Works both in the editor and stand alone builds.

DebugDraw is a runtime drawing toolkit for rendering shapes and visual aids directly in the world to support development and debugging. It enables clear visualization of gameplay systems such as physics interactions, AI behavior, targeting logic, pathfinding, spatial queries, and more.

The package provides a wide range of drawable shapes and utilities with a simple, consistent API. Drawing behavior can be customized through parameters such as color, duration, depth handling, and other visual options, allowing it to adapt to different workflows and project needs.

Documentation

[⚓ ARCHITECTURE]

• GUID Identity: Every event retains a unique ID in its .meta file. Renaming or moving assets never breaks scene references.
• Full Generic Support: GameEvent (no args), GameEvent<T>, GameEvent<TSender, TArgs>
• Multi-Database Management: Modular organization with dynamic loading and category-based fuzzy search.
• Folder-Move Protection: Automatically intercepts illegal asset moves to prevent broken references.
• Static Variable Auto-Reset: Uses [RuntimeInitializeOnLoadMethod] to clean internal caches and prevent editor play-mode data pollution. (v1.0.2 deeply refactored for Tuanjie Engine & Unity 6)[🕸️ NODE GRAPH & LOGIC]
  
• Expression Tree Compiler: Conditions compile into high-performance delegates (System.Linq.Expressions) — zero reflection overhead.
• Visual Logic Builder: Build complex nested AND/OR logic and dynamic object property comparisons without code.
• Hybrid Execution: Seamlessly mix fire-and-forget parallel triggers with blocking serial chains.
• Argument Transformers: Dynamically extract and pass specific object properties between flow nodes.
• Flow Gates: Built-in support for "wait for completion", "wait for frames", and conditional execution gates.
• Undo/Redo: Snapshot-based history system custom-built for the node editor.[🎧 BINDING & SCRIPTING]
  
• Visual Binding: Wraps UnityEvent with zero-code drag-and-drop callback binding and type-safe runtime indicators.
• Priority System: Integer-based sorting ensures critical logic (UI, audio) executes in the correct order.
• Persistent Listeners: Native cross-scene listeners that remain active across scene transitions.
• Runtime API: Full programmatic control for registering/unregistering listeners and managing DelayHandle / TaskHandle.[📜 AUTOMATION]
  
• Triple CodeGen Modes: Auto-generates concrete classes for base types, custom types, and sender-aware types — resolving Unity's generic serialization limits.
• Delay & Repeat: Built-in timed signals with cancellable handle management.
• Async Awaiting: Event chains can await Coroutine or Async task completion before continuing.[📊 DEBUGGING & PERFORMANCE]
  
• Runtime Monitor: Live profiling of execution time (avg/min/max), listener count, and GC allocation.
• Tree Visualizer: Real-time view of active triggers and chain hierarchies for debugging complex logic flows.
• Scene-Wide Reference Finder: Scans the current scene to locate component-level event dependencies.
• | Action | Performance | Note | | :--- | :--- | :--- | | Event Raise (0 listeners) | ~0.001ms | Near-zero overhead | | Event Raise (10 listeners) | ~0.02ms | Zero GC allocation | | Logic Condition Evaluation | ~0.003ms | Expression Tree optimized | | Platform Compatibility | IL2CPP & Mono | Fully optimized backends |Deep Logging: Full timestamps, frame counts, argument values, and stack traces.[🚀 PERFORMANCE BENCHMARKS]
  

🚀 Stop Fighting Spaghetti. Start Building with Clarity.

Game Event System (GES) is an industrial-grade productivity tool built for developers who refuse to choose between visual clarity and runtime performance. It combines the convenience of a visual node graph with the raw power of native C# — giving your project a robust, scalable nervous system.

❤️ Your project deserves professional architecture. 🔥 Fully supports Unity 6 Enter Play Mode (No Domain Reload) & Tuanjie Engine.

📢 Notice for Legacy Users (Important)

I'm back! Due to regional policy adjustments, GES was migrated to this new listing.

Are you a previous owner of the legacy GES? I value your support! If you purchased the previous version and need to migrate to this new listing or claim your community activation code, please join TinyGiants Discord Community. I'll dedicate to verify your proof of purchase and ensuring you have seamless access to all future updates.

🚀 Service & Support Matrix

• 🏠 TinyGiants Portal
• 📘 Technical Documentation
• 💬 Discord Community — Claim legacy activation codes here!
• 🎥 YouTube Channel
• 🎮 Unity Forum Thread
• 🐙 GitHub Organization

🛠️ Core Features

• ✨ Asset-Driven Event Architecture: ScriptableObject-based with GUID protection. Rename files, move folders — references never break. Say goodbye to "Missing Reference" errors.
• 🕸️ Visual Flow Orchestration: A powerful, zoomable node editor. Design complex event chains, parallel triggers, and sequential logic in a single window.
• ⚡ Zero-Reflection Performance: Powered by Expression Tree compilation. Logic conditions compile into native delegates at runtime — delivering C++-like execution speed with zero GC allocation.
• 🧠 Advanced Logic Builder: Build nested AND/OR logic groups and dynamic property comparisons — without writing a single line of code.
• 🎧 Professional Event Binding: Drag-and-drop UnityEvent wiring with type-safe indicators. Includes priority execution and conditional listeners.
• ⏳ Fine-Grained Flow Control: Native support for Delay, Loop, Async/Coroutine awaiting, and conditional gates.
• 📜 Automated CodeGen Pipeline: A unique triple-mode generator that automatically resolves Unity's generic serialization limitations.
• 🛡️ Industrial-Grade Toolchain: Built-in scene-wide reference finder, batch creation wizard, and database health checker.

💪 Who Needs GES?

• 🎯 Solo Developers — Eliminate spaghetti code from day one.
• 🏆 Professional Teams — A centralized, searchable, maintainable event database.
• 🎨 Technical Artists & Designers — Trigger and manage complex logic without writing C#.
• 🚀 Performance-Critical Games — Competitive games, large unit counts, high-throughput projects.

📦 Technical Specs

• Architecture: ScriptableObject-based with GUID protection
• Generic Support: Void, GameEvent<T>, GameEvent<TSender, TArgs>
• Performance: Expression Tree compiler — zero reflection overhead at runtime
• Workflow: Dashboard-style manager with fuzzy search and batch operations
• Platforms: PC, Mobile, Console, WebGL (IL2CPP & Mono)

🏆 A Note from the Developer

"I built GES because I was tired of fighting invisible code dependencies. This isn't just a plugin — it's the architectural foundation I use every day in my own game development. Thank you for staying with me through my store migration. Let's build something great together." — Tino, TinyGiants

• Unity Version: 2022.3 LTS or newer
• Render Pipelines Supported: URP & HDRP
• Target Platforms: PC & Console
• Asset Count: 9 prefabs
• Poly Range: 950 – 14,161 triangles
• LODs: LOD0–LOD2 included
• Texture Resolution: 2K
• Material Workflow: Mask-driven PBR materials
• Material Variants: Engineer Yellow, Neutral Grey, Desert Beige (Clean & Worn)
• Demo Scene Included
• Interaction Logic: No gameplay systems are included. Assets are designed as production-ready building blocks intended to integrate with custom scripts, animation systems, or gameplay frameworks.

Frontier – Field Power Distribution is a modular sci-fi infrastructure asset pack designed to connect power generation with powered equipment in system-driven environments.

The pack includes a portable field transformer together with modular raw-energy and standardized power connectors, enabling developers to build believable energy networks between generators, energy storage systems, and powered devices.

Ideal for projects involving:

• engineering systems
• deployable infrastructure
• exploration or survival gameplay
• environmental storytelling

Assets are production-ready and designed for clean integration into existing gameplay systems or environment setups.

Designed for System-Driven Worlds

Field Power Distribution represents the distribution layer within a modular energy ecosystem.

Example system chain:

Portable Field Generator → Field Power Distribution → Tools / Workstations / Infrastructure

This makes the asset suitable for developers building energy systems, engineering mechanics, or frontier infrastructure within their projects.

Included Assets

Power Distribution Unit

• Field Power Converter (hero asset)
• Mounted Power Converter
• Power Converter Stand

Raw Energy Connectors

• Raw Connector – Male
• Raw Connector – Female
• Raw Connector – Wall Mount

Standard Power Connectors

• Standard Connector – Male
• Standard Connector – Female
• Standard Connector – Wall Mount

Production Features

• Optimized meshes with clean shading for real-time rendering
• Consistent Frontier visual language and scale
• Modular asset design suitable for system-driven environments
• LODs included for performance optimization
• Mask-driven customizable PBR materials
• URP and HDRP support

Materials & Customization

Assets use a flexible mask-driven PBR material workflow designed for real-time rendering and efficient customization.

Adjustable parameters include:

• Color tint layers
• Text / symbol overlays
• Smoothness, metallic, and clearcoat
• Wear, rust, and dirt control
• Surface color and normal variation
• Emission color and intensity for powered elements

Material color variants: Engineer Yellow, Neutral Grey & Desert Beige (clean & worn)

A Unity-specific Frontier Material Helper tool is included to simplify material assignment and variant management.

Number of Audio Wavs: 7

Sample rate / bit rate: 16 Bit, 44,100 Hz

Minutes of audio provided: 21

Pack of Trap Beats For Games

❮❮❮❮❮ TRACK LIST ❯❯❯❯❯

1) Fame

2) This Means War

3) Unstoppable

4) Selfless

5) Midnight

6) Fearless

7) Penthouse

❮❮❮❮❮ YOUTUBE NOTICE ❯❯❯❯❯

Our music is registered with YouTube's Content ID system. If you upload a video featuring our music to YouTube, you may receive this notice: "Copyright-protected content found. The owner allows the content to be used on YouTube." This is not a copyright strike. It is a standard notification that does not harm your channel's status or mute your video's audio. You can learn more about this here: https://composersquad.com/contentid

Number of textures : 1

Texture dimensions : 512 × 512

Polygon count : Excavator – 5,517

Number of meshes/prefabs : 4 Prefabs

UV mapping : Yes

Texture maps : Base Color

Compatible with most Unity versions and suitable for games, simulations, and visualization projects.

This stylized low-poly excavator asset is designed for construction and industrial environment scenes. It is suitable for games, simulations, and real-time applications.

The track wheels are separated, allowing you to create moving track effects if needed. The upper and lower parts of the excavator are also separated, allowing the upper structure to rotate for more realistic construction vehicle movement.

Please note that this asset does not include built-in animations.

The model features clean topology and an optimized mesh, making it lightweight and suitable for real-time projects such as games, simulations, and environment building.

This asset may also be included in a 5 construction vehicle bundle package, so it may appear in multiple packages.

Mesh Combiner Window is a tool designed to combine multiple MeshFilters into a single mesh while maintaining control over the pivot and the submeshes.

The tool allows you to quickly gather meshes from selected objectsm combine them into a single mesh and save the mesh. It also provides control over the pivot and how to merge the submeshes, making it useful for level optimization.

It is particulary useful when working with grayboxing, optimizing levels or with imported meshes that require pivot fixes and cleanup.

It comes with a Documentation PDF.

Key Features

• Mesh selection tools, to easily select the meshes directly from the hierarchy.
• Submeshes handling modes, choose how materials are handled when the meshes are combined.
• Pivot control, you can define exactly where the pivot of the combined mesh should be.
• Scene visualization options, it has a gizmos for the pivot and a button to focus on it.

Typical Use Cases

• Combining group of meshes to reduce draw calls.
• Fixing the pivot of a mesh.
• Preparing meshes for prefabs or level assets.
• Creating optimized mesh assets directly from scene geometry.

Textures: 18 (URP + HDRP)

Texture scale: 2K

Vertices

• 104 (chain link)
• 1976 (chain)
• 80 (key)
• 114 (lock)
• 136 (lockLatch)

Meshes: 6

Prefabs: 4

Rigging: yes, on chain

Animations: 0

UV mapped: yes

Lods: 0

Materials: PBR

Trailer/tutorial: https://youtu.be/-MmzIt8XLFY

Nice looking lock & chain with 3 texture sets (2K).

This lock can be used many times in the same level with different keys you can set up.

Find the right key & walk near the lock and it will be unlocked !

In other hand, if you are in a hurry you can shoot/break the lock.

Works by collision or raycasting.

Setup:

• Drag lock-prefab to your level
• Set "LockID"
• Drag key-prefab to your level
• Set "keyID" to same as the "LockID" in your lock
• Walk near the key to add it to your inventory (script inside your player, check tutorial)
• Walk near the lock to unlock it

Note:

As I dont know how doors work in your game, you have to code the interraction with the lock yourself.

Included: Breakable lock-prefab

Included: Key -prefab

Included: Posable chain -prefab

Included: 3 texture sets (2K, URP + HDRP)

Included: URP DemoLevel

Extra: shooting script example

• Grid slicing — configurable rows and columns slice the source sprite into individual fragment particles; optional scatter offset randomizes starting positions
• 9 launch directions — Radial, Up, Down, Left, Right, and four diagonals, each with an adjustable spread angle
• Physics-style motion — explosion force, gravity multiplier, speed modifier, burst impulse, decay sharpness, and velocity retention give fine control over how fragments move and slow down
• Scale on impact — fragments punch outward with a configurable scale peak at burst, then settle back down
• Turbulence (Noise) — strength, frequency, and scroll speed controls add organic drift to fragment paths
• Limit Velocity — cap max fragment speed with a separate dampen value
• Color tint + flash — optionally shift all fragments to a tint color and trigger a flash at the moment of burst
• Trails — per-fragment trails with independent width, lifetime, and color
• Collision — world-collision support with dampen and bounce coefficients, layer mask selection
• Mask materials — apply shape-mask materials to fragments in Random or Sequential order, loaded from a dedicated asset folder
• Lifetime & rotation — independent min/max lifetime and rotation-over-lifetime ranges; optional random start rotation
• Loop mode — optional looping with manual duration override
• Live preview — built-in PreviewRenderUtility viewport with Play / Pause / Stop controls, no need to enter Play Mode
• Batch tab — bake multiple sprites in one pass
• Preset system — built-in factory presets plus unlimited user presets, persisted via EditorPrefs; supports save, rename, and delete
• Clean output — bakes to a standard UnityEngine.ParticleSystem prefab; optional auto-delete of the previously baked object

Sprite Shatter FX is a small editor tool where you drop in a sprite and get a ready-to-use Particle System out of it. No scripting needed.

The sprite is sliced into a grid of fragments that can explode outward, rotate, fade, and settle depending on how you set things up.

There are five built-in presets to start from: a hard crash, a slow fade, a fiery burst, an icy splinter, and a neutral base.

They’re just starting points — you can tweak them, save your own versions, and switch between presets without losing your current setup.

The tool is meant to fit into existing workflows without much friction. It works for hit effects, UI transitions, collectibles, puzzle elements — basically anywhere a static sprite feels a bit flat.

The result is a standard Unity Particle System prefab, so it plugs directly into scenes and animations.

Note: Masking does not work on Built-In.

• One-click workflow automation for Unity
• Reusable jobs and unlimited presets
• Shareable presets across multiple projects
• Built-in handling for editor restarts and script recompilation
• Pause and resume support during execution
• Built-in file, package, and project settings tasks
• Fresh project setup and configuration workflows
• File and asset cloning with .meta file skipping
• Folder setup, file creation, and project backup workflows
• Expandable system with support for custom tasks, custom UI, and custom workflow logic

Task Automator is a flexible workflow automation system for Unity that turns repetitive setup and production steps into reusable jobs you can run in one click.

With one click, you can:

• Initialize and configure a fresh project automatically
• Import your packages and tools, then remove unneeded ones
• Clone files and assets across different projects or locations without .meta files
• Set up folders, structure, and required project files
• Create a full backup of your project or selected files with ease.
• Apply project settings with less manual work

Out of the box, Task Automator includes tasks for cloning, creating, deleting, and moving files, handling package import and removal, changing input type, and applying project settings.

• Create unlimited presets for different roles and purposes, then reuse and share them across multiple projects and teams.
• Task execution can also be paused and resumed, with built-in support for editor restarts and script recompilation.
• Track task execution with step-by-step logs for faster debugging.

Task Automator is also expandable, allowing you to create custom tasks, custom task UI, and workflow logic for your own pipeline. 

For example, you could create a task that switches from dev mode to release mode, builds for selected platforms, then switches everything back automatically.

DISCORD | DOCUMENTATION

Included:

• Resources(Script, vfx asset, texture)
• 1x Prefab
• Demo Scene
• Documentation

Note: The character and its controller are not included.

* When you open the demo scene in HDRP, it will appear pink. However, this is not important and is entirely related to the demo scene itself. The particles will work without any issues. If you still want to view them in the demo scene, you can create a new material and drag and drop it onto the plane object.

🌨️ Procedural Snow Particles is an advanced particle system designed to create high-performance and realistic snow simulations in your Unity projects.

Unlike static effects, its procedural approach dynamically generates snowfall that adapts to environmental conditions. This ensures a unique and natural look in every scene.

🔹 Key Features:

• Procedural snow generation (non-repetitive and natural appearance)
• Wind direction and intensity control
• Adjustable snow density
• Adjustable kill zone
• Optimized performance
• Easy integration and use
• Modular structure (adapts easily to different scenes)
• URP & HDRP
• 2022+ & Unity 6.x

🔹 Use Cases:

• Games (winter-themed environments)
• Simulation projects
• Cinematic scenes and cutscenes

Add a stunning winter atmosphere to your project with just a few clicks!

Included:

• 2x Shader (Perpective & Orthographic)
• 2x Material
• Demo Scene
• Documentation

Notes

Tranparant Shaders: Transparent materials are not written to the depth buffer, so they are rendered last. Because of the rendering order, objects using transparent shaders (such as water shaders) may become invisible. Therefore, avoid using transparent shaders. However, you can use alpha clipping instead.

Anti-Aliasing: Using additional anti-aliasing is not recommended, as it can distort the pixel structure and negatively affect visual quality.

Thin Objects: Very small details such as wires, grass, or thin fences may disappear or render incorrectly during pixelation. You may need to thicken or scale such models.

Subpixel Limitation (Perspective Camera): Due to perspective projection, perfectly stable (grid-locked) pixel alignment is not possible. Objects at different depths move at different speeds, which can cause slight shifts.

Distance-Based Pixelator (URP)

A dynamic pixelation system based on distance. It pixelates objects in the scene at different resolution levels depending on their distance from the camera. Designed specifically for perspective cameras, it provides separate resolution control for each distance range. This way, you can pixelate all your 3D scenes.

✨ Features

Distance-Based Pixelation

Each pixel is rendered at a different level of pixelation based on its distance from the camera. You have full control over which resolution is applied at specific distances.

Perspective Camera Support

Not dependent on orthographic projection. Works seamlessly with perspective cameras to deliver a natural, depth-aware pixelation effect in 3D scenes. Orthographic mode is also supported.

Customizable Distance Mapping

You can manually adjust threshold values for each distance range in the scene.

Level-Based Resolution Control

Define a unique pixel size for each distance level. This allows closer objects to appear sharper while distant objects appear at lower resolution.

No Shader Required

Works with your existing materials without requiring any shader modifications.

Easy installation

You can set it up in just a few seconds and start using it right away.

🧩 Supported Versions

• Unity 6.x
• Unity 2022+ (not tested with 2021, but likely compatible)

File Count: 30x seamless dirt mask

Resolution: 4K

This package includes 30 dirt masks that can be used in all game engines and all 3D software. All textures are in 4K resolution and are seamless. They can be easily scaled, and their transitions are flawless. You can use the dirt masks in fullscreen effects, camera effects, shaders, VFX, and any other effects you create. Additionally, the textures are designed to be used in reverse, meaning you can invert them to effectively obtain 60 dirt textures.

File Formats
All textures are provided in widely supported formats such as PNG, ensuring smooth compatibility with industry standard tools and engines, including Unreal Engine, Unity, Blender, Godot, Maya, and 3ds Max.

This pack is built to adapt to your workflow, no matter which software you use, making it a powerful addition to any artist’s toolkit.

Technical Details

• Render Pipeline: Universal Render Pipeline (URP)
• Shader Type: Shader Graph
• Customization: Fully customizable parameters (color, intensity, length, glow)
• Performance: Lightweight and optimized for real-time use
• Materials Included: 1
• Demo Scene: Included
• Dependencies: Requires Unity Shader Graph
• Compatibility: Unity 2022 or newer recommended (versions before 2022 have not been tested, but they should still work)

Customizable Jet Thruster Shader is a real-time, fully customizable jet thruster effect created using Unity Shader Graph. It is designed for visual effects such as spaceship engines, rockets, jet thrusters, and other sci-fi propulsion systems.

The shader provides easily adjustable parameters that allow the effect to react to speed, power, or gameplay states. It can be modified directly through Shader Graph without writing code, making it easy to adapt to different projects.

Features

🚀 Fully Customizable Jet Effect

🎨 Adjustable color, intensity, and length

⚡ Drag and drop, easy to use

🔧 Built with Shader Graph for easy editing

🎮 Ideal for thrusters, rockets, and jet engine VFX

💡 Lightweight and performance-friendly

🎯 Platforms: PC, Console, Mobile (depending on project optimization)

Use Cases

• Spaceship engines
• Rocket thruster effects
• Jet engines
• Sci-fi vehicle VFX

With the exposed shader parameters, you can easily control the flame color, intensity, length, and brightness, allowing you to create different visual styles.

Bring realistic combat reactions to your game with the Combat Knockdown & Recovery Animation Pack.

This pack provides a complete set of animations for handling hits, knockdowns, ground states, recovery, and death reactions, allowing developers to build believable combat systems where characters react naturally to powerful attacks.

The animations are designed to support a full gameplay flow:

This makes the pack ideal for action games where characters can be knocked down, remain on the ground briefly, react to additional hits, and either recover or die.

All animations were carefully hand-crafted in Autodesk Maya, with clear body mechanics and consistent motion to ensure smooth integration into gameplay systems.

🎥 Video Preview

Watch the full technical showcase here: [YouTube Video]

For questions, support, or feedback:

📩 raisecreation14@gmail.com

This pack includes 50+ animations, covering multiple knockdown styles and ground reaction states.

Each knockdown style includes a full reaction cycle:

• Knockdown
• Ground Idle
• Ground Hit Reaction
• Get Up / Recovery
• Death

This modular structure allows developers to build flexible combat systems with different outcomes after a knockdown.

Knockdown Variations Included

The pack features multiple knockdown styles to represent different types of combat impacts.

Included reactions:

• Front knockdown
• Back knockdown
• Left knockdown
• Right knockdown
• Heavy knockdown
• Push knockdown
• Spin knockdown
• Uppercut knockdown
• Downward knockdown

These variations allow characters to respond differently depending on the type and direction of the attack

Ground State Animations

After a knockdown, characters can remain on the ground briefly in different states.

Ground states include:

• Ground idle poses
• Ground hit reactions while down
• Injured ground states

These animations allow developers to create gameplay where enemies can be attacked while down or recover after a short delay.

Recovery & Get-Up Animations

Multiple recovery animations allow characters to stand back up after being knocked down.

Recovery types include:

• Standard get-up
• Directional get-up animations
• Heavy recovery reactions

These help maintain smooth transitions back into combat.

The pack also includes ground death animations, allowing characters to remain down and die after receiving additional damage.

This makes the pack useful for both combat knockdowns and final defeat sequences.

Root Motion & In-Place Versions

To support different development workflows, the pack includes:

• In-Place animations – ideal for gameplay systems where movement is controlled by code or physics.

• Root Motion animations – useful for cinematic knockdowns or gameplay systems driven by animation movement.

This gives developers flexibility depending on their project needs.

Key Features

✔ 50+ high-quality combat reaction animations
✔ Complete knockdown and recovery system
✔ Multiple directional knockdowns
✔ Ground idle and ground hit reactions
✔ Get-up and recovery animations
✔ Death variations included
✔ Both In-Place and Root Motion versions
✔ Hand-crafted in Autodesk Maya
✔ Clean FBX files ready for game development

Total Number of Animations: 48

Animation types : In_place, Root_motion

A custom skeleton rig

Windows: (Yes)

Mac: (Yes)

Bring fast, stylish anime combat to your game with the Anime Dual Dagger Combat Animation Pack. This pack features a wide range of dynamic dual-dagger attacks designed for anime-style combat systems, assassin characters, rogues, ninjas, and agile fighters.

The animations focus on speed, agility, and fluid combo chains, capturing the energy and exaggerated movement typical of anime action combat. Characters perform rapid slashes, aerial attacks, spinning combos, dash strikes, and powerful finishing moves using two daggers.

These animations are perfect for creating anime action combat systems, character abilities, or fast-paced melee gameplay in RPGs, action games, anime-inspired games, or stylized combat systems.

The pack includes both in-place and root motion versions, giving developers flexibility depending on their gameplay system.

🎥 Video Preview

Watch the full show-reel here: [YouTube Video]

Total Animations

This pack contains 48 animations in total.

These include:

• Core combat attacks
• Combo chains and combo finishers
• Dash and run attacks
• Aerial combat attacks
• Defensive animations
• Hit reactions and death animation
• Locomotion animations
• Root Motion versions of key combat moves

This allows developers to build a complete anime dual-dagger combat system for their characters.

Animation Categories

Combat Attacks

Fast dual dagger attacks designed for anime-style combat.

Examples include:

• Standard attack combos
• Cross slash attacks
• Double dagger strikes
• Rapid combo chains
• Powerful finishing attacks

These animations allow developers to create fast melee combat gameplay.

Combo Attacks

Multiple combo chains are included to create fluid anime-style combat.

Examples:

• combo string attacks
• triple combo chains
• combo finisher strikes
• multi-hit attack sequences

These animations allow characters to perform continuous combo combat similar to anime action games.

Mobility Attacks

Anime combat often relies on speed and movement.

This pack includes:

• dash attacks
• run attacks
• jump attacks
• jump dash attacks

These help create high-speed anime combat mechanics.

Aerial Combat

Several animations allow characters to attack while airborne.

Examples include:

• aerial combo attacks
• jump attacks
• aerial dash strikes

These help create dynamic anime-style combat movement.

Special Anime Attacks

Stylized special attacks give characters powerful dramatic combat moves.

Examples:

• swirl attacks
• rotating slash attacks
• powerful smash attacks

These moves add anime-style flair and cinematic action.

Defensive Animations

Defensive actions allow characters to react to enemy attacks.

Included animations:

• block
• block hit reaction
• dodge left
• dodge right

These help integrate the animations into full combat systems.

Character Reactions

To complete the combat flow, the pack includes:

• hit reaction animations
• death animation

These are essential for gameplay interactions.

Locomotion

Basic movement animations are included for smooth gameplay integration.

Examples:

• idle combat stance
• walk
• run
• run to idle transition
• jump

Root Motion Versions

Several key combat animations are also included with Root Motion versions.

These allow the character to move naturally during attacks such as:

• aerial combos
• dash attacks
• combo chains
• special attacks

Root motion helps create more cinematic and powerful attack movement.

Perfect For

This pack is ideal for:

• anime action games
• RPG combat systems
• ninja or assassin characters
• rogue style fighters
• stylized melee combat
• anime inspired game projects

The animations are designed to work well for agile dual-weapon fighters.

Software

All animations were created and animated in Autodesk Maya.

They can be used in multiple game engines and pipelines including:

• Unreal Engine
• Unity
• other game engines that support humanoid animations

Support

If you have questions or need support, feel free to contact:

raisecreation14@gmail.com

Total Number of Animations: 49

Animation types : In_place, Root_motion

A custom skeleton rig

Windows: (Yes)

Mac: (Yes)

This pack includes Brutal Unarmed Finisher animations designed for intense hand-to-hand combat gameplay. These animations are perfect for action, stealth, survival, and melee combat systems.

The pack contains 24 finisher animation sets, each including Attack and React animations, resulting in a total of 48 animations for use with player and enemy characters.

All animations are created and animated in Autodesk Maya and are suitable for a wide range of gameplay scenarios. They can be used for combat systems, finishing moves, takedowns, cinematic gameplay moments, or other creative implementations.

React animations use the following transform values: TZ: -124, RY: 180

All animations included in this pack can be viewed in the Animations Show-reel Video.

If you have any questions or need support, feel free to contact:

raisecreation14@gmail.com

👊 WHY BARE-HANDED FINISHERS?

• Universal Application: Works for heroes, villains, enemies, civilians—any humanoid character
• No Weapon Clipping: No weapon models needed, no clipping issues
• Intimate & Brutal: Hands-on kills feel personal and terrifying
• Any Genre: Fantasy, sci-fi, modern, horror—all work
• Player Character Ready: Let players execute enemies with their bare hands

Perfect For

This animation pack is ideal for:

• Action games
• Stealth gameplay systems
• Finisher / execution mechanics
• Enemy takedown systems
• Melee combat systems
• Survival and horror games
• Cinematic combat moments

24 UNIQUE FINISHER ANIMATIONS

• Kick Finishers – Axe kicks, front kicks, roundhouse, spinning heel, flying knee
• Ground Stomps – Head stomps, chest stomps, double stomps, jump stomps
• Neck & Head – Neck snaps, skull crushes, jaw rips, head twists
• Choke & Suffocation – Standing choke, lifted choke, smothering
• Body Breaks – Spine breaks, rib crushes, body slams

🌐 Join the GanzSe Community

👉 Discord — GanzSe Workshop

Looking for more? Сheck out this matching environment packs:

GanzSe Fishing Harbor – Stylized Low Poly Environment

🗿 Looking for a ready-to-use stylized ruins environment for your fantasy project?

GanzSe Forgotten Hallowed Ruins is a handcrafted stylized environment pack designed to help you quickly build atmospheric ancient locations, abandoned temples, ceremonial arenas, and forgotten civilizations.

The pack provides a complete modular ruins system, allowing you to assemble flexible layouts for exploration areas, ritual sites, arenas, or ruined settlements without complex setup.

🧱 What’s inside:

✔️ Modular ruins architecture pieces (walls, arches, stairs, platforms, columns)

✔️ Broken ruins fragments and destruction pieces for environmental storytelling

✔️ Stone paths, floors, and structural elements for flexible layouts

✔️ Nature assets including trees, bushes, grass clusters, flowers, and ivy

✔️ Terrain and ground tiles to quickly shape natural environments

✔️ Mountains, clouds, and background elements for complete scenes

All assets are designed to work together, allowing you to easily create readable and cohesive ruins environments suitable for gameplay, exploration, or background worldbuilding scenes.

🎨 Visual style & optimization

All assets follow a clean stylized low-poly fantasy aesthetic, optimized for:

📱 Mobile projects

🖥 Desktop games

🧙 Fantasy, RPG, adventure, and stylized exploration games

⚙️ Technical details

• Materials: 1
• Textures: 2048×2048 (PNG, Base Color)
• Render pipelines: Built-in, URP, HDRP
• Average polycount: optimized low-poly, 500–50000 triangles per model
• Prefabs: ready-to-use Unity prefabs included

🧩 Compatibility

Compatible with other GanzSe Fantasy assets, including props, characters, weapons, and environments.

Audio format: WAV
Sample rate: 44.1 kHz
Bit depth: 24-bit

Total tracks: 97
Total music duration: ~4 hours
Original compositions: 58

Loopable tracks: Yes (seamless loops included)
Alternate edits: Yes

Organised folders:
• Background Underscore
• Narrative Themes
• Game-Ready Project Tracks

Files ready for immediate use in Unity projects.

Storyteller is a collection of emotional and atmospheric music created specifically for narrative-driven games, RPGs, visual novels, and story-focused adventure titles.

The tracks explore subtle tension, reflection, melancholy, and quiet cinematic moments, supporting storytelling, dialogue scenes, exploration, and emotional character moments.

Perfect for narrative adventures, story-driven RPGs, visual novels, and atmospheric exploration games.

Produced and composed by Andrea Baroni.

► VIEW COMPLETE TRACKLIST (SPREADSHEET)

WHAT'S INCLUDED:

• 58 original compositions

• 97 total tracks

• Nearly 4 hours of music

• 24-bit / 44.1 kHz WAV files

• Organised into three folders:

- Background Underscore

- Narrative Themes

- Game-Ready Project Tracks

• Seamless loops and alternate edits included

LICENSE:

The tracks are not registered with YouTube Content ID, meaning developers and content creators should not receive automated copyright claims when using them in gameplay videos, trailers, or promotional material.

• Scale and Offset subgraph
• Rotation subgraphs (X, Y, Z, XYZ axis)
• Taper subgraphs (X, Y, Z axis)
• Twist subgraphs (X, Y, Z, XYZ axis)
• Skew subgraphs (X, Y, Z axis)
• Squash & Stretch subgraphs (X, Y, Z axis)
• Bend subgraphs (X; Y, Z, XYZ axis)
• Blend and FBX file as example pipeline to port 3D package animation using deforms to Unity
• Simple C# Script to communicate animation to shader
• 2 Scenes with examples setups and different use cases: 3D assets, 3D animation.
• Two PDF-documents containing relevant information to support your first steps, understand how to apply subgraphs and which ones are available.
• Examples_URP.unitypackage where you will have examples created using URP

Multiple Deformation SubGraphs to add to your own ShaderGraph setups. You can play with them like in any 3D or 2D package happens, limits are yours. You will find:

• Rotate
• Taper
• Twist
• Skew
• Squash & Stretch
• Bend

And an extra Scale & Offset subgraph really useful on a daily basis. All of them prepared for one axis to three axis. You will find some examples to demostrate some ways to setup them and the results you can achieve.

All you can find here is really straight forward, without any tricky setup and it's prepared to support your project without creating any new layer in your configurations. They are only SubGraphs you can apply the way you want.

You will be able to animate via shader instead of using a SkinnedMesh and take profit to the SRP batching for Meshes. You will find a Blender example with a simple script to show you a possible pipeline between packages.

Model Info:

- Polygon(tris) Count : 143607

- PBR Texture Pack Count : 4

- Textures Size : 2048 x 2048 px

- proper UV unwrapped, no overlapping.

FEATURES:

- High Quality PBR Textures

- Ready for Mobile Devices