Asset Store newest packages

• 5 Custom Shaders (Optimized HLSL).
• C# Controller scripts for each effect.
• Inherits from a clean PostEffectsBase class for easy integration.
• Supports Unity Built-in Render Pipeline.
• Mobile and PCCompatible.
• List of VFX included: Brightness/Saturation/Contrast, Edge Detection, Edge Detection (Add/Overlay), Gaussian Blur (Optimized), Motion Blur (Accumulation).
• Texture sizes: 5852x3901
• Number of VFX: 5
• Custom shaders: Yes (5)

This package provides a curated set of high-performance post-processing effects specifically designed for the Built-in Render Pipeline. These shaders are an excellent alternative to heavy post-processing stacks, offering a professional visual polish without sacrificing frame rates on mobile or low-end devices.

Key Features:

• Essential Color Grading: Fine-tune the visual mood with Brightness, Saturation, and Contrast controls.
• Stylized Edge Detection: Two variations of the Sobel filter for technical or artistic outlines (Standard and Overlay modes).
• Optimized Gaussian Blur: A 5-tap separable blur with built-in downsampling and iteration support for high-quality results at low cost.
• Accumulation Motion Blur: Smooth frame-blending motion trails for racing or high-speed action games.
• Mobile-First Design: Optimized HLSL code and C# controllers ensure compatibility with mobile

Perfect for any genre, especially stylized, horror, or racing games where visual clarity and performance are paramount.

Core Features:

• Custom URP Shader (HLSL)
• Extremely optimized for Mobile, PC, and VR/AR platforms
• VR/XR Ready (Single Pass Stereo Instancing supported)
• Procedural, pulsating Hexagon grid system
• Dynamic Vertex Displacement for hit/impact reactions
• Background distortion/refraction (GrabPass equivalent for URP)
• Adjustable Fresnel edge lighting
• Dual-sided color rendering
• Flowing cloud/noise energy layer

Package Specifications:

• Render Pipeline: URP (Universal Render Pipeline) ONLY.
• Custom shaders: 1 custom HLSL Shader (EnergyShield)
• Target platforms: PC, Mac, Consoles, Mobile (Android/iOS), VR/AR (Meta Quest, PCVR).

Elevate your sci-fi project with this advanced and fully customizable Energy Shield package. Built specifically for Unity's Universal Render Pipeline (URP), this shader allows you to create AAA-quality force fields for spaceships, mechs, characters, or base defenses.

Key Features:

• Highly Optimized & Cross-Platform: Engineered for maximum performance across all devices. Whether you are targeting high-end PCs, standalone VR headsets, or mobile phones, this shader runs smoothly without sacrificing visual quality or framerate.
• VR & XR Ready: Fully optimized for Single Pass Stereo Instancing. Refraction (distortion) and depth effects work flawlessly in Virtual Reality environments.
• Interactive Hit Reaction: The shield reacts dynamically to damage using vertex displacement and color blending, providing a deeply satisfying visual response at the exact point of impact.
• Total Customization: Tailor every detail to fit your game's art style. Easily tweak front/back colors, fresnel intensity, cloud/energy flow speed, and hexagonal grid properties directly from the material inspector.
• Refraction & Distortion: Dynamically warps the world behind the shield to simulate a realistic, high-energy force field.

Whether you are developing a fast-paced arena shooter, a mobile sci-fi game, or an immersive virtual reality experience, this energy shield delivers the visual impact and performance you need.

Technical Details

Features:

• 10 procedural generators (terrain, roads, OSM import, paths, buildings, trees, rocks, grass, farms, props)
• Seed-based deterministic generation
• ScriptableObject theming (TerrainTheme)
• Full Undo support for all steps
• Setup Wizard for one-click configuration
• AI skill packs for extending with your coding assistant

Included:

• Demo theme with 100+ prefabs
• 4 terrain texture layers
• Full C# source code
• Complete documentation

Requirements:

• Unity 6000.0 or later
• Unity Splines
• Unity Mathematics

Terrainizer

Terrainizer is a procedural terrain generation toolkit for Unity. Drop it in, generate a complete landscape with villages, roads, vegetation, and farms, then delete it. Zero runtime cost, no scripts left behind.

What You Get

One seed generates an entire world. Terrain with hills, erosion, and island shaping. Village roads that branch naturally through the landscape. Buildings that flatten the ground beneath them and respect each other's space. Trees, rocks, and grass that follow slope and texture rules. Farm fields that line up along roads. Everything works together, and everything is driven by a single seed number.

Change the seed, get a different world. Same seed, same world, every time.

Real-World Roads

Import actual road networks from OpenStreetMap (optional). Terrainizer downloads road data, builds spline paths, flattens the terrain beneath them, and paints road textures automatically. Use real geography as a starting point, then fill in the rest procedurally.

How It Works

The Setup Wizard installs dependencies and creates a fully configured terrain generator in your scene. Click Regenerate All and you have a populated landscape. Want more control? Run each step individually: terrain first, then roads, paths, buildings, trees, rocks, grass, and farms. Every generator has its own inspector with settings you can tweak.

Built to Be Deleted

Terrainizer is an editor tool. It generates standard Unity terrain, tree instances, detail layers, and GameObjects. Once you are happy with the result, remove the Terrainizer components or the entire package. Your generated world stands on its own with no dependency on Terrainizer at runtime.

Built to Be Hacked

Full source code is included. Every generator inherits from a clean base class with a simple contract: Generate and Clear. The seed system, exclusion zones, terrain sampling, and pipeline ordering are all documented and designed for extension. Add your own generators, modify existing ones, or rip the whole thing apart.

AI Copilot Friendly

Terrainizer ships with AI skill packs so you can point your favorite coding assistant at the codebase and start extending. The skill packs include architecture maps, step-by-step workflows, integration checklists, and validation playbooks. Same engineering standards used to build every generator in the package.

Included

• 10 generator components (terrain, roads, OSM import, paths, buildings, trees, rocks, grass, farms, props)
• Demo theme with 100+ prefabs (buildings, vegetation, rocks, fences, props)
• 4 terrain texture layers (sand, grass, dirt, rock)
• ScriptableObject-based theming for easy prefab swaps
• Full Undo support for all generation steps
• Setup Wizard for one-click configuration
• Complete documentation and AI skill packs

- Unity 2021.3 or later

