Asset Store newest packages

System Requirements

• Unity 2020.3 LTS or later
• Supports Android, iOS, PC, Mac
• Android notifications supported
• Editor tools included
• Clean, commented C#
• No third-party dependencies

🚀 Increase Player Retention Instantly

Ultimate Retention System is a complete production-ready framework designed to increase D1, D7 and long-term player engagement.

This is not just a daily reward script — it is a full retention architecture used in top-grossing mobile games.

🔥 Core Features

✔ Looping Daily reward calendar (7days).

✔ Dynamic streak progression with progress bar

✔ Streak shield (24h protection in advance), when logged in after x days, x amount of freezeTokens would be charged to protect streak. If not, player loses the current streak.

✔ Reactive freeze tokens (save streak after missed days)

✔ Comeback bonus mechanic after streak reset

✔ Milestone chest rewards (15 days streak, 30 days streak, 60 days streak)

✔ Weekend rewards (each reward has a rarity: Common, Rare, Epic, Legendary, and is based on player's retention risk - different rewards based on customer's loyalty)

✔ Visual streak progress bar with glow indicator

✔ Token economy integration

✔ Push Notifications for iOS and Android. Fully customizable (daily reward notification, weekend bonus notification, streak lose warning, 24h shield expire warning,..).

✔ Runtime + Editor dev dashboard

✔ Fully PlayerPrefs based (easy to migrate to backend)

✔ Basic animations (chest bounce, freeze, all code-based)

🛠 Developer Tools Included

The built-in Dev Dashboard allows you to:

• Simulate missed days

• Break streak instantly

• Force milestone chest

• Add freeze tokens

• Test shield protection

• View real-time PlayerPrefs debug info

🎮 Designed For

• Mobile games

• Casual / Hypercasual

• Idle games

• Match-3

• RPG

• Live-ops systems

💰 Monetization Ready

The system is designed to increase:

• Return sessions

• Reward engagement

• Emotional investment in streaks

• Freeze token purchases

• Long-term retention

Key Features

- Load and edit multiple images simultaneously with a visual Before/After preview grid and adjustable card width

- Fine-tune Hue (-180 to +180), Saturation (-100 to +100), and Brightness (-100 to +100) with colorful gradient sliders and per-degree arrow key control

- Apply uniform color tint using Colorize mode with target HSV values

- Convert to Grayscale (BT.601 luminance weighting) with a single toggle

- Invert RGB channels while preserving alpha transparency

- Fill transparent areas with White or Black background

- Rotate images (90 CW, 90 CCW, 180) with cumulative rotation support

- Flip Horizontal or Vertical with one click

- Resize to target sizes from 32 to 4096 with aspect ratio preservation and bilinear interpolation

- Round sizes to Multiple of 2 or Multiple of 4 for platform-optimal dimensions

- Preview capped at 512px in Performance Mode for responsive editing of large textures; export at full resolution

- Process all transforms, color adjustments, and effects in a single GPU draw call via uber shader

- Inspect R, G, B, A channels individually with per-image channel mode memory

- Auto-detect Normal Maps via TextureImporter and display correctly (DXT5nm/BC5 formats)

- Export to Custom Folder, Save As dialog, or Overwrite original files directly

- Preserve source TextureImporter settings (npotScale, sRGB, filterMode) on export

- Access instantly via right-click textures > EzToolsLab > Image Editor

- Configure defaults via Edit > Project Settings > EzToolsLab > Image Editor

- Includes demo scene with billboard layout showcasing all example textures

Technical Specifications

- Unity Version: 2022.3 LTS or later

- Platforms: Editor only (Windows / macOS / Linux)

- Render Pipeline: All (Built-in, URP, HDRP)

Image Editor by EzToolsLab is the fastest way to batch-process textures without leaving Unity. Select your images, tweak colors, resize, and export — all with instant visual feedback.

3 core :

Color & Effects — HSB fine-tuning (with Colorize mode), grayscale conversion (BT.601), RGB inversion, and transparent area fill (black/white background).

Transforms & Sizing — Rotation (90°/180°, cumulative), flipping, resize (32–4096 with aspect ratio preservation and bilinear interpolation), and size rounding to multiples of 2 or 4.

Performance & Workflow — All processing in a single GPU draw call (uber shader), large image preview capped at 512px (Performance Mode), export preserves original TextureImporter settings.

Who Is This For?

- Game developers who need to batch-resize or color-correct texture assets

- Technical artists adjusting Normal Maps, alpha channels, or texture formats

- UI/UX designers processing icon sets and interface graphics

- Anyone who wants a built-in image editor without switching to Photoshop

Core Features

- Instant Inspector Preview — VFX plays automatically on Prefab selection; no Play Mode required

- Real-Time Performance Chart — dual-axis graph tracks particle count and draw calls simultaneously, with Min / Max / Avg / Median statistics

- Timeline Scrubbing — frame-accurate slider with step-backward and step-forward at 60 fps resolution

- Playback Speed Control — 0.125x to 2x speed adjustment; supports slow-motion analysis

- Overdraw Visualization — heat-map overlay highlights fill-rate hotspots; Picture-in-Picture (PiP) mode shows Rendering and Overdraw side by side

- Multi-Selection Compare — select up to 25 VFX Prefabs and preview them simultaneously in a responsive grid layout

- Interactive Preview Camera — rotate, pan, and zoom like Scene View; F key resets camera

