What is Universal AI?

Universal AI allows game developers to create AAA-quality AI characters in a few minutes. The system allows users to extend the system, understand the code; add features, disable features, and much more.

Customizable - Easy to add custom actions, behaviors & animations with examples.

Animation Wizard - Easily set up animations for your AI, with our custom animator creator wizard.

Setup Manager - With a few clicks, create your AI with our advanced AI setup wizard.

Integration Steps

Open the script health.cs from Game Kit Controller and add this code:

using UniversalAI; and , universalDamageable.

Rename the file GKCUniversalAIDamageDetectionInterface.txt as .cs and attach it to the Universal AI objects:

And that is all needed, the damage detection will be applied between both characters, GKC player and Universal AI objects.

What is SoulLink Spawner?

With SoulLink Spawner, you can avoid the tedious and time-consuming task of manually placing populations of animals, enemies, and other objects in your game world.

Instead, let SoulLink Spawner manage your populations based on biomes, areas, regions, time of day, weather, seasons, quests, and other conditions.

You decide how many AI will be in your world at one time and SoulLink Spawner will spawn and despawn them as necessary as your player moves throughout the game world.

You control the spawning/despawning ranges as well as various restrictions such as elevation and slope angle. You can even restrict your spawns based on layers.

Tutorial

Integration with Soullink Spawner is very easy and only requires one step!

Tools > Soullink Spawner > Integration > Enable Game Kit Controller.

For further information on this integration, see the SoulLink Spawner.

What is Emerald AI?

Emerald AI allows developers to quickly create engaging dynamic AI with 100's of AAA quality features, all without having to write a single line of code! Emerald's editor is designed to make creating AI easy, yet incredibly customizable. Emerald caters to all kinds of developers and offers everything users would expect from an all-in-one AI system.

Inspector Settings

Black Horizon Studios (The maker of Emerald AI) has a tutorial video showing the inspector changes needed to integration Emerald AI and Game Kit Controller.

If you'd rather just get a step by step instructions for the inspector changes you can view these in the tab below labelled "Step by Step Instructions".

Script Changes

Part #1

First you'll need to open the EmeraldAIPlayerDamage.cs script found in the Emerald AI directory Assets/Emerald AI/Scripts/Components/ in your favourite editor and add the following code after the DamagePlayerStandard() method:

/// <summary>
/// Applies damage to a Game Kit Controller controlled player.
/// </summary>
/// <param name="DamageAmount">The amount of damage to deal to the GKC player.</param>
void DamageGameKitController(int DamageAmount, GameObject attacker)
{
    applyDamage.checkToDamageGKCCharacterExternally (DamageAmount,
    gameObject, attacker);
}

Then in the same file, add the following inside the SendPlayerDamage method:

// Send damage to GKC player
GameObject targetObject = null;

if (Target != null){
    targetObject = Target.gameObject;
}

DamageGameKitController(DamageAmount, targetObject);

You can now save the EmeraldAIPlayerDamage.cs script and move onto the next step below.

Part #2

The next part can be done in two ways, the first is the recommended way to add the integration. The second option isn't recommended but can be used if you don't want to use inheritance.

public class EmeraldAISystem : healthManagement