- All platforms — editor-only tool, generated output is standard ScriptableObjects and enums with no platform-specific code

- ~100 C# scripts (~18 Runtime, ~80 Editor)

- 2 assembly definitions: SimpleSkillForge.Runtime, SimpleSkillForge.Editor

- 2 demo scenes (.unity)

- 15 HTML documentation pages + 1 CSS stylesheet

- No third-party dependencies

- No runtime dependencies — entire toolset is editor-only, generated output has zero framework overhead

- Optional dependency: Simple Attribute Forge (detected automatically at edit time via reflection, never a hard reference)

- Optional dependency: Simple Item Forge (detected automatically at edit time via reflection, never a hard reference)

- Optional dependency: Simple Enemy Forge (detected automatically at edit time via reflection, never a hard reference)

- Optional dependency: Simple Quest Forge (detected automatically at edit time via reflection, never a hard reference)

- 5 runtime helper classes included: SimpleSkillHelper, SimpleSkillTreeTracker, SimpleSkillBarManager, SimpleSkillComboTracker, SimpleSkillComboEvaluator

- 6 genre templates: ARPG, MOBA, MMO, Turn-Based, Action, Roguelike

Still building skill systems for your game by hand?

Seriously. Stop it.

Simple Skill Forge gives you 4 interconnected wizard tools that generate production-ready skill databases, skill trees, skill set loadouts, and skill combos — complete with type-safe enums, custom ScriptableObject inspector editors, and full JSON supported content generation support!

OFFLINE DOCUMENTATION HERE!

THE FOUR FORGES

- Skill Forge — Define skills with two-level dynamic properties (skill-level AND rank-level), multi-rank progression with upgrade costs, prerequisites, 12 cross-forge reference fields, and optional modifier linking. 5-step wizard with 6 genre templates (ARPG, MOBA, MMO, Turn-Based, Action, Roguelike).

- Skill Tree Forge — Build talent trees with grid-based node layouts, parent-child connections, branch groups, point costs, level requirements, and single-level dynamic properties. Nodes reference skills from any Skill Forge database.

- Skill Set Forge — Create loadout templates with typed slots, skill assignments, and threshold-based set bonuses (equip 3/5 for bonus effects). Supports modifier assets on bonuses. Single-level dynamic properties.

- Skill Combo Forge — Define skill sequences with ordered steps (required/optional), alternate skill choices, timing windows, branch groups, and threshold rewards with modifier effects. Single-level dynamic properties.

DYNAMIC PROPERTY SYSTEM

• No hardcoded fields.
• You define your own Categories, Flags, Numerics, and Texts in each wizard.
• Skill Forge supports TWO levels — skill-level AND rank-level properties.
• Your game, your properties — works for any genre.

JSON-POWERED CONTENT PIPELINE

• Export your schema as Full JSON, Light JSON, or Markdown.
• Generate your skills either by hand or paste into an AI LLM of your choosing.
• A detailed, verbose JSON schema allows you to generate literally hundreds or even thousands of skills for your databases.
• Generate skill trees, loadouts, or combos based on these generated skills that import directly into your database.
• Every JSON schema includes detailed AI instructions, format examples, and validation guidance.

GENERATED CUSTOM EDITORS

• Every wizard generates a professional Inspector editor alongside the database — split-panel layout, search, sort, filter by category, multi-select with bulk operations, and pagination.
• No Unity's default "Element 0, Element 1" entries in your Inspector.

WHAT GETS GENERATED (per wizard)

• Type-safe enum of all codes
• ScriptableObject database with full runtime API
• Custom Inspector editor with search, sort, filter, pagination
• Populated .asset file with all your data

RUNTIME HELPERS

- SimpleSkillHelper — Check prerequisites, evaluate upgrade costs, query cross-forge references, find skills by item/enemy/quest code, prerequisite chain traversal, and affordability checks

- SimpleSkillTreeTracker — Track node unlocks with point spending, cascade resets, branch tracking, and full save/load snapshot support

- SimpleSkillBarManager — Manage skill set loadouts with equip/unequip, threshold-based set bonus activation, and save/load support

- SimpleSkillComboTracker — Track active combos with timing windows, automatic progression across all defined combos simultaneously, threshold reward triggers, and save/load support

- SimpleSkillComboEvaluator — Static combo evaluation, progress checking, next-valid-skill queries without instantiating a tracker

EDITOR UTILITIES

- Batch Icon Assignment — Assign icons to skills, trees, sets, or combos in bulk by scanning a sprite folder

- Database Export — Export any generated database as clean JSON with resolved property names

12 CROSS-FORGE REFERENCE FIELDS

Every skill can link to data from companion forge packages — all stored as plain string codes, no hard dependencies:

SIF (Simple Item Forge):

- Granted by item (skill books, scrolls, equipment passives)

- Required equipment (weapon requirements — bow for arrow skills, staff for magic)

- Produces item (conjure food, crafting skills, gathering yields)

- Reagent costs (arrows, soul shards, catalysts consumed per cast)

SEF (Simple Enemy Forge):

- Summon enemy (necromancer minions, pet classes, conjured creatures)

- Learned from enemy (Blue Mage skills, monster absorption)

- Taught by NPC (class trainers, weapon masters, move tutors)

- Effective against factions (Holy vs Undead, type advantages)

- Restricted to faction (racial abilities, covenant skills)

SQF (Simple Quest Forge):

- Unlocked by quest (class quests, mastery trials)

- Rewarded by quests (reverse lookup — "Learned from: The Archmage's Trial")

CHARACTER CLASS SYSTEM

• When paired with Simple Attribute Forge character templates, all 4 forge types gain character class restrictions.
• Filter skills, trees, sets, and combos by class at runtime.
• Works with manual class names too — SAF is optional.

SIMPLE ATTRIBUTE FORGE INTEGRATION (Optional)

• When paired with Simple Attribute Forge, unlock modifier references on skills, ranks, and set bonuses.
• Fully automatic detection — just import both packages.
• Own both packages? They become one connected system.
• Import Simple Attribute Forge into the same project and Simple Skill Forge automatically detects it — no setup, no configuration, no code changes.
• Every skill gains a Modifiers section in the wizard and in the generated custom editor — drag-and-drop links to Simple Attribute Forge Modifier ScriptableObjects.
• Character template assets enable class restriction checkboxes across all 4 forges.
• The JSON content pipeline is SAF-aware too.
• Schema exports include modifier format and AI instructions for generating skills with modifier integration.
• Everything round-trips safely. Remove Simple Attribute Forge from your project — zero compilation errors, your databases still work, SAF data is preserved in the serialized fields.
• Re-import SAF later and it all comes back. No lock-in, no broken builds.