- Keyboard Shortcuts — Space (play/pause), Arrow keys (step frames), G (toggle graph), F (reset camera)

Pipeline & Compatibility

- Render Pipeline Auto-Detection — Built-in, URP supported out of the box

- VFX Graph Support — automatically enabled when the Visual Effect Graph package is installed; supports playback and particle count tracking

- ASE & Time-Based Shader Detection — detects Amplify Shader Editor materials and any shader using Unity built-in time variables (_Time, _SinTime, _CosTime); displays a warning when speed control may not affect shader-driven animations

Every VFX artist knows the drill: your effect looks stunning, then engineering rejects it for performance. VFX Preview fixes that in one click.

Select a Prefab — the effect plays instantly in your Inspector with a live performance chart and overdraw heat-map. No Play Mode. No waiting.

Who it is for

- VFX Artists — stop guessing if your effect will pass review; see the numbers while you create

- Technical Artists — find overdraw hotspots in seconds, not minutes

- Programmers — debug VFX lifecycle frame by frame without test scripts

- QA — verify that effects meet performance budgets at a glance

How to use it

1. Import the package

2. Select a VFX Prefab

3. Done — preview, performance chart, and overdraw appear automatically

Zero configuration. Zero runtime overhead.

Compatible with Built-in, URP, and HDRP out of the box.

VFX Graph support activates automatically when the package is installed.

*Main features*

A total of 8 models were produced with relatively low polygon counts for compatibility with mobile games.

The texture of each ship is provided in png and psd formats.

The turret for animation is a separate mesh.

Create a variety of warship games with the theme of a warship collection.

This model is a pack that includes ships from 1984 to 2014.

This pack includes destroyer, Frigate, Submarine and Aircraft carrier.

As the collection version increases, it will be updated with the latest ships.

The sea background in the picture is not included in the package.

*Technical details*

Ship Characteristics by Type

(1) America LHA-6 (2014, Aircraft carrier)

- Texture Set: png, psd

- Texture resolution: 512x512(1) 256x256(1)

- Formats: obj

- Polycount: faces 9,030 tris 4,150 vertices 6,975

- UV mapping: Yes

(2) Arleigh Burke (1991, Destroyer)

- Texture Set: png, psd

- Texture resolution: 512x512(2) 256x256(1)

- Formats: obj

- Polycount: faces 3,601 tris 7,758 vertices 5,852

- UV mapping: Yes

(3) Borei (1996, Submarine)

- Texture Set: png, psd

- Texture resolution: 512x512(1)

- Formats: obj

- Polycount: faces 611 tris 1,195 vertices 680

- UV mapping: Yes

(4) Hatakaze (1984, Destroyer)

- Texture Set: png, psd

- Texture resolution: 512x512(2) 256x256(1)

- Formats: obj

- Polycount: faces 3,349 tris 6,986 vertices 5,441

- UV mapping: Yes

(5) Kongo (1990, Destroyer)

- Texture Set: png, psd

- Texture resolution: 512x512(2) 256x256(1)

- Formats: obj

- Polycount: faces 3,746 tris 7,786 vertices 6,136

- UV mapping: Yes

(6) Murasame (1996, Destroyer)

- Texture Set: png, psd

- Texture resolution: 512x512(1) 256x256(1)

- Formats: obj

- Polycount: faces 3,517 tris 7,646 vertices 5,713

- UV mapping: Yes

(7) Sachsen (2004, Frigate)

- Texture Set: png, psd

- Texture resolution: 512x512(2) 256x256(1)

- Formats: obj

- Polycount: faces 3,032 tris 6,566 vertices 4,909

- UV mapping: Yes

(8) Tennessee (1986, Submarine)

- Texture Set: png, psd

- Texture resolution: 512x512(1)

- Formats: obj

- Polycount: faces 430 tris 745 vertices 437

- UV mapping: Yes

* Common Texture(handrail) : 256x256(1)

◼ Behold! CatBorg Studio™ Presents ◼

Mesh editing made easy- powerful in-editor geometry tools for Unity.

◼ Key Features ◼

• Standalone: No external packages or dependencies required.
• Editor-Integrated: Works directly inside the Unity Editor- no need to export to Blender or other tools.
• Customizable: Assign your own shortcuts for rapid workflow.

🟢 MeshFilter: Fully supported

🟡 SkinnedMeshRenderer: Supported (Experimental, introduced in v1.7.0)

◼ Toolset Overview ◼

• Pivot Tools:
• Pivot Set
• Pivot To Selection
• Pivot Center of Mass
• Pivot Bottom
• Mesh Tools:
• Mesh Merge
• Mesh Move
• Mesh Rotate
• Mesh Scale
• Mesh Delete
• Separate Tools
• Separate By Loose Parts
• Separate Selected
• Split Selected
• Repair Tools
• Bake Scale
• Orientation Set
• Bind To Rig
• Transfer Weights
• Remove Unused Materials
• Flip Normals
• Flat Shading
• Smooth Shading
• Other Tools
• Save As FBX
• Save As Mesh
• Make Static (Current Pose)
• Mase Static (Rest Pose)
• Select Tools
• Select Linked
• DeSelect Linked
• Select More
• Select Less
• Invert Selection
• Select All
• Rectangle Selection
• Lasso Selection
• Circle Selection

◼ Support & Updates ◼

• Help Desk (Discord)
• Quick Start Guide (GitHub Quick Start Guide)

File Count: ~100 Sprites

Sprite Resolution: 1920x1080

