Asset Store newest packages

• Wheel Picker Core – reusable scrolling wheel selection system

• Date Picker – day / month / year selection

• Time Picker – hour / minute / AM-PM format

• Custom Picker – configurable list of selectable values

• Example Scene demonstrating setup and usage

• Prefabs for quick integration

A smooth and customizable Wheel Picker UI component for games/apps that allows users to select values using a scrolling wheel interface.

This asset makes it easy to implement date pickers, time picker, and custom value pickers commonly used in mobile apps and modern game interfaces.

Designed to be lightweight, flexible, and easy to integrate with UI systems.

✨ Features

• Smooth scrolling wheel selection

• Built-in Date Picker (day / month / year) (Month Formate)

• Built-in Time Picker (hour / minute / AM-PM)

• Fully customizable Custom Picker (Supported Text , Image etc..)

• Supported your custom theme ui

• Snap-to-center value selection

• Simple inspector-based configuration

• Lightweight and optimized performance

• Clean and easy-to-understand scripts

• 115 line-style icons
• Each icons is of size 512x512 px
• Ready for use in game development, app design, or UI/UX projects
• Every icon is in flat white color, customizable to any color.

This icon pack includes a collection of high-quality 2D casual-style icons that cover a variety of in-game elements. The icons are designed in a simple yet effective style, making them versatile for many projects, including mobile games, apps, and websites. The pack contains elements like achievement badges, alert notifications, and armor, providing all the necessary components for your game's interface. These icons are customizable and ready to integrate into your project, ensuring both clarity and visual appeal.

• 114 flat-style icons
• Each icons is of size 512x512 px
• Ready for use in game development, app design, or UI/UX projects
• Every icon is in flat white color, customizable to any color.

The "Icons Pack - Flat Style" features a collection of 114 high-quality icons in a sleek, flat design, ideal for developers looking to enhance their UI/UX design. These icons are fully customizable, suitable for a wide range of genres including mobile, desktop, and web applications.

Number of textures: 108

Texture dimensions: 256 x 256, 512 x 512

Polygon count:

Bike 1: 23.1k

Bike 2: 29.8k

Bike 3: 15.8k

Bike 4: 17.8k

Bike 5: 8.9k

Bike 6: 15.7k

Bike 7: 17.9k

Bike 8: 23.3k

Bike 9: 21.1k

Bike 10: 15.9k

Bike 11: 29.8k

Bike 12: 30.4k

Bike 13: 34.4k

Bike 14: 19.7k

Bike 15: 29.3k

Bike 16: 18.6k

Bike 17: 25.3k

Bike 18: 27.3k

Bike 19: 20.2k

Bike 20: 19k

Bike 21: 20.1k

Bike 22: 16.6k

Bike 23: 17.6k

Bike 24: 16.9k

Bike 25: 20k

Bike 26: 23.2k

Bike 27: 19.9k

Bike 28: 15.3k

Bike 29: 22.3k

Bike 30: 18k

Bike 31: 27.3k

Bike 32: 25.2k

Bike 33: 23.1k

Bike 34: 27.4k

Bike 35: 22.4k

Bike 36: 22.7k

Bike 37: 29.8k

Minimum polygon count: 8.9k

Maximum polygon count : 34.4k

Number of Prefabs: 37

Rigging: Yes

UV mapping: Yes

Turbocharge your next bike or motorcycle racing game, bike stunt game, open-world adventure game, or urban simulation with the Ultimate Motorcycle Pack. This massive collection features 37 highly detailed, completely unique motorcycle models, offering an unmatched variety of styles to populate your game world.

Whether you need high speed street racing, off road dirt tracking, or casual city commuting, this one insane collection has you covered. Based on the diverse roster, this pack includes models spanning every major motorcycle discipline

Key Features:

• Massive Variety (37 Unique Models): No simple palette swaps here. Every single bike features a unique chassis, bodywork, and design.
• Game-Ready & Optimized: Carefully modeled to balance high visual fidelity with optimal performance, making them perfect for both PC/Console and Mobile platforms.
• Fully Rigged for Animation: Wheels, handlebars, and chassis are rigged and properly pivoted, ensuring a smooth ride when hooked up to your custom vehicle controller.
• PBR Materials: Built with Physically Based Rendering in mind to ensure realistic metal, plastic, rubber, and paint reactions to your game's lighting.
• Vibrant Color Palettes: Eye-catching, bright finishes that pop on screen right out of the box.

Included Vehicle Categories:

• Sportbikes & Superbikes: Sleek, aerodynamic, and fully faired for high speed racing.
• Cruisers & Choppers: Classic, laid back designs with exposed engines and custom exhausts.
• Adventure & Touring Bikes: Heavy duty frames equipped with hard case luggage panniers and tall windshields for the long haul.
• Dirt Bikes & Dual-Sports: High clearance suspensions and rugged frames built for off-road tracks
• Streetfighters & Naked Bikes: Aggressive, stripped-down urban street machines
• Scooters & Mopeds: Perfect for populating city traffic or casual delivery missions

• 19 looping tracks in WAV and OGG format (24-bit / 44.1kHz)
• Unlimited royalty-free license - safe to use for your game and YouTube.
• 38 minutes of music
• No AI.

All tracks were made WITHOUT AI and are safe for YouTube.

Inspired by the terrifying, grungy textures of Silent Hill and Resident Evil.

19 high-quality dynamic layers organised into 5 'songs'.

Designed to be faded in and out of as the situation requires - see overview video for more details.

Seamless looping.

TRACKLIST:

Reflections