SIMPLE ITEM FORGE INTEGRATION (Optional)

• When paired with Simple Item Forge, unlock item code dropdowns for skill-item relationships.
• Fully automatic detection — just import both packages.
• Every skill gains 4 item reference fields: granted by item, required equipment, produces item, and reagent costs.
• Link item databases in the wizard Setup step — codes populate automatically.
• The JSON content pipeline is SIF-aware too.
• Everything round-trips safely. Remove Simple Item Forge — zero errors. Re-import later — links restored.

SIMPLE ENEMY FORGE INTEGRATION (Optional)

• When paired with Simple Enemy Forge, unlock enemy and faction code dropdowns for skill-enemy relationships.
• Fully automatic detection — just import both packages.
• Every skill gains 5 enemy/faction reference fields: summon, learned from, trainer, faction effectiveness, and faction restriction.
• Everything round-trips safely. Remove Simple Enemy Forge — zero errors. Re-import later — links restored.

SIMPLE QUEST FORGE INTEGRATION (Optional)

• When paired with Simple Quest Forge, unlock quest code dropdowns for skill-quest relationships.
• Fully automatic detection — just import both packages.
• Every skill gains 2 quest reference fields: unlocked by quest and rewarded by quests.
• Everything round-trips safely. Remove Simple Quest Forge — zero errors. Re-import later — links restored.

INCLUDES

- 15-page HTML documentation (multi-page + single-page format)

- 2 demo scenes:

ARPG Skill Demo (browse skills, rank up, unlock tree nodes, equip loadouts, cast combos in a 4-tab interactive UI)

Soulslike Cross-Forge Demo (7-tab demo showcasing integration with all 4 companion forges — browse items, enemies, quests and see how they connect to skills. Requires SAF + SIF + SEF + SQF installed.)

- 6 genre templates with example skills (ARPG, MOBA, MMO, Turn-Based, Action, Roguelike)

- Zero runtime dependencies — generated output is plain ScriptableObjects and enums

- Unity 2021.3 or later (including Unity 6)

- All platforms — editor-only tool, generated output has no platform-specific code

- ~160 C# scripts (~34 Runtime, ~65 Editor, ~60 Generated)

- 2 assembly definitions: SimpleIdleForge.Runtime, SimpleIdleForge.Editor

- 5 demo scenes (Hub + 4 demos)

- 14 HTML documentation pages + 1 CSS stylesheet

- No third-party dependencies

- Optional: Simple Attribute Forge (detected via reflection)

- Optional: Simple Item Forge (detected via reflection)

- Optional: Simple Enemy Forge (detected via reflection)

- Optional: Simple Quest Forge (detected via reflection)

- Optional: Simple Skill Forge (detected via reflection)

- 9 runtime components, 5 static utilities, 3 API hook interfaces

- 6 genre templates: Classic Incremental, RPG Idle, Factory Tycoon, Prestige Heavy, Survival Idle, Gacha Collection

Still building idle game systems by hand?

Seriously. Stop it.

Simple Idle Forge gives you 5 interconnected wizard tools that generate production-ready idle game databases — resources, generators with cost scaling, upgrades, prestige layers, and achievements — complete with type-safe enums, custom inspector editors, and full JSON content generation support!

OFFLINE DOCUMENTATION HERE!

THE FIVE FORGES

Resource Forge

- Define currencies, materials, energy, and prestige points

- Starting amounts and optional caps with 5 cap modes (None, Hard, Flat, Curve, Step)

- Display formatting: K/M/B/T suffixes, scientific notation, engineering notation

- Display colors per resource

- Custom dynamic properties (Categories, Flags, Numerics, Texts)

- 6 genre templates: Classic Incremental, RPG Idle, Factory Tycoon, Prestige Heavy, Survival Idle, Gacha Collection

Generator Forge

- Define buildings, workers, and producers that generate resources over time

- Multi-resource production (one generator can produce multiple resources)

- Multi-resource costs with 5 scaling formulas and interactive preview sliders

- Two production modes: Continuous (Cookie Clicker style) and Timer (Adventure Capitalist style)

- Timer mode shows visible progress bars, Speed bonuses make timers tick faster

- Prerequisites to gate unlocking (resource amount, generator level, upgrade purchased)

- Milestone bonuses at level thresholds (x2 at level 25, +50% at level 50, etc.)

- TWO-LEVEL dynamic properties — generator-level AND milestone-level independently

Upgrade Forge

- Define boosts, automation triggers, and unlocks

- Multi-resource costs with scaling

- 6 effect types: Multiply, Add Flat, Add Percent, Unlock, Automate, Resource Grant

- One-time or repeatable purchases

- Prerequisite chains (requires generator level, resource amount, or another upgrade)

- Automate-type upgrades wire directly into the auto-purchase system

- Quick presets: Double Production, +50%, Automate, Unlock, Grant Resource

Prestige Forge

- Define entire rebirth cycles

- Configure prestige currency and source resource

- 4 formula types: Sqrt (Cookie Clicker standard), Linear, Log, Polynomial

- Reset rules control exactly what gets wiped and what survives

- Target specific resources, generators, or upgrades — or reset ALL

- Permanent bonuses that scale with total prestige currency earned

- Stack unlimited prestige layers

- Included demos ship with 1, 2, 3, and 4 layers

Achievement Forge

- Define global milestones, challenges, and goals

- Conditions: resource amount, generator level, upgrade purchased, prestige count, total production

- Multiple rewards per achievement (grant resources, add multipliers, unlock features)

- Hidden achievements (secret, revealed on completion)

- Repeatable achievements (daily challenges that can be earned multiple times)

OFFLINE PROGRESS CALCULATOR

When your player closes the app and comes back hours later, the offline progress calculator figures out exactly what they earned while away:

- Configurable efficiency: flat percentage, smooth curve, or step-based diminishing returns

- Optional max offline time cap (e.g., 24 hours max)

- Detailed report of every resource earned

- Pre-formatted summary string for your "Welcome Back" popup