Sprite Layers: Foreground, Midground, Background

Animated: Yes (Player only)

Animation Type: Player movement animations (walk, jump, idle, etc.)

Particle System: Includes dust, leaves (varied sprite resolutions)

Vector or Pixel-Based: Pixel-based

🏴 Dark Platformer World 🏴

for dark atmospheric 2D Unity games!

💬 Join Our Discord Community

Get support instantly

📘 Documentation

Easy setup & customization guide included

📧 Support Email

gameseedassets@gmail.com

✏️ Video Tutorial

Post Process Settings

🧩 Overview

Dark Platformer World is a complete environment kit designed for Unity. Create haunting, atmospheric platformer levels with layered environments, dynamic particles, and cinematic visuals for puzzle and story-driven games.

✨ Features

- 100+ handcrafted assets

- Background & foreground layers (3 layers)

- Vegetation & props 🌳 (trees, bushes, spikes, crates, etc.)

- Ambient particles (dust, falling leaves)

- Player controller & camera system

- Post-processing 🎭 effects for cinematic look

- Mobile-friendly (PC, WebGL, Mobile)

- Optimized performance

- Easy to modify 🧩 and extend

Axon is a professional UI animation framework for Unity that replaces tedious coding with a visual, timeline-based workflow. Features include hierarchy-aware staggering, priority-based interaction, and a non-allocating core for AAA performance.

Build animated UIs and menus without writing custom code.

It is not just another tweening library; it is a complete architectural framework designed to solve the complex lifecycle, hierarchy, and state management problems inherent in Unity UI development. Axon allows you to create sophisticated, staggered, and state-driven interfaces without spaghetti code of traditional methods.

Whether you are building a high-impact RPG menu, a complex HUD, or a sleek mobile interface, Axon provides the structural backbone to keep your project clean.

Documentation

• Documentation is included under "Assets/GeMo/Axon/UI/Documentation/index.html"
• Online-Documentation: https://pixelpoint-interactive.com/documentation/axon-ui/1.0.0/

Demo scenes

• Demo scenes are included under "Assets/GeMo/Axon/UI/Content/Demos"

-------------------------------------

Key Features

-------------------------------------

🎨 Visual Timeline & Editor Previews

Stop hitting "Play" to tweak your UI animations. Axon includes a dedicated Animation Designer Window that lets you scrub through transitions and visualize entry/exit sequences directly in the Editor.

🌊 Hierarchical Staggering System

Create "Waterfall" effects effortlessly. Widgets can automatically wait for their parents to show, and containers can stagger their children's entry/exit animations with a single float setting—no coroutines required.

🎮 Priority-Based State Machine

Seamlessly manage interaction states. The UIWidgetAnimator handles Entry, Exit, and Idle loops, while also layering "Interactive" states (Hover, Press) and additive custom states (e.g., "LowHealth", "Selected").

🛠️ Robust Navigation History

Includes a UIMenuManager with a built-in stack system for easy "Back" navigation and screen switching, ensuring a proper flow between your menus.

Is this customizable?

Yes. The framework is designed to be extended with custom code.

• Custom States: The UICustomStateManager allows you to define and trigger any number of arbitrary visual states directly in the editor (like "Locked," "NewItem," or "Damaged") via string IDs or UnityEvents.
• Custom Animations: The UIAnimationStep class is abstract, allowing you to script unique animation behaviors (e.g., specific shader parameter tweens or audio triggers) that automatically work with the sequencer.

Suitable Genres

Axon.UI is genre-agnostic but excels in projects with complex or stylized interfaces:

• RPGs & JRPGs: Perfect for managing deep menu hierarchies, party screens, and inventory lists that need to animate sequentially.
• Strategy Games: Ideal for complex HUDs with multiple floating windows and panels.
• Action/Arcade: Great for high-energy "Juice" effects (bouncing, shaking, punching) using the interactive animator.

Technical Requirements

• Unity 2021.3+
• DOTween (Free or Pro) is required for the underlying tweening engine.
• TextMeshPro supported.

Technical Details

• Unity 2022.3+ (LTS)
• Game Creator 2 Core required
• 30+ Runtime C# files
• 60+ Unit Tests
• Clean subsystem architecture
• Full source code included

Relationship System transforms how characters interact in your Game Creator 2 projects. Build dynamic reputation systems, complex faction hierarchies, and diplomatic relationships—all without writing code.

Imagine a guard who trusts you enough to look the other way, a guild that shuts its doors because you sided with their enemies, or a companion whose loyalty shifts after one too many questionable decisions. These aren't scripted moments — they emerge naturally from a living system of values, levels, and factions that react to everything the player does.

Setting it up takes minutes, not hours. Drop a component on your characters, define what "Friendly" or "Hostile" means to you, and wire it up through Game Creator 2's visual scripting. No code required. When the player completes a quest, a single instruction adjusts the relationship. When that value crosses a threshold, your UI updates, your NPCs react, and your world feels alive.

-----------------------------------------------------------------------------------------

Online Documentation: Link

-----------------------------------------------------------------------------------------

Core Features

• Dynamic Relationships — Values change based on player actions with configurable levels (Hostile → Neutral → Friendly)
• Faction Hierarchies — Parent/child factions with automatic relationship inheritance
• Diplomacy States — War, Peace, Alliance, Ceasefire, Embargo with threshold-based transitions
• Full GC2 Integration — 20+ Instructions, Conditions, and Events for visual scripting
• Save/Load Support — Automatic persistence via GC2 Remember integration
• Production-Ready UI — Base classes and prefabs for relationship displays