• Exploration Layer
• Cinematic / Dialogue Layer
• Tension Layer
• Combat Layer

Pit of Despair

• Exploration Layer
• Cinematic / Dialogue Layer
• Tension Layer
• Combat Layer

Once Familiar Now Forgotten

• Exploration Layer
• Cinematic / Dialogue Layer
• Tension Layer
• Combat Layer

In Limbo

• Exploration Layer
• Cinematic / Dialogue Layer
• Tension Layer
• Combat Layer

Dreamstate / Safe Room

• Exploration Layer
• Melodic Layer
• Subtle Unsettling Layer

Intended Use

These tracks were created to create a dark, gritty, unsettling atmosphere for your horror game. Start with the 'Exploration Layer' and fade in more layers as the player encounters new locations, NPCs, and enemies. While these tracks were originally written as 5 distinct songs, feel free to mix and match from different tracks to create interesting and potentially discordant soundscapes.

If you're interested in hearing some of my other work or contacting me for a custom soundtrack, check out https://sites.google.com/view/jamesfox-sound/

Album Artwork by Terri Krippner

Core System

• Built as a Unity Editor extension using EditorWindow
• Direct PostgreSQL connection (host, port, database, user, password)
• Supports PostgreSQL 10+ (local or remote servers)
• Automatic connection persistence and reconnection

Code Generation:

• Generates APIManager, data models, and API test script
• Schema-based C# class generation with type mapping

API Support:

• GET, POST, PATCH, DELETE
• JSON-based request/response handling

Editor Features:

• Table and schema management
• CRUD operations on table data
• Built-in API testing tool

Compatibility:

• Unity 2021.3+
• .NET Standard 2.1
• Supports all Unity target platforms (Windows, macOS, Android, iOS, WebGL, etc.)

Build, manage, and integrate databases directly inside Unity — with zero manual API integration required.

Database Manager For Unity is a powerful editor extension designed to streamline backend development for Unity projects. It eliminates the need to switch between Unity and external database tools by bringing database management, API testing, and automatic code generation into a single workflow.

Whether you're building a game backend, admin tool, or a data-driven application, this plugin helps you move faster with significantly less manual work.

Key Features

Direct PostgreSQL Connection

Connect your Unity project directly to a PostgreSQL database using secure credentials. Connection settings are saved and automatically restored.

Full Database Management Inside Unity

Create and manage your database without leaving the editor:

• View, create, and delete tables
• Modify schemas and column types
• Add or remove columns
• Configure primary keys

Built-in Data Editor (CRUD)

Manage table data visually:

• Insert, update, and delete rows
• Browse table records
• Edit gameplay or test data instantly

API Testing Toolkit

Test your APIs directly inside Unity:

• Supports GET, POST, PATCH, DELETE
• Payload builder and query filters
• Formatted response preview

No need for external tools like Postman.

Automatic API Code Generation

Generate production-ready Unity scripts with one click:

• APIManager runtime class
• Table-specific API methods
• Strongly typed C# data model classes

No manual networking or JSON parsing required.

Auto-Generated Test Script

Includes a ready-to-use APIManagerTest script:

• Runtime UI for API testing
• Example usage of generated code
• Quick validation in Play Mode

Why Use This Tool?

• Faster development workflow
• No backend expertise required
• Reduced repetitive coding
• All-in-one database and API solution inside Unity

Use Cases

• Game backends (player data, inventory, leaderboards)
• Data-driven gameplay systems
• Internal tools and dashboards
• Rapid prototyping and testing

Unity Version: 6000.x (Unity 6) and later

Render Pipeline: Compatible with URP, HDRP, and Built-in

Editor Only: Code Scaffold is an editor tool. No runtime scripts or assemblies are included in builds.

UI Framework: Built entirely with UI Toolkit (UIElements). No IMGUI.

Dependencies: None. Uses only built-in Unity APIs.

Generated Code: Pure C# with no dependencies on Code Scaffold or any third-party library.

Template Engine: Custom parser supporting placeholder replacement (`{{Key}}`), conditional blocks (`{{IF}}...{{ENDIF}}`), nested conditionals, and naming transforms (PascalCase, camelCase, snake_case, UPPER_CASE, lower).

Templates: 17 built-in templates stored as .txt files. Organized into 7 categories.

Folder Styles: Per-folder color and icon data stored as a ScriptableObject database asset. Renders via EditorApplication callbacks — zero performance impact in play mode.

Script Count: ~25 editor scripts, 0 runtime scripts.

Platforms: Works on Windows, macOS, and Linux editors.

C# Code Generator | Templates, Mass SO Creation & Folder Styles is a pattern-aware C# code generator built for Unity developers who want to write less boilerplate and start building faster.

Pick a template, fill in your parameters, and generate clean, production-ready C# scripts — all from a polished three-panel wizard or a simple right-click in the Project window.

What You Get

Ace Code Scaffold ships with 17 built-in templates covering the most common Unity scripting patterns:

• MonoBehaviour — Basic and Singleton (with DontDestroyOnLoad, thread-safety options)
• Networking — Netcode for GameObjects: NetworkBehaviour, Player Controller, Object Spawner (with NetworkVariables, ServerRpc, ClientRpc)
• ScriptableObject — Basic SO, Data Container (with mass asset creation), Event Channel
• Editor — Custom Editor, Custom Inspector (UI Toolkit), EditorWindow, Documentation Window, About Window, Property Drawer
• Patterns — Command, Object Pool, State Machine State
• Testing — Edit Mode and Play Mode test fixtures