- Time-to-afford queries for UI countdown timers — "You can afford this in 2m 34s"

Your players come back to meaningful rewards, not a blank screen.

NOTE: Only testable on deployed games or apps and not in the unity editor.

DOUBLE PRECISION — NUMBERS TO INFINITY

- Every game value uses double precision (1.7×10^308 range)

- Far beyond the 3.4×10^38 limit that breaks most projects

- Built-in number formatter: K/M/B/T/Qa/Qi suffixes (51+ tiers)

- Scientific notation, engineering notation

- Time formatting ("4h 23m") and rate formatting ("1.5M/s")

TWO PRODUCTION MODES

- Continuous — resources flow every frame, smooth and constant (Cookie Clicker style)

- Timer — resources arrive in batches after a countdown with a visible progress bar (Adventure Capitalist style)

- Speed bonuses from upgrades make timers tick faster

- Mix both modes in the same game

- Factory Tycoon demo uses Continuous for extractors and Timer for refineries

COST SCALING WITH LIVE PREVIEW

5 scaling formulas for generator and upgrade costs:

- None — cost stays constant forever

- Linear — cost increases by a flat amount each level

- Exponential — the industry standard (Cookie Clicker uses 1.15×)

- Polynomial — quadratic, cubic, or custom power curves

- Logarithmic — gentle late-game scaling that flattens out

- Exponential presets: Gentle 1.07, Standard 1.15, Steep 1.30, Aggressive 1.50

- Interactive slider: drag from level 1 to 200, see exact cost before generating

BONUS STACKING PIPELINE

- Transparent formula: (base + flat bonuses) × (1 + percentage bonuses) × multipliers

- Upgrades, prestige, achievements, and buffs all feed into the same pipeline

- No hidden interactions, no order-of-operations bugs

- You always know exactly how bonuses combine

DYNAMIC PROPERTY SYSTEM

- No hardcoded fields — you define your own Categories, Flags, Numerics, and Texts

- Generator Forge supports TWO levels — generator-level AND milestone-level properties

- Your game, your properties — works for any genre

JSON CONTENT PIPELINE

- Export your schema as Full JSON, Light JSON, or Markdown

- Generate entries by hand or with any external tool that outputs JSON

- Import directly — validates every entry, checks codes against linked databases

- All 4 included demo games were built this way

- JSON source data for every demo is included

FOUR COMPLETE PLAYABLE DEMO GAMES

Not tech demos. Complete idle games with polished UI, multiple progression systems, and hours of content.

Simple Kingdom — Classic Idle Clicker

- 7 resources, 8 generators, 20 upgrades, 1 prestige layer, 20 achievements

- Medieval fantasy theme, centered column layout

- Teaches: core idle loop, prestige basics, achievement design

Factory Tycoon — Industrial Supply Chain

- 12 resources, 10 generators, 24 upgrades, 2 prestige layers, 25 achievements

- 3 Continuous extractors + 7 Timer processors with progress bars

- Royal maroon and gold theme, centered column layout

- Teaches: timer production, multi-resource economies, stacked prestige

Survival Idle — Resource Decay Challenge

- 16 resources, 12 generators, 24 upgrades, 3 prestige layers, 30 achievements

- Food, water, and warmth drain constantly with color-coded vital bars

- 5 Continuous gatherers + 7 Timer crafters

- Neumorphic B&W theme, full Melvor-style sidebar layout

- Teaches: resource decay, vital management, three-layer prestige

RPG Idle — Dark Soulslike + Cross-Forge Showcase

- 19 resources, 14 generators, 27 upgrades, 4 prestige layers, 35 achievements

- Combat zones drain health and endurance while producing souls

- 10 Timer generators (combat rounds, crafting cycles) + 4 Continuous

- Dark neumorphic crimson theme, sidebar layout

- Detects companion forge packages at runtime

- Teaches: cross-forge ecosystem, deep prestige, combat drain

Every demo includes its JSON source data.

RUNTIME COMPONENTS

9 pure C# runtime trackers:

- IdleResourcePool — resource amounts, caps, fill ratios, events

- IdleGeneratorManager — levels, production, timer mode, milestones, auto-collect

- IdleUpgradeTracker — purchases, prerequisites, effects, bonus collection

- IdlePrestigeManager — prestige cycles, reset rules, permanent bonuses

- IdleMilestoneTracker — achievement completion, conditions, reward granting

- IdleBuffManager — temporary boosts with duration tracking

- IdleProgressCalculator — offline progress, production snapshots, time-to-afford

- IdleAutoPurchaser — 4 strategies: Cheapest, Most Expensive, Round Robin, Disabled

- IdleStatisticsTracker — lifetime stats with auto-subscription to all events

- Full snapshot serialization on every tracker for save/load

GENERATED CUSTOM EDITORS

- Every wizard generates a professional Inspector editor alongside the database

- Split-panel layout with search, sort, filter by category

- Multi-select with bulk operations

- Pagination for large databases

EDITOR UTILITIES

- Batch Icon Assignment — scan a sprite folder, auto-match to entries by filename

- Database Export — export any generated database as clean JSON

CROSS-FORGE INTEGRATION

Automatically detects companion forge packages and enriches your wizards:

- Simple Attribute Forge — attribute names for stat-based scaling

- Simple Item Forge — item codes for loot rewards and crafting

- Simple Enemy Forge — enemy and faction codes for combat zones

- Simple Quest Forge — quest codes for milestone conditions

- Simple Skill Forge — skill codes for ability references

- Zero hard dependencies — install a companion, codes appear in dropdowns

- Remove it — zero errors, data preserved

INCLUDES

- 14-page HTML documentation (multi-page + single-page, neumorphic theme)

- 4 demo scenes with Hub scene

- 6 genre templates per forge (30 total)

- Zero runtime dependencies

- API hook interfaces for save/load, ad rewards, and notifications

• 11-page HTML documentation (multi-page + single-page format, light/dark mode)
•     Cookbook with 15 copy-paste recipes (mana costs, elemental weakness, status timers, buff stacking, critical hits, drain, instant kill, damage formulas, and more)
•     5 interactive demo scenes (Classic, ATB, Timeline, Press Turn, Action Point) + Demo Hub
•     Template Generator — generates a ready-to-run battle controller for any turn system
•     Pure C# — zero engine dependencies, zero third-party dependencies
•     Works on all platforms — no platform-specific code
•     Unity 2021.3+ compatible
•     5 turn system implementations
•     1 interface to implement on your character class
•     20 events, 11 actions, 4 query helpers