Advanced Capabilities

• Temporary Modifiers (flat/percentage/override with duration)
• Relationship History (audit log with timestamps)
• Reputation Caps (min/max gates with events)
• Auto-Hostility (NPCs attack based on reputation)
• Scene Instructions (override actions per scene)
• Event Listeners (UnityEvents + GC2 Instructions)

Use Cases

• RPG reputation with merchants, guilds, factions
• Strategy game diplomacy and alliances
• NPC trust/distrust mechanics
• Companion approval systems
• Territory control faction wars

----------------------------------------------------------------------------------

HuckHub - Possible Updates and Integrations

This asset communicates with HuckHub to check for module updates, possible Integrations, upcoming releases and links external documentation.

----------------------------------------------------------------------------------

• Zero-setup workflow: add one DevKitManager component and all modules initialize automatically
• Works in Unity Editor Play Mode and Development Builds
• Release builds strip debug code unless DEVKIT_ENABLED is manually enabled
• 6 integrated modules: Log Console, Variable Monitor, Performance HUD, Command Console, Gizmo Overlay, Free Camera
• Log Console supports search, tag filters, collapse mode, stack trace expansion, export, auto-scroll, and panel resize
• Variable Monitor supports [DebugWatch] attributes, live updates, numeric sparklines, alert thresholds, and scene re-scan
• Performance HUD displays FPS, average/min values, frame time spikes, CPU/GPU timings, memory, draw calls, batches, and triangles
• Supports custom runtime metrics and event counters through API calls
• Command Console supports [DevCommand("name")] methods with automatic argument parsing for bool, int, float, and string
• Includes autocomplete, command history, help, clear, quit, scene_reload, and fps_cap commands
• Gizmo Overlay supports Sphere, Box, Line, Ray, Circle, Label, StateLabel, NavPath, and collider visualization
• Free Camera supports WASD movement, Q/E vertical movement, mouse look, sprint, speed adjustment, and camera state restore
• Cursor lock state is automatically managed when overlays open and close
• Supports both Legacy Input Manager and New Input System
• Clean assembly separation: DevKit.Runtime and DevKit.Editor
• No third-party dependencies
• TextMeshPro required
• Compatible with Built-in Render Pipeline and URP
• Minimum Unity version: 6.2f LTS

DevKit — Runtime Debug Toolkit is a zero-setup debugging toolkit for Unity projects.

Add a single DevKitManager component to any GameObject in your scene, press Play, and all runtime modules initialize automatically by code. No prefabs, no manual UI setup, no scene clutter.

DevKit is built for developers who want fast in-game debugging both in the Unity Editor and in Development Builds. It helps inspect logs, monitor values, track performance, execute commands, draw debug visuals in Game View, and freely move the camera during testing.

The toolkit includes 6 integrated modules:

1. Log Console
   Capture Unity logs and custom DevKit logs in a searchable runtime console with tag filters, collapse mode, stack traces, export, and resize support.
2. Variable Monitor
   Mark fields or properties with attributes and watch them live in a draggable overlay. Supports graphs and alert thresholds for fast inspection of gameplay values.
3. Performance HUD
   Track FPS, frame time, CPU/GPU timings, memory, draw calls, batches, triangles, and your own custom counters in real time.
4. Command Console
   Expose your own methods as runtime commands with simple attributes. Execute commands with typed parameters, autocomplete, history, and rich output.
5. Gizmo Overlay
   Draw lines, rays, spheres, boxes, circles, labels, navigation paths, and collider overlays directly in Game View and builds.
6. Free Camera
   Detach the main camera and inspect your game world with fly controls, speed adjustment, sprint, smooth look, and automatic restore of the original camera state.

DevKit also includes Editor-side integration:

• Custom Inspector for DevKitManager
• Dashboard window under Tools > DevKit > Dashboard
• Startup visibility controls
• Release build define toggle
• Quick-add right-click menu entries

Designed for rapid iteration, gameplay debugging, QA, prototyping, and internal development workflows.

Works in Unity Editor Play Mode and Development Builds automatically. In Release builds, debug code is stripped unless explicitly enabled with DEVKIT_ENABLED.

• Intercepts asset deletion and moves files to Recycle Bin instead of permanently deleting them
• Preview thumbnails for Materials, Textures, Prefabs, Folders, and more
• Filter deleted items by asset type with color-coded labels
• Sort by date or name (Newest First / Oldest First)
• Restore assets to their original paths with one click
• Bulk actions for restoring, deleting, and clearing trash
• Search deleted items by asset name
• List and Grid view modes
• Displays deletion date and file size for each item
• Persists across Unity Editor sessions
• Editor-only tool with zero runtime or build impact

Ever accidentally deleted a prefab, material, texture, or folder and then had to search through Git, backups, or old project copies to recover it? Recycle Bin solves that.

Instead of deleting assets permanently, Recycle Bin moves them into a dedicated trash system inside the Unity Editor. You can browse deleted items with previews, timestamps, file sizes, and asset type labels, then restore them to their original location with a single click.

It works the way you would expect from a desktop recycle bin, but is designed specifically for Unity workflows and the asset pipeline.

Recycle Bin helps reduce mistakes, speed up recovery, and make project cleanup much safer — especially during rapid iteration, refactoring, or content-heavy production.