Every template is fully parameterized. Toggle optional sections on or off, set class names, namespaces, method signatures, accent colors — the generated code adapts to your choices.

### Live Previews

The code preview panel shows your generated C# script updating character-by-character as you adjust parameters. For Editor Window templates, open the companion Live Visual Preview window to see a pixel-accurate rendering of the window you're creating — complete with toolbars, sidebars, status bars, and accent colors — all updating in real-time.

### Quick Create

Right-click any folder in the Project window and navigate to Create > Ace > Code Scaffold to generate any template directly into that folder. A compact Quick Create popup lets you fill in parameters and generate without opening the full wizard.

### Mass ScriptableObject Creation

The Data Container SO template lets you define a ScriptableObject class and batch-create named asset instances in one step. Define your fields, add your asset names, click Generate — the script and all SO assets are created together.

### Folder Styles (Bonus)

Right-click any Project folder to assign a color and icon badge. Visually organize your project at a glance — no configuration files, no setup.

### Zero Dependency

Generated code is clean, standalone C#. There is no runtime reference, no base class, no using directive pointing back to Code Scaffold. You can safely remove the tool at any time without affecting your project.

### Built for Unity 6

Designed for Unity 6 (6000.x) with UI Toolkit throughout. The editor UI is dark-themed, responsive, and follows Unity's design conventions.

AAA Rpg Choices

Wizard broomstick flight system

Advanced Dialogs

Multiple endings

Time control for cutscenes

Built to call methods between choices and dialogs

Fully controlled save & load flow

Explicit write / read order (no hidden serialization)

Key-based data registration system

Supports multiple independent data blocks

Safe loading (no crashes if save file is corrupt or missing)

Built-in versioning support

Designed for large-scale and long-term projects

Wizard combat system with advanced AI

Complete third person movement

Require new input system package to be installed

Require Post Processing for Built-In to be installed

Require AI Navigation package

Wizard School Complete AAA System is a powerful, all-in-one solution crafted for building immersive wizarding and fantasy experiences at a professional level. Designed with scalability and performance in mind, it delivers a complete gameplay foundation that blends cinematic magic combat, advanced AI, and deep RPG systems into a seamless workflow.

At its core, the system features dynamic magical combat with fluid attacks, defensive mechanics, and cinematic spellcasting that brings every encounter to life. Targeting logic allows enemies and players to prioritize by distance or vulnerability, creating more strategic and engaging battles. This is reinforced by an advanced wizard combat AI capable of reacting intelligently, making encounters feel alive and unpredictable.

Character control is built around a fully realized third-person movement system, including smooth transitions for sliding, crouching, and navigating environments such as stairs. Complementing this is an advanced broomstick flight system that enables fast, responsive aerial traversal and combat, expanding gameplay beyond the ground.

The package is designed for ease of use without sacrificing depth. A simple drag-and-drop setup allows rapid integration into projects, while full support for Xbox, Nintendo Switch, and PlayStation controllers ensures a polished experience across platforms. Built on Unity’s new Input System, player input is streamlined, flexible, and ready for modern development standards.

On the narrative side, the system includes a robust RPG dialogue and choice framework. It supports complex branching conversations, direct method calls between choices and dialogue events, and the creation of multiple endings based on player decisions. This allows developers to craft meaningful stories where every choice can shape the outcome of the game.

Cinematic tools such as time control for cutscenes provide greater control over storytelling and presentation, enabling dramatic sequences and polished in-game moments.

The save and load system is built with reliability and transparency in mind. It offers full control over the data flow with explicit write and read order, avoiding hidden serialization pitfalls. A key-based registration system allows modular data management, supporting multiple independent data blocks for complex projects. Safe loading ensures stability even if files are missing or corrupted, while built-in versioning makes it ideal for long-term development and updates.

This package requires the Unity Input System, AI Navigation, and Post Processing for the Built-In Render Pipeline to be installed.

Wizard School Complete AAA System is more than a toolkit. It is a complete foundation for building rich, reactive, and cinematic wizarding worlds with the depth and quality expected from modern AAA experiences.

• Unity 2022.3 or newer
• Supported Methods: GET, POST, PUT, DELETE, PATCH
• Supported Body Types: Raw (JSON/Text), Form-Data, x-www-form-urlencoded
• Dependencies: Native Unity components only (UnityEngine.Networking). No extra DLLs or massive third-party libraries required.
• Compatibility: Works across all platforms supported by UnityWebRequest (Windows, Mac, iOS, Android, WebGL, consoles).
• Source Code Included: Full C# source code provided so you can extend or modify the tool to fit your specific pipeline needs.

RESTKit allows you to import Postman collections and cURL commands directly into Unity, instantly converting them into ready-to-use API requests.

RESTKit is a powerful, yet easy-to-use Unity Editor tool and runtime client designed to streamline the process of integrating, testing, and managing REST APIs within your Unity projects.

Whether you are integrating cloud services, or connecting to external databases, RESTKit saves you hours of boilerplate coding by allowing you to instantly import API definitions and use them in your code.

Key Features

• cURL Import: Directly paste cURL commands to instantly generate Unity-ready API requests.
• Postman Integration: Import your existing Postman collections directly into Unity.
• ScriptableObject Architecture: Imported APIs are saved as APICollection and APIRequestDefinition ScriptableObjects, making them easy to manage, reference, and version control.
• In-Editor API Tester: Test your endpoints right inside the Unity Editor with a custom interface. Configure headers, body (JSON, raw), and form-data (including file uploads) without leaving Unity.
• Runtime API Client: A robust, built-in APIClient that handles the heavy lifting of UnityWebRequest.
• Clean & Modern UI: Reimagined with a premium, responsive Editor UI featuring smooth hover transitions and a sleek Dark/Light theme palette.
• Smart Redirect Handling: Intelligently handles 301/302 HTTP redirects under the hood, seamlessly converting methods to prevent dropped payloads and infinite loops.