Still writing JRPG battle systems from scratch?

Seriously. Stop it.

Simple JRPG handles the battle flow so you can focus on what makes your game unique — your damage formulas, your status effects, your UI.

Set up your characters, pick a turn system, and start calling actions.

Simple JRPG manages turn order, tracks battle state, and notifies you whenever something happens so you can react however you want.

OFFLINE DOCUMENTATION HERE! 

HOW IT WORKS

• Create a battle, add your characters, pick a turn system — your choice.
• Call actions like DealDamage, Heal, Revive, or Flee. You calculate the numbers, Simple JRPG applies them and tells your game what happened.
• Every action triggers an event — damage dealt, character knocked out, status applied, battle ended.
• Hook into any of these to update your UI, play animations, trigger sound effects, or run custom logic.
• Simple JRPG doesn't care what your stats look like, what "Fire" means in your game, or how you calculate damage. That's all yours.

5 TURN SYSTEMS INCLUDED

• Classic — Characters act in speed order, one round at a time. The standard JRPG turn system.

• ATB (Active Time Battle) — Each character has a gauge that fills based on their speed. When it's full, they can act. Faster characters act more often.

• Timeline / CTB — Every action has a cost. Heavy attacks push your next turn further away. Light actions let you act again sooner. A visible timeline shows who acts when.

• Press Turn — Teams take turns in phases. Each phase starts with a pool of action points. Smart plays conserve points; mistakes waste them.

• Action Point — Characters can save points by skipping their turn, then spend those saved points later for multiple actions in a row.

• Want something different? Implement the turn system interface and build your own. You can just do that if you want.

ACTIONS

• DealDamage — hit one target or a whole group
• Heal — restore HP to one target or a whole group
• Kill — instantly knock out a character
• Revive — bring a knocked-out character back
• ApplyStatus — apply any status effect (poison, stun, whatever you define)
• RemoveStatus — remove a status effect from a character
• ApplyBuff — apply any buff or debuff (attack up, defense down, your call)
• RemoveBuff — remove a buff or debuff from a character
• Flee — escape from battle
• RemoveCombatant — pull a character out of battle entirely
• EndBattle — manually end the battle with a specific outcome
• You could add more events if you want.

20 EVENTS

• Battle started, battle ended
• Turn started, turn ended
• Before damage, before heal (intercept and modify or cancel)
• Damage dealt, healed
• Character knocked out, character revived
• Status applied, status removed
• Buff applied, buff removed
• Fled, character removed
• Group damage dealt, group healed, group status applied, group buff applied

Every action fires an event.

There's no built-in UI or animation system — you listen for the events you care about and handle them your way.

INTERCEPT ACTIONS BEFORE THEY HAPPEN

• The "before damage" and "before heal" events fire before the action goes through.
• Change the damage amount, boost healing, or cancel the action entirely.
• Use these to build dodge mechanics, shields, damage reduction, healing amplification — anything.

BUILT-IN HELPERS

• Get all enemies, allies, alive characters, or dead characters with one call
• Full battle history — every action recorded with turn number and sequence
• Battle result summary — outcome, total turns, survivors
• Automatic win/loss detection

TEMPLATE GENERATOR

• Window > Simple JRPG > Generate Battle Controller
• Pick a turn system, name your script, hit Generate.
• Get a complete, ready-to-run script with placeholder logic and clear TODO comments showing you exactly what to customize.
• Attach it to a GameObject, hit Play, and you have a working battle.

YOUR CHARACTERS, YOUR RULES

• Your character class just needs to provide: a name, whether they're alive, which team they're on, their speed, and methods to take damage and heal.
• Beyond that, add whatever you want — MP, defense, elemental resistances, equipment, level, anything.
• Simple JRPG never touches your custom stats. It only uses what it needs to run the battle.

CLEAN, PORTABLE CODE

• No singletons, no global state, no MonoBehaviours, no ScriptableObjects.
• Create a battle, use it, done. Run multiple battles at the same time if you need to.

Number of Audio Wavs: 19

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

Minutes of audio provided: 22

Pack of Sneaky Music For Games

❮❮❮❮❮ HERE’S EVERYTHING YOU’RE GETTING WITH THIS PACK ❯❯❯❯❯

• 7 Original high-quality music tracks
• 19 WAV Files including Full Tracks, Alt & Short Versions, Loops & Stingers
• 22 Minutes of Audio in 16-bit / 44.1 Khz format
• Commercial Rights & Royalty-Free License

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

1. Setting A Trap
2. The Ultimate Heist
3. Exciting Quirky Tune
4. The Greatest Detective
5. Creative Soundtrack
6. Inspiring Creativity
7. Sneaky Squirrel

❮❮❮❮❮ 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

ONE UI SYSTEM. EVERY DEVICE. ZERO HASSLE.

Stop manually coding different layouts for desktop, mobile, and tablets.

Adaptive UI Layouts automatically detects your player's device and applies

the perfect layout - instantly.

✓ Works with WebGL, standalone, and mobile builds

✓ Compatible with animated and code-controlled UI

✓ Set it up once, works everywhere

✓ No complex scripting required

Create a responsive UI that adapts automatically. Focus on your game, not

device-specific UI code.

Adaptive UI Layouts

Simplified Multi-Platform UI Development

Create one UI system that automatically adapts to different devices and screen configurations.

Adaptive UI Layouts allows you to design your interface once and automatically apply the correct layout for desktop, mobile, and tablet devices.

• Create one UI setup that adapts automatically across platforms

• Avoid writing custom UI positioning code for every resolution

• Reduce development time for multi-platform projects

• Works with WebGL, standalone builds, and mobile devices

Live Demo

Try the WebGL demos to see Adaptive UI Layouts in action:

Responsive UI Demo

https://colpolstudios.itch.io/adaptiveuilayouts-web-and-portrait

Character UI Demo (World Space Canvas)

https://colpolstudios.itch.io/adaptiveuilayouts-character-use-web-and-portrait

Resize the browser window on desktop or open the demo on a mobile device to see the UI automatically adapt to screen size and orientation.

Publisher Website & Support