mobile, beast, alien, doom, creature, monster, human, humanoid, people, medieval, fantasy character, game, low poly, pbr, rigged, animation, unity, unreal, rpg

Number of unique asset: 1

Average polygon count: 23322

Texture dimensions: Body 4k, Eyes 2k

Texture map: PBR

faces 23322

verts 11790

tris 23322

Fully animated

- Model contains 42 animations including attack, walking, running, turn, react, idle, death, jump

Transform your game!

Purchase your premium 3D character now!

Using the AI Translate feature requires you to have an API key to the selected provider. When you enter your key, it is saved in EditorPrefs, and it lives entirely in the Editor. It is not included in the build.

You can get API Keys here:

• OpenAI: API Platform | OpenAI
• Google Gemini: Using Gemini API keys | Google AI for Developers
• Groq: API Keys - GroqCloud

Some of these providers and models have a cost. View pricing here:

• OpenAI: Pricing (openai.com)
• Gemini: Gemini Developer API pricing | Gemini API | Google AI for Developers
• Groq: Groq On-Demand Pricing for Tokens-as-a-Service | Groq is fast, low cost inference.

Google Gemini and Groq has a free tier. By default, the API key you get from them allows free use, but with certain rate limits - requests / min, tokens / min and requests / day.

🌍 Frostzone Localization - Multi-Language System

Powerful. Simple. Production-Ready.

No setup required. Just import the package and start requesting localized values from the database.

Localize text, sprites, audio, and any custom UnityEngine.Object from a single, easy-to-use central database. Switch languages instantly at runtime with automatic saving and loading built in. Create dynamic localized in-game text using SmartStrings (e.g. “Restores {hp} health.”) and easily export and import CSV for external work.

Need a head start? Generate initial translations for your entire string database with one click using AI-powered batch translation.

Fully documented, includes a demo scene with guided tutorial and practical examples. Beginner-friendly, and built for projects of any size. Make your game playable worldwide, without the headache.

Supports all Unity platforms: Standalone, Android, iOS, WebGL, etc.

🚀 Key Features

🤖 AI Translation (Integrated in the editor)

Translate your entire database with one click using: OpenAI, Google Gemini, or Groq.

Perfect for: Rapid prototyping, Placeholder localization and Initial translation drafts. This is an unofficial integration, Frostzone is not affiliated with Gemini, OpenAI or Groq in any way.

Note: See Techical details for information about API Keys!

📝 Localize Everything

Supports the most common Unity types: Strings, Sprites, AudioClips and a flexible custom table that accepts any UnityEngine.Object (Material, Prefab, ScriptableObject, etc.) Fully type-safe with graceful null fallback behavior.

🧠 Automatic Initialization & Saving

No setup required. The system loads the previously saved language, falls back to default if needed, and can optionally prefer the system language of the player’s computer. The active language is saved automatically whenever the languge is changed, and the save system is modular and easy to hook up to your own logic. Just import the package and start requesting localized values.

⚡ Runtime Language Switching

Change language instantly in-game. Includes a ready-to-use Language Picker prefab, or switch via script with a single method call.

🔔 Event-Driven Architecture

All localization components respond to a global onLanguageChange event. You can subscribe to this as well. The event components are designed to work with anything that accepts its value. E.g. The LocalizedStringEvent supports any text component that takes a string, whether it’s TextMeshPro, built in text, or other custom solutions. Zero manual refresh logic required.

📊 CSV Workflow (Translator Friendly)

Export all string entries to CSV. Send to translators or edit in Excel. Languages added in CSV are automatically created in the database. Sprites, Audio, and Custom objects remain untouched by CSV imports.

🧩 SmartStrings (Dynamic Localized Text)

Create flexible, runtime-driven localized text with placeholders.

Example: “Restores {health} HP over {duration} seconds.”

The placeholders can be assigned values at runtime, and the system formats the fully translated result automatically. Perfect for: Tooltips, Stats, Damage numbers, or other dynamic values.

🗂 Centralized Database

Single ScriptableObject database with Language management, Fallback control, Memory estimate overview, Key search & browser and Organized tabs (Strings, Sprites, Audio, Custom)

🎥 Demo Scene & Documentation

Includes: Fully functional demo scene, Practical examples, Step-by-step tutorials, and comprehensive documentation.

🔌 Full C# API Included

Complete source code included, and covered in the documentation.

Core methods:

• GetLocalizedString
• GetLocalizedSprite
• GetLocalizedAudioClip
• GetLocalizedObject<T>
• SetLanguage

Mutant S1

Additional bones that are added to skeleton:

jaw

Textures:

4K PBR Textures(tga)

3 materials

7 textures

Animations:

Model contains 25 animations:

atack(x5)

walk(x4)

jog(x4)

rage

idle(x4)

gethit(x3)

death(x3)

turn180

Polycount:

Verts: 7026

Faces: 6262

Tris: 11774

Mutant S2

Additional bones that are added to skeleton:

jaw

Textures:

4K PBR Textures(tga)

3 materials

9 textures

Animations:

Model contains 25 animations:

atack(x5)

walk(x4)

jog(x4)

rage

idle(x4)

gethit(x3)

death(x3)

turn180

Polycount:

Verts: 7485

Faces: 6590

Tris: 12508

Mutant S3

Additional bones that are added to skeleton:

jaw

Textures:

4K PBR Textures(tga)

3 materials

9 textures

Animations:

Model contains 23 animations:

atack(x5)