Benefits

• No More Boilerplate: Stop writing repetitive UnityWebRequest code. Import your API once, and call it anywhere in your project with a single line of code.
• Stay in Unity: Test your APIs directly within the Editor ecosystem instead of constantly switching between Unity and external tools like Postman.
• Designer Friendly: By storing requests as ScriptableObjects, non-programmers can easily assign API calls to UI buttons or events via the Inspector.
• Type-Safe & Organized: Group your endpoints logically into Collections, ensuring your project stays clean even as your backend scales.

COMING SOON FOR SWAGGER!!!

Unity version: 6000.3 (Unity 6.3) or later

Render pipeline: Universal Render Pipeline (URP). Example materials and shaders require URP. The procedural generation code itself is render-pipeline-independent; the example content can be adapted to HDRP or Built-In RP by replacing the included materials.

Editor-only components: the graph editor window, shape editor window, auto-regenerate postprocessor, and baker are editor-only and do not increase runtime build size

Dependencies: none beyond Unity's built-in packages; no Asset Store dependencies required

What is included:

• PlantSketchGenerator — MonoBehaviour component, the entry point for generation
• PlantSketchAsset — ScriptableObject graph container (nodes + edges)
• Graph editor window (Tools → PlantSketch Editor)
• Shape editor window (Tools → PlantSketch Shape Editor)
• Four geometry strategies: Quad, Revolution, Shape Extrusion, Prefab Variant
• Mesh merging and LOD system
• Prefab baker
• Auto-regenerate on asset save
• Full PDF/Markdown user guide with reference documentation
• Four example plants with assets, materials, and strategy configurations
• Two ready-made fallback prefabs (DefaultCylinder, DefaultCylinderShort)
• Plant surface shader (URP Shader Graph) with procedural stripe pattern, cell noise, and alpha mask support — ready to use on any generated geometry

Discord for Support: discord.gg/s6kECDkThw

Plant Sketch is an editor tool for creating procedural plants and organic 3D structures without writing any code. You design a plant by drawing a small graph — dots connected by arrows — and the tool builds the full 3D geometry in your scene. Move a point, change a slider, and the result updates immediately in the viewport.

The tool is built for artists and designers. Every feature is exposed through Unity's Inspector and two custom editor windows; no scripting knowledge is needed to create complex plants, vines, flowers, cacti, tendrils, or similar objects.

How it works

A plant is described as a directed graph. Nodes are anchor points; edges are branches. The angle and length of each edge in the canvas directly determine the growth direction and reach of the corresponding branch in 3D. A compact graph of four or five nodes is enough to produce a fully detailed plant.

Radial Count on any edge multiplies that branch symmetrically around the parent's growth axis — a single petal definition becomes a ring of five, eight, or twelve petals without drawing each one separately. Edge Shift staggers the origin points of child branches along the parent stem, creating alternating leaves or spiralling arrangements from a single graph entry.

Deformers — gravity, drift, noise, segment noise, twirl, and upright correction — shape each branch as it grows, giving curvature and organic irregularity without manual editing. Every parameter has a Min/Max range so the same graph produces natural variety across a group of plants while a numeric seed keeps results fully reproducible.

Geometry strategies

Four strategy types define the 3D shape of each segment:

• Quad — flat two-sided mesh for leaves, petals, and thin organic shapes. Configurable width profile, roll, fold, and twist per strategy asset, with multiple profiles blended through Variation T.
• Revolution — surface of revolution for berries, seed pods, rounded stem joints, and similar compact shapes. Profile curve defines the outline; close caps can be enabled or disabled.
• Shape Extrusion — extrudes a custom 2D cross-section along the branch path. Multiple consecutive edges sharing a Geometry Group Id merge into a single seamless tube — ideal for smooth, continuous stems with natural bends.
• Prefab Variant — spawns any hand-crafted prefab at each segment. A pool of variants lets one edge distribute a mix of different models, chosen randomly per segment.

Strategy assets are reusable and shareable across plants.

Shape Editor

A dedicated bezier editor inside Unity lets you draw the cross-section profiles used by the Shape Extrusion strategy. Points support Auto, Linear, and Free tangent modes. No external tools needed.

Additional features

• LOD support — strategies produce reduced-resolution meshes at distance, with configurable screen-height thresholds per level.
• Mesh merging — edges can be merged into a single mesh per group, reducing draw calls and eliminating seams between consecutive extruded segments.
• Baking — finished plants bake to static meshes and prefabs with one click. Baked results have zero runtime dependency on Plant Sketch.
• Auto Generate — when enabled, the plant regenerates automatically whenever you modify its asset in the editor, with no manual refresh needed.
• Graph export — the Inspector can print a readable text tree of the graph structure for documentation or debugging.
• Four example plants included to demonstrate a range of techniques.

• Unity Editor extension for scene performance analysis and safe-fix workflows.
• Works on the active scene without requiring runtime integration.
• Deterministic rule-based detectors for common scene optimization issues.
• Issue list with severity, impact, safe-fix filtering, and preview panel.
• Safe Preview Fix, Apply Fix, and Revert Fix flow with Unity Undo support.
• Fix history with per-fix revert and session-wide revert support.
• Scene and hierarchy debugging helpers including object selection, pinging, and optional light overlap overlays.
• Saved tool settings for target profile, filters, and scan thresholds.
• Conservative editor-side fixes for supported issue types.
• No Asset Store package dependencies required.