For documentation, updates, and support:

https://colpolstudios.wixsite.com/studio-design

Automatic Device Detection & Layout Application

The system automatically detects device type and applies the correct layout profile.

• Automatically detects desktop vs mobile devices

• Works with WebGL builds on mobile browsers

• Supports manual orientation controls for Device Simulator testing

• Automatically responds to screen size, aspect ratio, and orientation

Flexible Layout Profiles

Create and manage layout configurations for different devices and orientations.

• Create profiles for Desktop, Mobile Portrait, and Mobile Landscape

• Use only the profiles you need (for example, Desktop + Mobile Portrait)

• Capture the current UI layout with one click

• Update layouts easily by repositioning UI and recapturing

• Modify existing profiles by selecting them before capturing

• Includes Prefab workflow for safe UI iteration

Animation & Code-Friendly

Adaptive UI Layouts is designed to work smoothly alongside animations and scripted UI systems.

• Layout applies once at Start() and does not interfere with animations

• UI elements can be animated freely without layout resets

• Safe to modify UI via scripts or gameplay systems

Performance Optimized

The system is lightweight and designed for runtime efficiency.

• Layout applied only when needed (startup or orientation change)

• Efficient UI element lookup using cached dictionaries

• Minimal runtime overhead

Easy Workflow

A straightforward workflow designed for fast integration.

• Simple setup: Add two components to your Canvas

• Visual workflow: position UI → capture layout → assign profiles

• Works with Unity UI (uGUI) systems

• Easy to modify or expand layouts later

Key Benefits

• Save time when developing multi-platform UI

• Reduce repetitive UI positioning work

• Keep UI systems clean and maintainable

• Support desktop, mobile, and WebGL from a single UI setup

• Render Pipeline: Universal Render Pipeline (URP) ONLY.
• Shader Type: Custom URP Shader.
• Please Note: Currently, this asset only supports URP. Compatibility with other rendering pipelines (like HDRP or Built-in) is planned for future updates.

Welcome to FlexShader, the debut asset release from Winterbite! We are dedicated to create versatil tools for developers and will continuously support this package with new effects and additional shaders in the future.

FEATURES

• 12 Moods — Happy, Emotional, Dark, Fantasy, Epic, SciFi, Horror, Lullaby, Ambient, Mystery, Celtic, Creepy. Each mood sets the scale, chord progressions, rhythm patterns, tempo range, and default instruments.

• 15 Lead Instruments — Flute, Violin, FrenchHorn, Guitar, Choir, SynthLead, Celesta, Chimes, and more. Set to Auto or override manually.

• Deterministic Seeds

Music Weaver generates original, royalty-free music tracks entirely from code — no audio files, no middleware, no external dependencies.

Save to you disk in .Wav and have a bunch of cool background music for your game, with different lenghts and so on

:D

• Hand Tracking Type: Real-time monocular camera-based hand tracking
• Landmark Tracking: 20+ 3D landmarks per hand (wrist, palm, finger joints)
• Hand Detection: Automatic left and right hand identification
• Mesh Animation: Full 3D hand mesh animation with finger joints and wrist rotation
• Movement Tracking: World-space hand position, rotation, and scale tracking
• Gesture Support: Landmark-based data suitable for custom gesture and action detection
• Input Sources: Device camera, video file, static image
• Tracking Models:
  Lite Model (optimized for mobile performance)
  Heavy Model (higher accuracy)
• Rendering Support: Built-in Render Pipeline, URP, HDRP
• Platforms: Android, iOS, Windows, macOS
• Unity Version: 2021 or later
• Dependencies: None (works without AR SDK)
• Setup: Plug-and-play prefabs with demo scenes included

AR Hand Mesh Tracking is a powerful plugin that enables real-time hand tracking, full 3D hand mesh animation, and AR-style hand interaction — without using any AR SDK.

The plugin detects left and right hands, tracks 20+ 3D hand landmarks, animates realistic 3D hand meshes, and follows hand movement in world space, allowing developers to build gesture-based AR interactions using only a camera.

Unlike traditional AR solutions, this system does not rely on AR Foundation, ARCore, or ARKit. It is ideal for lightweight AR experiences, rapid prototyping, and projects that need hand-based interaction before integrating an AR SDK.

Key Highlights

• Real-time hand landmark tracking (20+ points per hand)
• Full 3D hand mesh animation
• Hand movement tracking (position, rotation, scale)
• AR-style hand mesh interaction (no AR SDK required)
• Left & right hand detection
• Gesture & action detection ready
• Interact with AR objects, UI, and physics items
• Supports Camera, Video, and Image input
• Lite & Heavy models for performance control
• Mobile and desktop friendly
• Plug-and-play prefabs with demo scenes

Perfect For

• AR hand interaction systems
• Gesture-based games and applications
• Mobile AR experiences
• AR prototyping and experimentation
• HCI, research, and education projects
• Hybrid AR projects using or preparing for AR SDKs

If you’re looking for a fast, flexible, and SDK-free solution for AR hand tracking, AR Hand Mesh Tracking gives you everything you need to build natural, hand-driven interaction.

Features

• Scene Scanning
• Project Scanning
• Smart Fixes
• Missing Scripts
• Build Safety
• Review Window
• Undo Support
• JSON Export
• Zero Overhead
• Auto Suggestions
• Prefab Safety
• ScriptableObject Scan

Supported Unity Versions

• 2019.4 LTS
• 2020.3 LTS
• 2021.3 LTS
• 2022.3 LTS
• 2023.x / Unity 6 / Above 
• Compatible with all future versions

Supported OS

• Windows
• macOS
• Linux

Documentation -> Online Documentation

⚠️ Stop shipping builds with broken references

Deleting scripts, renaming folders, prefab overrides, branch merges—Unity projects slowly collect missing references and “Missing Script” components. These issues silently grow until they explode as NullReferenceExceptions or failed builds.

Missing Reference Killer is a Unity Editor tool built to find, review, and safely fix these problems before they reach runtime.

This tool is not a passive logger. It actively scans your project and shows you exactly where things are broken—clearly, early, and safely.

🔍 Deep & Accurate Scanning

• Scene Scan
  Detects missing references and broken components in the active scene.
• Project-Wide Scan
  Scans Prefabs and ScriptableObjects across your Assets folder.
• Missing Script Detection
  Finds ghost components left behind after deleted or renamed scripts.