walk(x5)

run

rage

idle(x4)

gethit(x3)

death(x3)

turn180

Polycount:

Verts: 6639

Faces: 5246

Tris: 10184

Mutant S4

Additional bones that are added to skeleton:

jaw

Textures:

4K PBR Textures(tga)

3 materials

9 textures

Animations:

Model contains 22 animations:

atack(x5)

walk(x5)

rage

idle(x4)

gethit(x3)

death(x3)

turn180

Polycount:

Verts: 6054

Faces: 5160

Tris: 9900

Mutant S5

Additional bones that are added to skeleton:

jaw

tentacles_joints1

tentacles_joints2

tentacles_joints3

tentacles_joints4

tentacles_joints5

tentacles_joints6

tentacles_joints7

tentacles_joints8

tentacles_joints9

tentacles_joints10

tentacles_joints11

tentaclesParasite_joints1_r

tentaclesParasite_joints2_r

tentaclesParasite_joints3_r

tentaclesParasite_joints1_l

tentaclesParasite_joints2_l

tentaclesParasite_joints3_l

Textures:

4K PBR Textures(tga)

3 materials

9 textures

Animations:

Model contains 23 animations:

atack(x5)

walk(x5)

run

rage

idle(x4)

gethit(x3)

death(x3)

turn180

Polycount:

Verts: 13071

Faces: 10068

Tris: 18878

Mutant S6

Additional bones that are added to skeleton:

jaw

Textures:

4K PBR Textures(tga)

3 materials

9 textures

Animations:

Model contains 23 animations:

atack(x5)

walk(x5)

run

rage

idle(x4)

gethit(x3)

death(x3)

turn180

Polycount:

Verts: 7916

Faces: 6443

Tris: 12226

Mutant S7

Additional bones that are added to skeleton:

jaw

Textures:

4K PBR Textures(tga)

4 materials

13 textures

Animations:

Model contains 25 animations:

atack(x5)

walk(x4)

jog(x4)

rage

idle(x4)

gethit(x3)

death(x3)

turn180

Polycount:

Verts: 12669

Faces: 9169

Tris: 17237

This pack includes 7 high-quality mutant enemy characters, ready to use in your game.

Perfect for horror, survival, dark fantasy, sci-fi and post-apocalyptic projects.
The pack features a variety of grotesque mutant creatures with unique silhouettes and body mutations, allowing you to quickly populate your levels with terrifying and visually diverse enemies.

Each character is designed with a strong focus on readability, silhouette variation and detail, making them ideal for both gameplay and cinematic use.

All characters are fully rigged and include FBX files with animations.
Characters can be imported into Unity and retargeted to the Humanoid system if needed.

Each character includes a set of 22–25 animations, allowing immediate use after setup.

Each Character Includes

• Fully rigged characters (custom rig with FBX animations, compatible with Unity retargeting workflows)
• FBX files (meshes and animations)
• 22–25 animations per character
• Game-ready meshes
• High-quality PBR textures (4K)
• Optimized for real-time use
• Compatible with Built-in Render Pipeline
• Compatible with URP (Universal Render Pipeline)
• Compatible with HDRP (High Definition Render Pipeline)

Ideal For

• Horror and survival games
• Dark fantasy projects
• Sci-fi / mutation themes
• Dungeon crawlers
• Post-apocalyptic worlds

Before buying, read the technical details and watch the pages and videos for full information.

• Mutant S1

https://assetstore.unity.com/packages/3d/characters/creatures/mutants1-355890

• Mutant S2

https://assetstore.unity.com/packages/3d/characters/creatures/mutant-s2-358998

• Mutant S3

https://assetstore.unity.com/packages/3d/characters/creatures/mutant-s3-tank-363772

• Mutant S4

https://assetstore.unity.com/packages/3d/characters/creatures/mutant-s4-364154

• Mutant S5

https://assetstore.unity.com/packages/3d/characters/creatures/mutant-s5-parasite-host-366550

• Mutant S6

https://assetstore.unity.com/packages/3d/characters/creatures/mutant-s6-367972

• Mutant S7

https://assetstore.unity.com/packages/3d/characters/creatures/mutant-s7-368792

• Output type: PNG (raster/pixel-based). Static (one PNG per character) or animated (PNG sequence per character).

• Animated: Yes. Animation type: frame-by-frame PNG sequences (e.g. glow pulse, shadow, border animation). Frames exported to an Animation subfolder.

• Unity version: 2022.3 or higher.

• Render pipelines: Built-in, URP. No pipeline-specific setup; tool generates textures.

• Dependencies: SkiaSharp and dependencies included in package (Plugins folder). No Asset Store package dependencies. See ThirdPartyNotices.txt.

• Content: Runtime and Editor scripts, Documentation, Samples (demo scenes and scripts), Shaders (optional). File count and sizes depend on generated output; package includes wizard UI, generators, and demo scene assets.

• Input: .ttf/.otf fonts in a project folder (e.g. Input_Fonts). Export to any folder under Assets.

Procedural Font Bakery lets you generate pattern-filled and effect-rich font assets as PNGs for Unity. Use the Basic or Advanced editor (Tools → GlyphAurea Labs) to pick a font, set patterns and effects, and export one image per character—static or as animated PNG sequences.

• Basic: font selection, patterns (Solid, Diagonal, Grid, Dots, etc.), frame shapes (29 options), character set, one-click export.