Supported OS:

• Windows
• macOS
• Linux

Opteurism is a Unity Editor extension focused on practical scene optimization workflows. It scans the active scene for common content-side performance risks, presents findings in a clean review window, and lets users inspect, preview, apply, and revert supported fixes without leaving the editor.

The package is designed as a deterministic first-pass optimization assistant. It detects issues such as unnecessary shadow casting on decorative props, overlapping realtime shadow-casting lights, unnecessary colliders on decorative clutter, missing static flags, duplicate material variants, oversized textures for mobile targets, excessive particle usage, and expensive post-processing setups. The tool favors conservative heuristics and safe editor-side changes over aggressive automation.

For supported issue types, users can preview exact proposed property changes before applying them. Fixes use Unity Undo and can be reverted individually or through the session fix history. The extension also includes filtering, issue selection helpers, rescan comparison flow, and light scene overlays for easier debugging.

Technical Details:

• Number of Meshes: 152
• Collision: Yes - automatically generated
• LOD stages: Yes, 1-4 per model
• Number of Prefabs: 165
• Number of Materials: 133
• Number of Particles: 1
• Number of Textures: 273
• Texture Resolutions: up to 4K
• Texture Formats: TGA and PNG

Modular Port is a game-ready industrial environment, including 150+ unique meshes, animated cranes, terrain with paint layers and water.

Example scene included!

URP Version Only!

Meshes:

152 unique meshes included: cargo ship, cargo containers and boxes, packages, barrels, oil tanks, lifts and many other props.

Prefabs:

Animated crane models included.

Forklift prefab included (comes with separate parts - easy to animate later).

Particles:

Steam particles included. 

Scene:

The example port scene is included in this pack!

Terrain with paint layers and water mesh included. Water shader included. 

Contact:

Email: info@dexsoft-games.com

Join our DISCORD server

Table-Based Data Editor

Browse and edit structured data through a powerful table interface inside the Unity Editor. View large datasets in a compact grid and edit values directly without navigating multiple inspectors.

Advanced Search and Filtering

Quickly locate specific records using powerful filtering and search tools. Sort, filter, and group data to focus on the information that matters.

Bulk Editing Tools

Apply changes across many records at once. Perform bulk edits, copy/paste operations, and batch updates to accelerate large-scale data maintenance.

Computed Columns

Define calculated columns based on expressions to derive additional values from existing data. This is particularly useful for balancing gameplay parameters such as DPS, efficiency, or cost ratios.

Flexible Data Architecture

Game Data Workbench Core separates the editor UI from the underlying data source. While ScriptableObjects are supported out of the box, the system can connect to any custom backend through pluggable data providers.

Possible integrations include:

• ScriptableObjects
• JSON or CSV data pipelines
• remote services or APIs
• custom file formats
• proprietary data systems

Import and Export Workflows

Import and export data using common formats such as CSV or JSON. This allows teams to integrate the tool into existing data pipelines or external balancing workflows.

Schema Creator

Define data schemas visually and generate corresponding C# structures. This allows teams to standardize data models and accelerate the creation of new datasets.

Collection and Complex Data Editing

Edit lists and structured data more efficiently than with the standard Unity Inspector, making it easier to manage nested or complex data structures.

Modular Architecture

Game Data Workbench Core is designed to be extended and customized. Developers can add their own:

• data providers
• custom cell drawers
• adapters and parsers
• additional modules

Optional Extensions (Coming soon)

The architecture allows additional modules to extend the workflow, such as:

• Balance tools for analyzing gameplay parameters
• Sync tools for reviewing data changes from external sources
• Validation tools for enforcing data rules and quality checks

A powerful data editing environment for Unity

Game Data Workbench Core is a professional Unity Editor tool designed to make working with structured game data fast, comfortable, and scalable.

Documentation | Discord

Typical Use Cases

Game Data Workbench Core is ideal for projects that manage large amounts of structured gameplay data, such as:

• Item databases for RPGs

• Enemy stats and balancing tables

• Skill and ability configuration

• Economy and crafting systems

• Localization or configuration tables

• Live-ops balancing and tuning

• Any large ScriptableObject dataset

Instead of editing large datasets through multiple inspectors and scattered assets, Game Data Workbench Core provides a table-based editing environment directly inside Unity. This allows developers and designers to browse, search, filter, and edit large amounts of data with the speed and clarity of a spreadsheet while remaining fully integrated into the Unity workflow.

The tool is particularly useful for projects that rely on data-driven gameplay systems, such as RPGs, strategy games, simulations, or live-ops titles where large datasets must be maintained and balanced continuously.

Game Data Workbench Core supports ScriptableObjects out of the box, but its architecture is not limited to them. Through a flexible data provider system, the editor can work with virtually any data backend. This enables teams to connect the editor to JSON files, CSV pipelines, external services, or proprietary formats while still benefiting from a powerful in-editor editing experience.

With advanced filtering, bulk editing tools, computed columns, and import/export workflows, Game Data Workbench Core dramatically improves productivity when managing complex game data.

Whether you are balancing gameplay parameters, maintaining item databases, editing enemy stats, or managing configuration tables, Game Data Workbench Core provides a fast and reliable environment to handle large datasets efficiently.

The package is also modular and extensible, allowing teams to integrate it into their own pipelines and extend its behavior with custom providers, drawers, and modules.