Issues are clearly color-coded so you can instantly see what is critical and what is safe to clean.

🧠 Smart Suggestions & Safe Fixing

• Smart Suggestions
  Analyzes variable names and expected component types to suggest correct fixes.
• Safe Fix Mode
  Apply supported fixes without touching critical data.
• Review Window
  Preview every change with Old Value → New Value before applying.
  Nothing is applied blindly.

🛡️ Build Safety Guard

• Pre-Build Scan
  Automatically checks for broken references when you press Build.
• Build Protection
  Stops the build and alerts you if critical issues are found—saving you from shipping a broken game.

🌟 Why this tool?

This isn't just a scanner; it's a workflow accelerator. We built it to be the "Check Engine Light" for your Unity project. It handles everything from simple null fields to deep complex prefab data corruption.

📊 Professional Workflow Tools

• Clean, structured results view
• Group and filter issues by Scene, Asset type, or severity
• Export scan results as JSON for audits or team use

⚡ Key Benefits

• Editor-only tool (zero runtime overhead)
• Full Undo / Redo support
• Works with large projects and refactors
• Compatible with Addressables and modern Unity workflows

Missing Reference Killer is designed for developers who care about stability, clean projects, and stress-free releases.

Clean project.
Safe builds.

Keep your project clean. Keep your sanity. Get Missing Reference Killer today.

- "by DecNet"

JOIN DISCORD | DOCUMENTATION | OTHER ASSETS

9 prefab

9 model

LowPolyNature-MiniPack

This free low poly pack has 9 prefabs. All models are ready to put in scene.

All models are optimized with approximately 90-100 tris each.

-3 Tress

-3 Bushes

-2 Grasses

-1 Rock

All models use the same texture and material.

Don't forget to ranked the package if you download it.

Thank you!

The package catches up the active ProjectBrowser Editor Windows and edits the Title GUIContents of each Locked Project Tabs according to a selected Titling Mode Settings.

This package modifies the Project tab titles to easily distinguish between multiple Project tabs. Works only with Two Column Layout.

The package includes multiple titling modes:

• Folder Only. Title consist of the lowest level folder name
• Wrap. A fancy path compress mode.
• Shrink. The maximum symbols within the given Limit used.
• RegEx. Setup your desired way of titling.

How to use:

The package activates immediately. The Titling mode Settings can be found on the top menu: Window/Titled Project Tabs Settings

- Unity 2021.3 LTS or newer

- Built-in, URP, and HDRP compatible

- Separate Runtime and Editor assemblies

- Zero runtime allocations

- No third-party dependencies

- IL2CPP and Mono compatible

- Namespace: DawgTools.Smooth

QUICK START

using DawgTools.Smooth;

using UnityEngine;

public class SmoothExample : MonoBehaviour

{

    public float halfLife = 0.12f;

    float _value;

    void Update()

    {

        float target = Mathf.Sin(Time.time) * 10f;

        _value = Smooth.ExpHalfLife(

            _value, target, halfLife, Time.deltaTime);

    }

}

LICENSE

Licensed under Unity Asset Store EULA.

DAWG Tools - Smooth PRO

Most Unity projects have code like this:

current = Mathf.Lerp(current, target, 0.1f);

It runs every frame, applying a fixed percentage step toward the target. At 30 FPS it applies 30 times per second. At 144 FPS it applies 144 times per second. Players on faster machines see faster smoothing.

The fix is one line:

current = Smooth.Exp(current, target, 10f, Time.deltaTime);

Same behavior at every frame rate. The math uses exp(-speed * dt) which naturally compensates for variable frame times.

Use cases: camera systems, UI motion and transitions, gameplay parameter smoothing, audio interpolation, network / multiplayer interpolation.

WHAT'S INCLUDED

Exponential Smoothing (Smooth class)

- Smooth.Exp — frame-rate independent exponential smoothing

- Smooth.ExpHalfLife — parameterized by half-life (designer-friendly: "halfway to target in 0.2 seconds")

- Smooth.ExpAngle — wrap-safe angle smoothing (no snapping at 0/360)

- Overloads for float, Vector2, Vector3, Quaternion, Color

Spring Dampers (Spring class)

- Spring.Critical — fastest convergence, no overshoot

- Spring.Damped — general-purpose, any damping ratio

- Spring.Bouncy — configurable overshoot and oscillation

- Overloads for float, Vector2, Vector3

- Adaptive substepping for frame-rate stable results

Easing Functions (Ease class)

- 30+ standard curves: Quad, Cubic, Quart, Quint, Sine, Expo, Circ, Back, Elastic, Bounce

- In / Out / InOut variants for each

- SmoothStep and SmootherStep (Hermite / Perlin)

- Ease.Lerp helper combining easing + interpolation

Conversion Utilities

- SpeedFromBrokenLerpT — convert existing lerp t values to correct speed

- SpeedFromHalfLife / HalfLifeFromSpeed

- ConvergenceTime — time to reach 90%, 99%, etc.

Editor Window (Window > DAWG Tools > Smooth Inspector)

- Three modes: Exponential, Spring, Ease

- Exponential: side-by-side graph of naive lerp vs Smooth.Exp at different frame rates

- Spring: response curve visualization showing overshoot for bouncy settings

- Ease: curve shape preview for all easing functions

- dt profile stress test (constant FPS, jittered frame times, FixedUpdate simulation, custom tick rates)

- Convergence analysis, migration helper, copy-to-clipboard snippets

EXAMPLES

Camera follow:

// Before (frame-rate dependent)

transform.position = Vector3.Lerp(

transform.position,

target.position,

followSpeed * Time.deltaTime

);

// After (consistent at any FPS)

transform.position = Smooth.ExpHalfLife(

transform.position, target.position,

0.15f, Time.deltaTime);

UI fade (works during frame drops and with timescale = 0):

canvasGroup.alpha = Smooth.ExpHalfLife(

canvasGroup.alpha, targetAlpha,

0.08f, Time.unscaledDeltaTime);

Rotation (no snapping at 0/360 boundary):

currentYaw = Smooth.ExpAngle(

currentYaw, targetYaw,

Smooth.SpeedFromHalfLife(0.12f),

Time.deltaTime);

Spring motion:

position = Spring.Critical(

position, target,

ref velocity, 5f,

Time.deltaTime);