• Advanced: effect presets (Glow, Neon, Tron, Shadow, Outline, Border Animation), drop shadow, glow, outline, PNG sequence export.

• Output: PNG files per character (e.g. 0041_A.png); for animation, a sequence of frames per character. Use in UI Image, sprite-based text, or animation.

• SkiaSharp is bundled in the package (see ThirdPartyNotices.txt). Unity 2022.3 or higher. Works with Built-in and URP. No Shader Graph, VFX Graph, or Post Processing required.

Finite state machines are one of the most reliable ways to build clear, maintainable gameplay logic. State Designer brings that workflow into a modern, data-oriented architecture built on Unity DOTS, giving you the flexibility to create scalable systems for gameplay, AI, interactions, UI flow, and more.

No DOTS expertise is required. State Designer supports GameObject, hybrid, and Entities-based workflows, so you can use the approach that fits your project today while keeping a path open for higher-performance data-oriented execution as your project grows.

By combining visual state machine authoring with a DOTS-backed runtime, State Designer keeps logic organized while reducing runtime overhead. The result is a workflow that feels intuitive to build with and remains efficient and predictable as complexity increases.

📚Documentation | 🎥Videos | 💬Discussions | 🌐Discord

🧠Why Finite State Machines?

State machines excel at modeling systems with clear phases, transitions, and event-driven behavior. They are a natural fit for gameplay systems, character abilities, interactable objects, UI flows, and cutscenes.

✨Key Features

Performance & Architecture

• Built on Unity DOTS for efficient runtime execution
• Supports GameObject, hybrid, and Entities workflows
• Burst-compiled traversal and transition systems
• Data-oriented runtime designed for scalable state logic
• Supports both object-backed and DOTS-backed node patterns

Authoring & Tooling

• Visual node-based finite state machine editor
• Event-driven graph flow with transitions, conditions, and actions
• Reusable subgraphs with override support
• Runtime SharedVariable inspection
• Error window and editor debugging support
• Save & Load support

State Design

• States, actions, conditions, transitions, and events
• Sequential or parallel action execution within a state
• Shared variables for communication across graph logic
• Pause, resume, and runtime state persistence
• Flexible graph composition with subgraph references and inheritance

Extensibility

• Familiar API for custom states, actions, and conditions
• Extend systems with object-backed or DOTS-backed implementations
• Custom editor controls and inspectors
• Designed for long-term project integration

💡Use Cases

• Gameplay Systems: Character abilities, combat states, cooldowns, and interactions
• Interactive Objects: Doors, elevators, switches, traps, and environment logic
• UI Flow: Menus, prompts, dialogue states, and screen transitions
• Scene Management: Loading, unloading, persistent scenes, and transitions
• AI & Simulation: Reactive agents, entity behaviors, and event-driven world logic
• Turn-Based Systems: Phase flow, action resolution, and stateful combat logic
• Save/Load Workflows: Persistent runtime state and variable restoration
• Custom Logic Systems: Build project-specific state-driven mechanics visually

🤝Seamless Integrations

• Animal Controller
• Behavior Designer Pro
• Dialogue System
• Essential Kit
• Feel
• Love/Hate
• Curvy Splines
• Quest Machine
• Sensor Toolkit 2
• Simple Waypoint System
• Ultimate Character Controller
• Ultimate Inventory System

State Designer combines the proven clarity of state machines with a modern DOTS-based runtime, giving you a flexible way to build performant, scalable game logic inside Unity.

all materials use 2k res textures

object count 27

1. tris: 21932; Polygons: 10219; Verts: 12241

2. uv mapped

3. 5 materials

4. no rig

5. no animation

support by buying my other assets

Portable stove for cooking and Butane Cans to keep them working.

Technical Details

• Unity Version: 2021.3+ (Recommended)
• Render Pipeline: Built-in / URP / HDRP (Material dependent)
• Type: Editor Tool / Procedural Mesh Generator
• Mesh Generation: Runtime + Editor supported (Editor focused)
• Spline Type: Catmull-Rom spline
• Road Features: Smooth procedural road mesh generation
• Sidewalk Features: IN / OUT sidewalks with curb height geometry
• Loop Support: Open road & Closed loop roads supported
• Customization: Road width, sidewalk width, curb height, spacing, UV tiling
• Materials: Separate material slots for Road, Sidewalk IN, Sidewalk OUT
• Optimization: Lightweight & optimized mesh building
• Dependencies: None (No external packages required)
• Included Scripts: Spline system + mesh generators + custom editor tools

Spline Road & Sidewalk Generator is a lightweight Unity editor tool that helps you quickly create procedural roads using spline points. Simply place and move control points in the Scene view and the tool automatically generates a smooth road mesh along with optional IN / OUT sidewalks.

Sidewalks include real curb height geometry, making roads look more realistic for city environments, racing tracks, open-world maps, and level design projects.

The tool supports both open roads and closed loop roads, includes material slots for road and sidewalks, and is optimized for fast generation and real-time editing.

Perfect for developers who want a quick and clean road creation workflow inside Unity.

Key Features

• Procedural spline-based road mesh generation
• IN / OUT sidewalks with curb height support
• Open & closed loop road support
• Material slots for road and sidewalks
• One-click setup + real-time editor updates

Key Features

• Mobile Optimized – Designed for smooth performance on all platforms.
• Easy Setup – Generate hair physics instantly with a single button
• Fully Customizable – You can customize all the physic settings
• Real-Time Simulation – Responsive physics that reacts naturally to movement
• Selective Bone Control – Apply physics only to specific hair bones via node editing
• Dynamic Adjustment – Easily tweak parameters to match any art style or gameplay need