Game Data Workbench Core helps teams move from tedious inspector editing to a structured, scalable, and designer-friendly data workflow inside Unity.

• Converts lists of Vector3 points into simplified directional line patterns
• Pattern recognition system with configurable tolerance for angle and length
• Includes optional fuzzy logic, allowing for increased generosity in recognition
• Designed to interpret likely intended shapes rather than exact input paths
• Pattern presets stored as ScriptableObjects for easy editor configuration
• Supports runtime pattern generation and matching
• Works with any input system that produces positional point data (mouse, touch, controllers, etc.)
• Supports both 2D and 3D input (3D patterns included as experimental)
• Example scene included for drawing and testing patterns
• Playable showcase game demonstrating the system as a core mechanic
• Confirmed compatible with Unity 2022 LTS and newer

Directional Pattern Recognition converts a sequence of Vector3 points into a simplified pattern made of directional line segments. These patterns can then be matched against predefined patterns, allowing you to trigger gameplay events when a player draws the intended symbol.

The system is designed to interpret the likely intent of a drawing, tolerating variation in angle, length, and minor directional inconsistencies.

This makes it suitable for gesture systems where players draw shapes using a mouse, touchscreen, controller, or any input that produces point data.

This package includes an example game showcasing the tool. If you wish to test the tool yourself before getting this package, the game has been made publicly available here: https://connor-hasson.itch.io/runic-defence

• UI framework: Unity UI Toolkit (UIElements) — no UXML or USS files required, all layout is code-driven
• Theme-aware: all colours reference EkiooWindowStyle constants that are calibrated for both Editor light and dark themes; no manual theme detection needed
• EkiooWindowStyle: single source of truth for colours (Bg, Accent, ActiveColor, DoneColor, RemoveColor, TextTitle, TextMuted, BorderColor, …), font sizes (FontSizeXS → FontSizeHeading), spacing (SpaceXS → SpaceXXL), and border radii (RadiusSm, RadiusMd, RadiusBadge, RadiusPill)
• EkiooInspectorBuilder: SectionLabel, Separator, ReadOnlyRow, MetaRow, ActionButton, RuntimeContainer — all returning VisualElement and composable without subclassing
• EkiooWindowBuilder: BuildSection, Badge, BuildTogglePill, FlexRow, ItemRow, Divider, ToolbarContainer, StatusBar, AccentDot — all returning VisualElement
• EkiooSparklineElement: custom VisualElement drawn with Painter2D; call SetSamples(float[], Color) to update — supports grid lines, fill gradient, zero line, and terminal dot
• DependencyChecker: static Require(packageId, displayName, url, sentinelTypeName) called from an [InitializeOnLoad] class; shows a one-time informational dialog per Unity session if a dependency is missing
• AssetDatabaseHelper: GetAssets<T>() — finds all ScriptableObject assets of a given type across the entire project without writing GUID queries by hand
• Assembly: Ekioo.Editor.asmdef, autoReferenced: true, includePlatforms: ["Editor"] — zero runtime overhead, does not appear in builds
• Unity: 6000.0 (Unity 6) or later
• Render pipeline: compatible with Built-in, URP, and HDRP (Editor-only, no rendering dependency)
• Sample: "Style Showcase" — importable from Package Manager; includes an EditorWindow, a CustomEditor, a demo MonoBehaviour, and a demonstration scene

Ekioo Editor Core is the shared foundation used by all Ekioo packages to build consistent, polished editor interfaces in Unity. It provides a centralised style system, a library of ready-to-use UI Toolkit components for both EditorWindow and CustomEditor, and a sparkline renderer — all designed to be dropped into any in-house or third-party Unity toolset.

The package ships a Style Showcase sample that demonstrates every visual primitive interactively, inside a live EditorWindow and a CustomEditor, with real-time Play Mode polling.

Who is this for? Any Unity developer or team building their own editor tools, custom inspectors, or Asset Store packages who wants a solid, theme-aware visual foundation without reinventing the wheel. The package has no runtime footprint — it is 100% Editor-only and adds zero overhead to builds.

What is included?

• A complete colour/typography/spacing palette that automatically adapts to Unity's light and dark themes
• Pre-built CustomEditor components: section headers, read-only rows, metadata rows, action buttons, and a Runtime foldout that disables itself outside Play Mode
• Pre-built EditorWindow components: titled sections, badges, toggle pills, item rows, toolbar, status bar
• A custom VisualElement that renders a data sparkline with grid lines, fill area, and a terminal dot
• A dependency-check mechanism for packages that need to declare optional or required dependencies
• A fully documented, interactive sample importable directly from the Package Manager

Requirements

• Extenject Dependency Injection IOC
• DOTween (HOTween v2)

Supported platforms

Multiplayer Card Game Core was designed for creating PC games. All of the systems will work on mobile, though UI would need adjustements.

Third-Party Notices

Asset uses the Ebbe font under a SIL OFL 1.1 license and Sclate font under a free license; see Third-Party Notices.txt file in package for details.

Create, customize, and launch your own Trading Card Game (TCG) or Collectible Card Game (CCG) in Unity - now with 1v1 Multiplayer built-in.

Card Game Core + Multiplayer Module gives you the complete single-player foundation of the original template, expanded with synchronized head-to-head duels for competitive turn-based gameplay.

Easily add your own cards, spells, heroes, effects, and abilities through a structured workflow, then validate balance in both AI matches and player-vs-player duels without rebuilding your core systems.