Easing:

float t = elapsed / duration;

float eased = Ease.OutCubic(t);

value = Mathf.LerpUnclamped(start, end, eased);

Technical Details

• Unity 2021.3 LTS or newer
• Built-in, URP, and HDRP compatible
• Editor-focused tool (no runtime dependencies required)
• Clean namespace: DawgTools.OKLab
• Implementation follows Björn Ottosson’s reference specification
• Contrast computed using correct linear RGB luminance

Runtime Integration

At runtime, simply replace:

Color.Lerp(a, b, t);

With:

OKLabColor.Lerp(a, b, t);

Use perceptual interpolation only where it matters — UI transitions, theme blending, animated color states.

Designed For

• UI animation systems
• Theme engines
• Accessibility-conscious projects
• Design-heavy applications
• Production workflows requiring visual consistency

License

Licensed under the Unity Asset Store EULA.

DAWG Tools - OKLab Color Inspector PRO - Perceptual Color Tools for Unity

Unity’s default Color.Lerp interpolates colors in RGB component space.

https://dawgtools.org/unity/

For UI and theme transitions, this often results in:

• Desaturated or “dirty” midpoints
• Perceived brightness dips
• Unintended hue shifts
• Inconsistent animation quality

The OKLab color space is designed so that distance and interpolation better match human perception.

This tool makes the difference visible, measurable, and actionable inside the Unity Editor.

OKLab interpolation produces smoother, visually consistent gradients and transitions because it operates in a perceptual color space rather than raw RGB component space.

Instead of guessing how a transition will look, you can:

• Compare Gamma RGB vs Linear RGB vs OKLab interpolation
• Inspect perceptual midpoints
• Measure ΔE distance between colors
• Validate contrast compliance before shipping

1. Typical Workflow

1. Select two UI colors (e.g., Normal → Hover).
2. Compare Unity RGB interpolation against OKLab interpolation.
3. Inspect midpoint, hue drift, chroma, and contrast.
4. Replace Color.Lerp with OKLabColor.Lerp in runtime code.

2. Who It’s For:

• UI / UX engineers
• Technical artists
• Tools programmers
• Teams implementing dynamic themes
• Developers who care about visual polish and accessibility

3. WHAT'S INCLUDED

Interpolation Comparison

Side-by-side preview of:

• Unity RGB (Gamma)
• Linear RGB
• OKLab interpolation

Instantly see how transitions differ visually and mathematically.

Perceptual Metrics

• ΔE (perceptual distance measurement)
• Live midpoint inspection
• Chroma comparison
• OKLab component breakdown (L, a, b)
• Hue angle visualization

Accessibility & Contrast Tools

• WCAG contrast ratio calculation
• AA / AAA / Large-text thresholds
• Automatic best-text color suggestion
• Contrast validation against background colors

Computed correctly in linear luminance space.

OKLab Utilities

• OKLabColor.Lerp runtime helper
• OKLab decomposition per color
• Copy helpers (Hex, OKLab values)
• Lock Lightness (L)Optional perceptual constraints:
  Lock Chroma (C)
  

ASSET LIST & POLYCOUNTS (TRIANGLES)

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

Tedy Bear ...2,510

Dinosaur ...2,042

Lion ...2,006

Bunny ...2,008

Elephant ...2356

Giraffe ...1,648

Penguin ...1,848

Duck ...1,116

Total assets: 8 

+ simple room props with Demoscene

Textures: None

Texture dimensions: N/A

Texture maps: None

Materials: Unity materials only (URP compatible)

Render Pipelines: Built-in, URP

A charming set of stylized low-poly plush toy animals, perfect for children's room scenes, casual games, and cozy environment props. Each character has a soft, rounded form inspired by classic stuffed toys.

Package Contents:

• 8 plush toy animal prefabs (Teddy Bear, Bunny, Lion, Dinosaur, Elephant, Giraffe, Penguin, Duck)
• Simple demo room with props
• URP compatible materials
• No textures required
• Demo scene included

Low Poly Train 11 Lowpoly 3d model It is best for use in games and other real time applications.

Model is built with great attention to details and realistic proportions with correct geometry. 

4k textures are very detailed so it makes this model good enough for close-up. 

Features:

•     Low Poly Train 11_ polys:13372, Tris:31494, Verts:17748
•     Map size HD ---diffuse,specular,height,Normal,occlusion
•     Model is correctly divided into main part and animation parts
•     Model completely unwrapped.
•     Model is fully textured with all materials applied.
•     Pivot points are correctly placed to suit animation process.
•     All nodes, materials and textures are appropriately named.

Number of textures: 13

Texture dimensions: 4096*4096

Polygon count [Draton]

Verts: 5,867

Faces: 5,668

Tris: 11,326

Rigs: Yes

UV mapping: Yes

Material types and texture maps: PBR

Draton 3d model

Verts : 5,867

Faces : 5,668

Tris : 11,326

• Navigation-first architecture

• Deterministic panel lifecycle management

• LRU-based panel caching and automatic reuse

• Safe panel eviction and recreation

• Screen and Modal panel support

• Navigation Anchors for hub-style navigation

• Runtime-enforced screen exclusivity

• Inspector-driven navigation setup

• Engine-agnostic Core architecture

• Unity uGUI adapter included

• Optional DOTween animation integration

• Automatic setup via editor menu

• Basic and DOTween sample scenes included

• Fully extensible and modular design

Advanced UI Framework is a navigation-first UI system for Unity, designed to provide deterministic behavior, explicit lifecycle control, and clean architectural separation.

Instead of treating UI as loosely connected GameObjects, this framework manages UI as a structured system with defined ownership, navigation history, and lifecycle rules.

Panels are reused automatically through an internal LRU cache, preserving state while allowing safe memory eviction when needed. Navigation Anchors enable predictable hub-style navigation flows, and runtime-enforced rules ensure only one Screen is active at a time.

The Core architecture is engine-agnostic and separated from the Unity adapter, allowing flexibility and long-term scalability. Navigation can be configured entirely through the Inspector using Panel Descriptor and Panel Action components, or controlled directly through code using the Navigator API.

This framework is designed for developers building production-ready projects who need reliable, maintainable, and scalable UI infrastructure.

Included:

• Basic usage sample

• Optional DOTween integration sample

• Automatic setup tools

• Full documentation