How It Works

Simply attach the HairDynamicsController to your hair object, assign the root bone, and generate physics. The system automatically creates and manages hair simulation in real-time.

Requirements

• Hair object must be rigged (bone-based)

Easy Hair Physics Pro is a lightweight and high-performance dynamic hair physics solution designed specifically for Unity projects, with a strong focus on mobile optimization.

With its simple one-click setup, you can instantly add realistic and responsive hair physics to your characters without complex configurations.

====================

What is included:

1. This asset uses Unity-Chan model parts under the Unity-Chan License.

You can get model for free by clicking the link.
See Third-Party Notices.txt for details.

2. Hair Physic System Scripts

3. Example Demo for hair physics

80s dump truck

This model was created for 3d camera view, but also it have lowpoly interior with seats and steering wheel.

Body model with smooth topology, 3d seams, small parts like wipers, hanles, hinges etc.

Car body - 48770 tris and 27714 verts.

Wheels - 10254 tris and 6132 verts.

This model have separated steering wheel, lights glass, windows and license plates, fuel tanks and side tool box.

All dump part are separated and ready for animation.

Truck comes with two different fuel tanks.

Hood and doors do not open.

Model comes with shadowplane.

No LODs.

All screenshots from Unity, with Post Procecessing Package.

18 materials for dump truck

body_blue (4096x4096 BaseMap/MaskMapNormal/Mixed_AO)

body_blue2 (4096x4096 BaseMap/MaskMapNormal/Mixed_AO)

body_blue3 (4096x4096 BaseMap/MaskMapNormal/Mixed_AO)

body_gray (4096x4096 BaseMap/MaskMapNormal/Mixed_AO)

body_red (4096x4096 BaseMap/MaskMapNormal/Mixed_AO)

body_red2 (4096x4096 BaseMap/MaskMapNormal/Mixed_AO)

body_sand (4096x4096 BaseMap/MaskMapNormal/Mixed_AO)

glass (2048x2048 BaseMap/MaskMap/Normal)

headlights_glass (2048x2048 BaseMap/MaskMap/Normal)

interior (2048x2048 BaseMap/MaskMap/Normal)

licence_plates (1024x1024 BaseMap)**

lights_glass (2048x2048 BaseMap/MaskMap/Normal)

mirrors (128x128 BaseMap/MaskMap/Normal)

parts (2048x2048 BaseMap/MaskMap/Normal/Mixed_AO)

dump (2048x2048 BaseMap/MaskMap/Normal/Mixed_AO)

stones (2048x2048 BaseMap/MaskMap/Normal/Mixed_AO)

wheels (2048x2048 BaseMap/MaskMap/Normal/Mixed_AO)

shadow_plane (1024x1024 BaseMap)

** three different textures for plates

Model comes with environment - floor, buildings, walls and containers.All models and prefabs are available with this product.

Environment details

container - 1 material (2048x2048 BaseMap/MaskMap/Normal) * 

floor - 1 material (2048x2048 BaseMap/MaskMap/Normal)

wall - 1 material (2048x2048 BaseMap/MaskMap/Normal)

store - 1 material (2048x2048 BaseMap/MaskMap/Normal) 

*** three different textures for containers - red, blue, yellow.

29 maps for van (including additional colos schemes and licence plates)

29 maps for environment (including additional colos schemes and licence plates)

Feel free to ask me about this product before purchasing.

No refunds will be given after the asset has been downloaded.

80s dump truck

This model was created for 3d camera view, but also it have lowpoly interior with seats and steering wheel.

Body model with smooth topology, 3d seams, small parts like wipers, hanles, hinges etc.

Car body - 48770 tris and 27714 verts.

Wheels - 10254 tris and 6132 verts.

This model have separated steering wheel, lights glass, windows and license plates, fuel tanks and side tool box.

All dump part are separated and ready for animation.

Truck comes with two different fuel tanks.

Hood and doors do not open.

Model comes with shadowplane.

⭐ Notes: Dotween should be install before install this package in order for the package to work properly.

Key Features

🎡 Smooth Wheel Spinning

• Realistic rotation deceleration
• Configurable spin speed and direction
• Dynamic arrow oscillation during spins

🎁 Flexible Reward System

• ScriptableObject-based reward configuration
• Support for custom reward providers (server, database, procedural)
• Weighted shuffle and probability control
• Custom reward handlers for game-specific logic

🎨 Fully Customizable UI

• Multiple wheel image configurations
• Adjustable item count and positioning
• Editor gizmos for visual setup
• Responsive panel animations

🔧 Developer-Friendly

• Clean adapter pattern architecture
• Comprehensive event system
• Well-documented API
• Example implementations included

🎯 Perfect For

• Daily Reward Systems - Engage players with spin-to-win mechanics
• Gacha Games - Prize wheels and lucky draws
• Casino-Style Games - Wheel of fortune implementations
• Promotional Events - Limited-time reward campaigns
• Idle/Clicker Games - Bonus reward mechanics

📦 What's Included

• Complete FortuneWheel prefab
• Sample wheel sprites
• ScriptableObject reward templates
• Custom reward adapter examples
• Comprehensive documentation
• Demo scene

📩 Support & Inquiries

• the.coffee.std@gmail.com

Transform your game's reward system with Lucky Draw!