Powered by Unity Netcode for GameObjects (NGO) - Unity’s official networking solution for a Unity-native multiplayer foundation and smooth integration into modern Unity projects.

HELPFUL LINKS:

📄 DOCUMENTATION | 🌐 WEBSITE | 💬 DISCORD | 🎥 YOUTUBE

🛠 FEATURES OF CARD GAME CORE MULTIPLAYER INCLUDE:

⚔️ 1v1 Multiplayer Duels

Play head-to-head matches using a synchronized turn-based duel flow.

🎴 Synchronized Mulligan

Both players confirm opening hand changes before turn one begins - stable pacing and fair starts.

🔁 Turn Sync & Authority Rules

Clear “Your Turn / Opponent Turn” control, with consistent turn progression on both clients.

✅ Validated Actions

Actions are checked before being applied, keeping matches stable, predictable, and competitive.

🏁 Results & Rematch Flow

Finish matches cleanly, review outcomes, and start the next duel fast.

🎯 Where This Asset Fits Best

Card Game Core + Multiplayer Module is designed for projects where deck building, card collection, turn-based combat flow, and ongoing balance tuning are central - now extended with competitive 1v1 PvP.

Competitive CCG / 1v1 PvP Foundations

Deck builder, collection progression, and polished duel flow suitable for head-to-head play - in the spirit of Hearthstone, Legends of Runeterra, or Shadowverse.

Hero-Based Card Combat Systems

Support for heroes, spells, units, and clear combat feedback in a clean turn-based structure - similar in feel to Gwent or KARDS.

Prototype-to-Production TCG Projects

Ship a playable vertical slice faster with complete core systems plus multiplayer duel support - ideal when you want to validate rulesets, pacing, and balance early.

🔗 Plays Well With These Asset Categories

This asset stack integrates smoothly with the systems commonly used alongside TCG/CCG projects:

Backend, Player Profiles & Cloud Save

Account-based collections, cross-device persistence, secure inventory storage.

Card Pack, Gacha & Loot Systems

Booster packs, rarity pools, pity rules, pack-opening UX.

LiveOps, Events & Remote Config

Balance updates, rotating formats, limited-time events, weekly rule changes.

Quests, Daily Tasks & Battle Pass Systems

Retention loops rewarding matches, wins, and collection milestones.

Ranked Play, Leaderboards & Tournaments

Ladders, seasonal progression, brackets, competitive ranking layers.

Economy, Shops & IAP Frameworks

Currency sinks, bundles, cosmetics, starter packs, store flows.

Analytics & A/B Testing Tools

Track deck meta, win rates, funnels, churn signals for faster iteration.

Content Pipelines (CSV / Sheets-Based Tools)

Scalable card authoring and balancing via spreadsheets and localization tables.

Card Game Core is designed to fit into modern TCG/CCG production pipelines and works smoothly alongside commonly used Unity tools for multiplayer, data management, and scalable workflows.

Possible Integrations:

• Odin Inspector & Serializer
• Easy Save – The Complete Save System
• PlayFab Unity SDK
• Behavior Designer Pro - DOTS Powered Behavior Trees
• Toolkit for Steamworks 2026
• Hot Reload
• vHierarchy 2
• Scriptable Sheets
• Sensor Toolkit 2
• DOTween (HOTween v2)
• I2 Localization
• Master Audio 2024
• Amplify Shader Editor
• Super Text Mesh
• Rewired
• Curvy Splines
• Behavior Designer

Core Component:

• NPC Controller Script – central “brain” managing NPC behavior, movement, interactions, and animations.

Movement & Navigation:

• Integrated with Unity NavMesh for pathfinding
• Smooth animation blending via Animator.CrossFade
• Target-based movement logic for dynamic navigation

Interactions:

• NPC-to-NPC conversations (visual / timed interactions)
• Object-based interactions (pick up, use, activate)
• Interruptible actions with state-safe fallback

Zone Awareness:

• Limit NPC Movable Space.

Animation & Visuals:

• Assign animations to world objects
• NPCs can visually interact or appear to talk to each other
• Supports environment storytelling via actors and animated objects

Customization & Extensibility:

• Adjustable parameters for movement speed, interaction timing, zone behavior
• Modular namespace and clean architecture for easy integration into projects
• Lightweight and optimized for performance

Setup:

1. Add NPC Controller to your NPC prefab
2. Assign Animator and optional NavMeshAgent
3. Configure zones, interactions, and targets

Ideal For:

• RPGs, adventure games, simulations, fantasy worlds, open-world games
• Developers who want quick setup with modular, extensible NPC behavior

Bring your world to life with a powerful and flexible NPC behavior system designed to create believable, dynamic characters with minimal setup.

This asset allows you to create NPCs that move naturally, interact with the environment, talk to each other, and respond to different zones in your world — making your game feel alive instead of static.

• Deterministic snapshot storage for repeatable comparisons
• Baseline vs current diff with increases, decreases, new, and removed entries
• Budget thresholds for total variants, delta variants, percent delta, and per-shader caps
• Ignore rules and allow rules for cleaner signal
• Latest-passing baseline workflow for CI promotion
• Incomplete snapshot detection with fail-fast CI gating
• Batchmode runner with stable exit codes for automation

📜 Docs

Shader Variant Budget & CI Guard helps Unity teams find, understand, and stop shader variant regressions before those regressions turn into bigger build problems. Instead of guessing why variant counts suddenly went up, you can capture snapshots, compare builds, and see exactly what changed. The tool is made for developers who want a clear workflow, not a vague warning after the damage is already done.