/// <summary>
/// Game Kit Controller Integration
///
/// Applies damage to the player via the GKC healthManagement class.
/// </summary>
public override void setDamageWithHealthManagement(float damageAmount,
    Vector3 fromDirection, Vector3 damagePos, GameObject attacker, GameObject projectile,
    bool damageConstant,
    bool searchClosestWeakSpot, bool ignoreShield, bool
    ignoreDamageInScreen, bool damageCanBeBlocked, bool
    canActivateReactionSystemTemporally, int damageReactionID, int damageTypeID)
{
Damage((int)damageAmount, EmeraldAISystem.TargetType.Player);
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using EmeraldAI; // Emerald AI Integration

public class applyDamage : MonoBehaviour
{

What is Animal Controller?

Animal Controller(AC) is an animation framework controller, root-motion or In Place, for any creature or HUMANOID character.

AC is the base controller for all my Assets, but you can use it on any other asset in the Store.

It was built from the ground up with over 3 years of experience to make all my assets shine even more with a smooth and modular controller.

AC is based on States and Modes. States like Locomotion, Idle, Jump, Fall, Fly, Swim.. and Modes Like Main Attacks, Secondary Attacks, Hits, Actions, etc.

States are the Animations that contain certain Logic and they cannot overlap each other (Ex: You cannot swim and fly at the same time)

Modes are the Animations that be used while a state Animation is playing (Ex: Attack while flying or Running).

Video Tutorial

Written Tutorial

Open the first demo scene (in this example it's Unka the Dragon) and drop the GKC Player in the scene along with the Rider System Object. You can drop this object inside the Malbers animal, and reset its transform value.

Modify Malbers Input

Next, we need to modify the Malbers Input component with some custom code.

Copy the code below to have a function that allows you to Pause/Resume the input of the Animal Controller.

if (inputPaused)
 {
 horizontal = 0;
 vertical = 0;
 upDown = 0;

 RawInputAxis = Vector3.zero;

 return;
}

This first part is pasted inside the SetInput function at the very top of the script, it starts at line 70.

The second code part, below, is pasted directly at the end of the SetInput function.

public bool inputPaused = true;

public void setInputPausedState(bool state)
{
 inputPaused = state;
}

Configure GKC Rider System

On the GKC rider system, configure the option to use events on start, calling to that function, so the input of the animal is paused from start.

Create an empty game object inside the CM Brain of the animal and name it Main Camera Position. Disable the Camera and Audio Listener components of that camera. In the Rider Seat System prefab, under the Move Camera to Devices component, drag and drop the Main Camera Position game object you created in the CM Brain to the Camera Position slot.

Configure Electron Device Component

On the Electronic Device component, we'll configure the Pause/Resume events for the animal. Scroll down to the section, Start/Stop Using Device Settings, and assign your Malbers animal and Look At as in the photo below. Setting setInputPausedState and LookAt in their respective states is needed.

On Event on Start Using Device () MalbersInput.setInputPausedState should be unchecked. That means the animal is not paused on Start. LookAt.enabled is checked as that lets the Animal Controller look at targets as usual.

In Use Event on Stop Using Device, the opposites are selected so that the Animal is Paused on stop and LookAt is disabled. Additionally assign the Animal twice, selected MalbersInput.enabled. Checking one, and unchecking the other.

After that you can customize the interaction panel text transform along the Ride positions and IK elements (check the tutorial for Edy's Vehicle System tutorial for more info) in the Rider Seat System prefab.

That's it! You're ready to ride!

What is Randomation Vehicle Physics?

Randomation Vehicle Physics is a vehicle physics system for the Unity engine, originally developed with Unity 5.6. The most recent Unity version it has been tested with is 2019.2.9. It aims to achieve semi-realistic, general-purpose driving mechanics. This was originally sold on the asset store as Randomation Vehicle Physics 2.0.

Written Tutorial

*Coming Soon*

What is Space Combat Kit?

Looking for a complete solution for getting your space game off the ground? The Space Combat Kit gives you a massive head start, taking care of the complex and difficult coding so that you can focus on creating what makes your game fun and unique.

Packed with features – build the foundation of your game in a fraction of the time it would otherwise take, giving you the opportunity to quickly test new creative ideas and make rapid progress toward release.

Easy to customize – enjoy a modular, event-driven design that gives you powerful customization from the inspector. Completely change the look and feel of your game without writing code - and if you need to dive in, all the code is neatly designed and documented.

Video Tutorial

Written Tutorial

*Coming Soon*

What is Edy's Vehicle System?

EVP brings fun and realistic vehicles to your games! Designed for gameplay, ease of use, and realistic behavior.

Video Tutorial

Written Tutorial

*Coming Soon*

What is Mech Combat Kit?

The Mech Combat Kit is designed to help you create anything from a simple arcade game to a complex mech sim! Packed with features built from the ground up to allow you to easily customize your game from within the editor.

The Mech Combat Kit comes with all the features you need to build an exciting, action-packed mech combat game:

- Rigidbody-based Mech Controller with third-person and cockpit perspectives. Smooth, fun, and easily handles bumps and ramps. Includes jetpack capability!

- Loadout System to create mechs with loadouts, save them to slots and spawn during gameplay.

Video Tutorial

Written Tutorial

*Coming Soon*

What is NWH Vehicle Physics 2?

NWH Vehicle Physics 2 is a complete vehicle simulation package for Unity. Realistic, easy to use, and heavily customizable.

• Easy and fast to set up with all the defaults loaded automatically and a validation system that warns the developer about any setup issues.

• Vehicle setup wizard that creates a functional vehicle from scratch in a few clicks. Multiple presets are available.

• Modular vehicle architecture. Enable or disable parts of the vehicle as they are needed, either manually or through the built-in LOD system.

• Powertrain solver that features excellent performance, stability, and physical accuracy.

• Custom physics sub-stepping solution.

• All aspects of the vehicle are adjustable at runtime - including powertrain, suspension, friction, effects, etc.

Video Tutorial

Written Tutorial

Open the scene Racetrack in NWH or drop the vehicle prefab you want, drop the GKC player and the rider system object prefab directly inside the vehicle.

If the default controller of NWH is on the scene, disable it. Disable all the camera objects from the vehicle, including their audio listener and the camera component of the first camera.

Drag the External Rider Controller System into the scene from the GKC folder and reset it's position. Enable the option on the GKC Rider System to Use Event On Start Game and configure the sleep function of the vehicle controller component by dragging the root prefab into the Event Field. Select VehicleController < Sleep().

Configure the events to wake and sleep on the electronic device components by dragging the vehicle prefab to Event on Start Using Device and selecting VehicleController < Awake. and Use Event on Stop Using Device and selecting VehicleController < Sleep.

Assign the DemoUICanvas (only for the Demo Scene) and set it to GameObject < Set Active and enable it.

Create a new GameObject inside the Vehicle Camera in the Cameras gameobject of the vehicle and name it Camera Position. Select the External Rider Controller System, the Move Camera to Device component and in Camera Position, assign the Camera Position gameobject you just created.

Change the Device Name and Device Action on the Device String Action component to what you want. And all is configured to work properly, now it is a matter of adjusting the IK positions and the seat and passenger elements.

Also, move the Steering gameobject from inside the External Rider Controller System object to the vehicle mesh. Make sure to unpack the prefab on the rider object. On the vehicle controller, you can adjust the steering wheel max rotation angle so it looks proper with the driver's hands on it through IK.

What is UMA 2 - Unity Multipurpose Avatar?

The Unity Multipurpose Avatar (aka UMA) system lets you create customizable characters. Whether you need a hero, a villain, or an entire village of NPCs this package is for you!

UMA includes all of the code necessary to build a huge variety of unique characters at runtime from simple recipes. By merging the meshes, textures and bones of a character and its equipment UMA builds efficient customizable characters with a minimum number of draw calls.

The included Human meshes can be used as is with some of the stunning clothing assets available on the Asset Store or you can create brand new creatures specific to your game and use UMA to customize those as well.

Import UMA 2 from the store.

Assign that object here:

Drop the main player prefab “Player and Game Management” into the scene and use the manual character creator, selecting the UMA character as the new model and replace the model of that player with this UMA character.

Go here and press this button:

You can see the field Number Of Childs will change its value from 0 to a certain number.

Replace the scripts on UMA with the two provided on this zip (CapsuleColliderSlotScript and UMASkeleton) directly the window explorer and not in unity.

UMASkeleton is located here:

And CapsuleColliderSlotScript here:

Move the scripts UMAIgnoreTransformAndChilds and UMAIgnoreTransformAndChildsEditor from GKC folder to this folder:

Hit play and try it.

What is Dynamic Water Physics?

Dynamic Water Physics 2 is a water physics simulation tool that uses mesh data to simulate buoyancy and hydrodynamics - above and under the water. Suitable for any mesh shape and size.

DWP2 is a complete rewrite from the previous version to make use of new Unity features and get even better performance.

• Fast and easy to set up - either manually or through the one-click wizard.

• Simulate any object of any shape or size, as long as it has a mesh.

• Extremely well optimized. ~0.02ms CPU time on average per object in the demo scene, ~1.2ms total for 70 objects. (Wavy water performance depends on 3rd party asset used)

• Multiplayer support (Mirror and PUN2).

• WaterObjects are Rigidbodies and interact with water only through the use of forces. No translation or rotation applied.

Video Tutorial

Written Tutorial

*Coming Soon*

What is Honor AI?

Honor AI is an utility-based solution for easy creation of various AI agents like monsters, animals, followers, villagers, hunters etc, with just a few clicks!

No matter how experienced you are, you will find Honor AI helpful: less experienced developers will appreciate quick and easy AI setup with just a few clicks, while more advanced users can enjoy well written modular codebase, flexibility and extensibility of the whole system.

What makes Honor AI special is that AI logic isn't hardcoded, but rather designed in AI graphs that can be freely modified to your needs.

Thanks to such a solution Honor AI is the only AI solution on the Asset Store that solves the age-old problem of having to choose between a ready-made product that is inflexible or a low-level framework that doesn't provide game-ready features, as it provides benefits of both, without any compromises!

Honor AI provides you with all of AI essential systems: movement, spatial awareness, perception, combat, relationship, animations, audio, productivity tools and so much more!

Integration Steps

These integration steps are also provided in the Honor AI documentation.

Step #1

Extract the GameKitController.zip archive file located in the Integrations directory of the Honor AI asset into the Game Kit Controller project directory.

Step #2

To enable interactions between both assets you'll need to do the following:

1. For your Honor AI characters add the GKCIntegration component. This will also automatically add the necessary CharacterFactionManager component. This should be configured accordingly as per the GKC documentation - Faction System field has to be assigned.

2. For your GKC AI characters add the HonorAIIntegration component and assign all fields.

What is DestroyIt?

DestroyIt is a highly optimized destruction system that provides multiple options for handling the damage, repair, and destruction of objects in your games.

Objects can show visible progressive damage (which can even be repaired) using the Standard/URP shaders and customizable damage textures. You can also play damage effects at any damage level, for instance, an engine that starts smoking at half health and catches on fire at one-quarter health.

Destruction can be simple or realistic, from playing a particle effect to replacing the object with a pre-fractured prefab (that you supply). You can even combine the two for a more extravagant effect.

Video Tutorial

What is Interactor?

Interactor is designed to cover all aspects of any kind of interaction, from the designing stage in the editor to handling complex interactions in runtime.

It contains editor tools to simplify the process of preparing a fully interactable environment (Look at the Easy Workflow section below).

And in runtime, it handles which player parts are going to interact with which parts of the interacted object, while using its own IK to animate player bones.

Video Tutorial

Written Tutorial

*Coming Soon*

What is Dialogue System for Unity?

The powerful, top-rated dialogue system used in Disco Elysium, Lake, Suzerain, Peglin, Jenny LeClue, and many many more, the Dialogue System for Unity makes it easy to add interactive dialogue and quests to your game.

It's a complete, robust solution including a visual node-based editor, dialogue UIs, cutscenes, quest logs, save/load, and more.

The core is a lean, efficient conversation system. A large collection of included, optional add-ons make it quick and easy to drop conversations into your project and integrate them with other assets.

No scripting required. Complete C# source included.

Video Tutorial

Written Tutorial

Open the first demo scene from Dialogue System asset content. Search the GKC player prefab called "Player and Game Management" and drop it on the scene, adjust its position and rotation as you need.

Disable the previous player and copy the components Selector, and paste it as new on the Player Controller gameObject from GKC, on the message that appears, press Add.

And finally, copy and paste the Dialogue System Events on the Player Controller.

Search the words "Pause Resume" on the project searcher tool and drop that prefab on the scene, disable its collider trigger.

On the Dialogues System Events, remove the previous calls on the events of Conversation Events and configure the calls to pause and resume the player, with parameters true to pause and false to resume with the function PauseOrPlayPlayerComponents.

Finally, go to the Selector component, and set a new key for the interaction, like for example E as it is the default key used on interaction in GKC.

And with that, the system is ready to work, pausing the player when the dialogue is in process and resuming it once the dialogue is over, along with the rest of the interactions with the environment.

What is iStep?

iStep is a premium foot placement solution for Unity that will help bring your characters to life and provide that triple-A feel everyone is looking for.

Written Tutorial

Integrating iStep with Game Kit Controller is fairly simple!

1. Import iStep into your project.

2. Disable the Foot IK Component in Other Systems.

3. Navigate to and click on the Player Controller game object.

4. Add the iStep Foot IK script.

What is Silantro Flight Simulator Toolkit?

Silantro Flight System is a toolkit that allows you to set up, model, and simulate any Fixed-wing aircraft.

Silantro Flight System provides AAA flight simulation physics with superb aerodynamics, very realistic engines, and aircraft components, which can be easily set up and controlled.

It can be used to simulate any aircraft type, from subsonic or supersonic jets to propeller-powered aeroplanes or unpowered/powered gliders.

Video Tutorial

Written Tutorial

*Coming Soon*

What is Easy Build System?

Easy Build System is an advanced building system, easy to use and expandable. Fast and powerful to suit all of your building needs in all your games, works on any platforms!

Designed to work out-of-the-box, it includes several components like scalable conditions and add-ons, sockets, physics, blueprints, skins, save and load... etc

Support three view modes first, third and top-down view, works with the new Unity Input System and XR. Extend it or to customize it to fit your exact needs, even if you aren't a programmer.

Integration Steps

Follow these quick easy steps to integrate Easy Build System and Game Kit Controller.

Step #1

Open the scene called "[Desktop] First Person - Modular Building Demo" or any first person demo scenes in the EBS demos directory here: Assets/Easy Build System/Demos & Add-Ons/Demos and drop the GKC player prefab into the scene.

Step #2

Next locate the Easy Build System - Demo First Person Controller EBA player controller GameObject in your project hierarchy and disable it.

Step #3

Select the Main Camera child GameObject of the Easy Build System - Demo First Person Controller GameObject. Then locate the Builder Behaviour component and copy it.

Step #4

Next up you want to locate the GKC Main Camera GameObject in your project hierarchy (Player And Game Management > Player Camera > Pivot Camera Transform > Main Camera Transform > Main Camera) and select the hamburger menu of an existing component, then press "Paste Component As New" to paste the Builder Behaviour component onto the GKC Main Camera.

Step #5

Still on the GKC Main Camera GameObject, got to the bottom of the inspector and press "Add Component" then we're going to create a new script, so enter GKCInputBehaviour and then select "Create and Add".

Open the newly created GKCInputBehaviour.cs script in your preferred editor, delete any existing content in the script so that it's empty, and paste in the code below.

using EasyBuildSystem.Features.Scripts.Core.Base.Builder;
using EasyBuildSystem.Features.Scripts.Core.Base.Builder.Enums;
using EasyBuildSystem.Features.Scripts.Core.Base.Manager;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;

public class GKCInputBehaviour : MonoBehaviour
{
    #region Fields

    public bool UseShortcuts = true;

    public KeyCode BuilderPlacementModeKey = KeyCode.E;
    public KeyCode BuilderDestructionModeKey = KeyCode.R;
    public KeyCode BuilderEditionModeKey = KeyCode.T;

    public KeyCode BuilderValidateModeKey = KeyCode.Mouse0;
    public KeyCode BuilderCancelModeKey = KeyCode.Mouse1;

    public int SelectedIndex { get; set; }

    public bool buildModeEnabled = true;

    #endregion

    #region Methods

    private void Update ()
    {
        if (!buildModeEnabled) {
            return;
        }

        if (UseShortcuts) {
            if (Input.GetKeyDown (BuilderPlacementModeKey))
                BuilderBehaviour.Instance.ChangeMode (BuildMode.Placement);

            if (Input.GetKeyDown (BuilderDestructionModeKey))
                BuilderBehaviour.Instance.ChangeMode (BuildMode.Destruction);

            if (Input.GetKeyDown (BuilderEditionModeKey))
                BuilderBehaviour.Instance.ChangeMode (BuildMode.Edition);

            if (BuilderBehaviour.Instance.CurrentMode != BuildMode.Placement)
                UpdatePrefabSelection ();

            if (Input.GetKeyDown (BuilderCancelModeKey))
                BuilderBehaviour.Instance.ChangeMode (BuildMode.None);
        }

        if (BuilderBehaviour.Instance.CurrentMode == BuildMode.Placement) {
            if (IsPointerOverUIElement ())
                return;

            if (Input.GetKeyDown (BuilderValidateModeKey))
                BuilderBehaviour.Instance.PlacePrefab ();

            float WheelAxis = Input.GetAxis ("Mouse ScrollWheel");

            if (WheelAxis > 0)
                BuilderBehaviour.Instance.RotatePreview (BuilderBehaviour.Instance.SelectedPrefab.RotationAxis);
            else if (WheelAxis < 0)
                BuilderBehaviour.Instance.RotatePreview (-BuilderBehaviour.Instance.SelectedPrefab.RotationAxis);

            if (Input.GetKeyDown (BuilderCancelModeKey))
                BuilderBehaviour.Instance.ChangeMode (BuildMode.None);
        } else if (BuilderBehaviour.Instance.CurrentMode == BuildMode.Edition) {
            if (IsPointerOverUIElement ())
                return;

            if (Input.GetKeyDown (BuilderValidateModeKey))
                BuilderBehaviour.Instance.EditPrefab ();

            if (Input.GetKeyDown (BuilderCancelModeKey))
                BuilderBehaviour.Instance.ChangeMode (BuildMode.None);
        } else if (BuilderBehaviour.Instance.CurrentMode == BuildMode.Destruction) {
            if (IsPointerOverUIElement ())
                return;

            if (Input.GetKeyDown (BuilderValidateModeKey)) {
                if (BuilderBehaviour.Instance.CurrentRemovePreview != null) {
                    BuilderBehaviour.Instance.DestroyPrefab ();
                }
            }

            if (Input.GetKeyDown (BuilderCancelModeKey))
                BuilderBehaviour.Instance.ChangeMode (BuildMode.None);
        }
    }

    private void UpdatePrefabSelection ()
    {
        float WheelAxis = Input.GetAxis ("Mouse ScrollWheel");

        if (WheelAxis > 0) {
            if (SelectedIndex < BuildManager.Instance.Pieces.Count - 1)
                SelectedIndex++;
            else
                SelectedIndex = 0;
        } else if (WheelAxis < 0) {
            if (SelectedIndex > 0)
                SelectedIndex--;
            else
                SelectedIndex = BuildManager.Instance.Pieces.Count - 1;
        }

        if (SelectedIndex == -1)
            return;

        if (BuildManager.Instance.Pieces.Count != 0)
            BuilderBehaviour.Instance.SelectPrefab (BuildManager.Instance.Pieces[SelectedIndex]);
    }

    /// <summary>
    /// Check if the cursor is above a UI element or if the circular menu is open.
    /// </summary>
    private bool IsPointerOverUIElement ()
    {
        if (Cursor.lockState == CursorLockMode.Locked)
            return false;

        if (EventSystem.current == null)
            return false;

        PointerEventData EventData = new PointerEventData (EventSystem.current)
        {
            position = new Vector2 (Input.mousePosition.x, Input.mousePosition.y)
        };

        List<RaycastResult> Results = new List<RaycastResult> ();
        EventSystem.current.RaycastAll (EventData, Results);
        return Results.Count > 0;
    }

    public void setBuildModeEnabledState (bool state)
    {
        buildModeEnabled = state;

        if (!buildModeEnabled) {
            BuilderBehaviour.Instance.ChangeMode (BuildMode.None);
        }
    }

    #endregion
}

Save the GKCInputBehaviour.cs script and return to Unity. You should now see something like the following:

Step #6

Next we're going to link up the Player Mode that'll be used when the player wants to enter build mode.

First select the Player Controller GameObject in your project hierarchy and locate the "Player Modes List" in the "Player States Manager" component.

Now you need to create two new events in the player mode you want the player to have the ability to build in. We're going to use an existing one for this example called "Simple Mode", but you can add a new player mode, or use another existing one if you'd prefer.

Expand your selected mode and add a new event to the "Activate Player Mode Event" list and one to the "Deactivate Player Mode Event" list. The function for both new events should be set to GKCInputBehaviour.setBuildModeEnabledState - Now tick the checkbox in the "Activate Player Mode Event" list and leave the checkbox unticked in the "Deactivate Player Mode Event" list.

Finally drag the Main Camera GameObject into the object field in both events you just created.