The core job of this tool is simple: it tracks shader variant counts over time and tells you when they move in the wrong direction. After a build, it reads the variant data from Editor.log, saves a deterministic snapshot, and lets you compare a baseline build against a current build. You can quickly see total variant changes, per-shader changes, new entries, removed entries, and where the biggest increases came from.

This matters because shader variant growth is easy to miss. A project can look fine for weeks, then slowly collect extra variants through shader changes, keyword changes, package updates, or content changes across teams. By the time someone notices, the project may already have slower build iteration, harder debugging, and a less predictable pipeline. This tool gives you a practical guardrail so shader variants stay visible and controlled.

Inside the Unity Editor, the workflow is built to be direct and easy to use. You open the Shader Variant Guard window, capture or load snapshots, choose a baseline and current result, and run a comparison. The results are shown with summary cards, filtered diff views, search tools, sorting, and diagnostics. That means you do not need to dig through raw logs by hand just to answer basic questions like “what changed?” or “which shader caused this jump?”

The budget system is where this becomes a real production tool, not just a viewer. You can define hard limits and warning limits for total variants, delta variants, percent delta, and per-shader counts. When the current snapshot breaks those rules, the tool reports the problem clearly. You can also add ignore rules and allow rules so the results stay focused on the shader changes that actually matter to your team.

For teams working in CI, this tool is built to gate builds automatically. It includes a batchmode runner with stable exit codes, external JSON budget support, report export options, and a latest-passing baseline workflow. In practice, that means you can run it in automated validation and fail a build when shader variant counts cross the limits you defined. Instead of noticing regressions later, your pipeline can stop them at the point where they are introduced.

Baseline management is handled with real production needs in mind. The tool can compare against the latest snapshot, the latest passing snapshot, or a specific snapshot path. It also supports profile-aware baseline matching, latest-passing index overrides, and optional baseline promotion in CI. This makes it useful for teams that need a repeatable baseline workflow across multiple branches, build targets, or build profiles.

The tool also protects you from low-quality data. If a snapshot is incomplete, the guard can detect that and fail the check instead of silently giving you bad results. This is important because a broken or partial snapshot can hide a real regression. The incomplete-snapshot gating makes the tool more reliable when used in automated environments where confidence in the data matters.

The editor experience is practical, not bloated. Settings are available in Project Settings, with normal and advanced sections, browse buttons for paths, clear controls for storage and retention, and guidance for unusual values. The main window supports snapshot-first comparisons, filtering, search, diff tabs, and diagnostics export. There is also a one-click Generate Example Test Workflow action so you can seed realistic sample data and understand the tool fast.

This asset is a strong fit if your project has grown past the point where manual checking is enough. If you are shipping on multiple targets, working with a team, reviewing build health in CI, or trying to stop shader complexity from creeping up over time, this tool gives you structure and visibility. It is especially useful when you want to turn shader variant control into a repeatable process instead of relying on memory, guesswork, or occasional cleanup passes.

What you are really buying is control. You get a way to measure shader variant changes, compare builds with confidence, define budgets that match your project, and enforce those budgets both in the Editor and in CI. If shader variants have ever felt like a hidden problem in your pipeline, Shader Variant Budget & CI Guard turns them into something visible, trackable, and manageable.

• One-click generation of clean 2D icons from 3D models

• Automatically exports PNG icons with transparent backgrounds

• Automatically imports icons as Sprite (2D and UI)

• Preview camera shows the final icon in Game View before export

• Export directly into the Unity project or to an external location

• Automatic folder creation for icon exports

• Ideal for RPG inventory icons, item icons, and UI thumbnails

IconStudio is a lightweight Unity editor tool that converts 3D models into clean, UI-ready 2D icons with a single click.

Simply place your model under the ItemSpawn object, position it at (0,0,0), adjust rotation as desired, and export. IconStudio automatically renders the object to a transparent PNG and configures the texture import settings for immediate use in Unity UI.

Designed for developers who want their UI icons to perfectly match their 3D models, IconStudio makes it easy to generate consistent, professional-looking icons without needing design experience or spending hours creating custom artwork. It works out of the box in clean Unity projects and supports Built-in, URP, and HDRP pipelines.

Perfect for inventory systems, RPGs, strategy games, mobile UI, or any project requiring fast icon generation.

Stop wiring everything together.

Evently introduces a clean and deterministic event-driven communication layer for Unity. Instead of tightly coupling systems with direct references, singletons, or manager chains, Evently allows components to communicate through a scalable publish/subscribe event architecture. This keeps your codebase modular, maintainable, and significantly easier to extend as your project grows.

No string-based events. 

No hidden dependencies. 

No fragile object graphs.

Evently provides a type-safe event system for Unity that enables systems to react to events without knowing about each other.

Core Capabilities

• Global Event Bus – project-wide messaging system for communication between gameplay systems
• Scoped Event Buses – isolated buses for modular features, UI panels, mini-games, tools, or temporary systems
• Disposable Subscriptions – explicit lifetime control for every event listener
• Auto-Bound MonoBehaviour Listeners – automatic cleanup when Unity objects are destroyed
• Lightweight Debug Window – inspect active events and listener counts directly in the Unity Editor

Event Dispatching, Done Right

• Type-Safe Events – strongly-typed contracts (structs or classes), zero magic strings
• Fluent Listener API – chainable configuratio for expressive and maintainable subscriptions
• Duplicate Subscription Protection – prevent accidental multiple registrations
• Exception-Safe Dispatching – one failing listener won’t break the entire event chain
• Minimal Allocations – optimized for performance-sensitive and mobile projects

Documentation