MultiGame is a multi-purpose game development system for Unity. it allows the user to complete complex games by simply dragging and dropping components, and sending messages.
This versatile system empowers developers of all skill levels to create games more rapidly.
In practice, components either send messages, receive messages, or embody some type of game behavior. For consistency, these components are called senders, receivers, and processors. Processors usually both send and receive messages, and have some complex behavior like inventory management at their core.
For the components to work together, one needs to send messages to others. Common senders can be found in the "Logic" tab of the toolbar, and all MultiGame components can be found in the Inspector's Add Component -> MultiGame menu.
A message is any scripting function with zero or one parameters. This means it is often possible to use MultiGame message senders with scripts not included in MultiGame!
MultiGame also works seamlessly with Unity's new user interface system. Just assign events as you would messages (outlined below).
These components can be found in the Add Component -> MultiGame menu on the Inspector. The components are split into separate categories for ease of use.
All components have a “Help” button which contains quick instructions for their use!
When you first start using MultiGame, the large number of scripts and categories may at first seen intimidating. So if you are a beginner I recommend you start here, and move to the Component Reference section once you are more familiar with the system.
First, it is important to know that the system uses a fully decoupled architecture wherein components don’t “know” about each other in most cases. There are very few exceptions to this rule, and this decoupled approach allows MultiGame components to control non-MultiGame components by sending messages, toggling objects, and toggling components. MultiGame also works with UnityEvents and Animation events, making it very flexible.
Second, you should know that most components use either message senders or receivers. When you see the word “message” on a particular component, you will notice a consistent fold-out, which allows you to set up messages to be sent to other components. It is worth noting that even components developed outside of MultiGame often can receive useful messages! A message is simply a public or private method with 0 or 1 arguments. Since every package in existence has some methods with 0 or 1 arguments, it is almost always possible to interface MultiGame with other packages without any additional programming!
MultiGame components can be easily accessed via Unity’s Add Component menu. Take a few moments and experiment with anything that catches your eye - each component has built-in documentation right in the editor to help you along!
In the Component Reference section below, you will find a comprehensive list of MultiGame components. Browse through and find a few that will help you finish your game and give them a try! You can always swap them out later if you want :)
To use the standardized message senders, most of which are found in Add Component -> MultiGame -> Interaction -> Input, simply pair a message sender with another component that receives messages. The following example demonstrates basic workflow:
An “Active Zone” is added to the object
A “Message Spawner” is also added
We click the “Refresh Messages” button on the “Active Zone” and select “Spawn”
We drop a prefab in the “Item” slot on the “Message Spawner”
We add an entry to the “Active Tags” list called “Player”
As long as there is a collider on the object, it will spawn the prefab when the object tagged "Player" enters the trigger! To learn about what messages can be sent/received, we can look at the Inspector for any component. Below the “Help” button you will find some “MSG” foldouts. These tell us the exact message name, and if it has any arguments. You can also check the script files themselves for messages, which are any method with zero or one arguments of a supported primitive type. This is useful when using scripts found outside of MultiGame itself. Some components that embody an encapsulated game behavior also send optional messages using this system.
Target: the target object to receive the message. The current object is used if this field is left blank
Message: The exact name of the method to be called
Send Message Type: “Send” goes to one specific object, “Broadcast” also sends to all child objects.
Parameter: an optional parameter you can type in
Parameter Mode: The data type of the parameter. If “None” the Parameter field is ignored.
You can refresh the message sender, to check the "Target" (or the current game object if none is selected) for new messages.
Rapid Dev Tool
New in MultiGame 0.8 is the Rapid Dev Tool, a powerful interface containing editor functionality and commonly-used components to further accelerate your development.
To access this tool, select MultiGame -> Rapid Dev Tool from the top menu.
The Rapid Dev Tool is broken into the following categories:
This tab contains direct access to the most common and basic MultiGame features, including powerful editor tools and ways to control Unity game engine features (like lights, sounds and colliders) quickly and easily.
The Object tab contains powerful procedural primitives and mesh modification functionality. Using this tab you can create new object geometry and even entire game scenes right in the editor. It’s more lightweight than ProBuilder and allows easy offset and scaling of mesh UVs.
The Logic tab contain the most commonly-used message senders in MultiGame, allowing you to quickly generate messages to activate other functionality. It also contains the powerful Relay and TagRelay components, which let you broadcast multiple messages to multiple targets as desired, creating complex logic from simple components.
The Combat tab provides easy access to the most common combat functionality. Here you can add health, create projectiles of various types, explosions and general mayhem!
The Player tab contains a variety of controllers, as well as inventory and customization options. These common Player components are a direct interface to your game from your player’s perspective.
The AI tab contains automatic setup options for the most commonly-developed AI types. It also has a handy Layer Mask wizard to help you set up a two-team sensor system, which is required for most AI to detect targets.
The Utility tab provides quick access to important secondary game functionality like music, saving and loading the game level, quick one-button setup of LOD Group components, scene management and even 2D support via the Billboard system which allows a 2D sprite to represent an object in 3D space!
The Help tab contains a variety of links to video tutorials to help you get started with MultiGame. These tutorials will help you practice the basics and get started with MultiGame and accelerate your Unity game development experience!
MultiGame Pro contains 125 game features, and is capable of making thousands of games without programming.
UtilityModule: One of the most versatile types of game AI, the Utility Module has directives and a desire level for each. Every frame, it updates it's desire and pursues the Directive which has the highest desire level.
BehaviorSequencer: Execute a named list of events in order with an optional delay between each. Can be used with UtilityModule or by itself
NavBot: Takes orders from the mouse cursor. Requires a navigation mesh. Does not work with AI “module” components.
SimpleEnemy: Provides melee enemy (zombie) functionality. Does not work with AI “module” components. Very efficient! Tested 256 agents at 60 fps on a computer with a 2.2ghz quad core i7
TargetingComputer: Aims at moving rigidbodies.
Targeting Sensor: Used to assign targets to an AI
SetTarget: Assigns a target to compatible components
TurretAction: Spawns projectiles with a delay. Use with Targeting components for best results.
NavModule: handles navigation by Unity's navmesh agent system. You must bake navigation data in your scene according to the Unity documentation for it to work.
GuardModule: handles behavior of AI that should protect a given area and wander around in a predetermined radius.
HitscanModule: handles behavior of AI that should apply melee damage to targets at close range or instant damage to targets at long range.
MinionModule: allows the user to command the unit, and can be combined with other AI modules.
MusicManager: Allows you to set up three playlists for your users and change the volume
Sounder: Plays sounds when messages are received
PlayASound(AudioClip): play an arbitrary sound
PlaySound: play the sound assigned to the audio source
PlayRandomSound: select a random sound from 'clips'
PlaySelectedSound(int selector): play clip number 'selector'
BackupCamera: provides functionality to enable and disable a camera with an audio listener whether or not there is a main camera in the scene.
CamZone: Parent a camera to a cube, and put this component on the cube. Disable the cube's Mesh Renderer and position it and the camera. When an object tagged "Player" walks through the area denoted by the box collider, the camera will toggle on.
SmartCam: A powerful camera component that smoothly follows a target, third-person style. You can set up a target manually using an invisible transform offset from the player, or make it target the player automatically
CursorLock: Handles locking/unlocking the mouse cursor. Defaults to locking on WASD button presses and unlocking with CTRL
DepthTextureManager: Allows you to control the DepthTexture mode of the current renderer. If you don’t know what this is, you probably don’t need it!
CustomCharacter: Allows you to set up custom character editors in your game so that the player can customize their avatar.
CharacterSelector: Specify a list of player prefabs. Lets the Player switch.
CharacterOmnicontroller: Create a first or third person character with moving platform support! Pair this with the SmartCam component for easy third-person character setup!
Bullet: Simulates a physics-interpolated projectile.
BeamLaser: simulate a continuous fire laser beam, similar to bullet in functionality.
Explosion: applied explosive damage and rigid body forces to objects caught in the blast area.
ImpactDamage: applies collision damage to attached Health component based on the velocity of the objects that collided.
DamageBox: Periodically sends negative 'damage' amount of 'ModifyHealth'
Health: Allows things to die, tracks HP, and optionally displays it on-screen. Damage dealers all work with this component directly; allows things to live, die, and spawn prefabs on death such as ragdolls, explosions, and loot
ModifyHealth: Change the health
MeleeInputController: Allows you to use melee weapons for the player. Uses the legacy animation system.
MeleeWeaponAttributes: Needs to be on the melee weapon, which must be parented to the player.
ModernGun: Fires bullets, requires ammo (see “Inventory” section). Works for sci-fi guns as well!
Fire: Activates the weapon
GameManager: saves and loads the score, and allows victory conditions based on score values.
Score: increases the score by Goal Base Value
Victory: sends the Victory Message
ScoreCustomValue: (_val) increases the score by the specified value.
MessageManager: Provides the primary message sending functionality used in MultiGame. Can optionally be added to an object to send a large list of one-time messages (for example to set up the game when it starts). Does not need to be added to the game for messages to work!
SendAll: Sends all the messages in it’s list. Perhaps useful for initialization.
ProcCube, ProcSphere, ProcPlane, ProcCone: Creates a procedural primitive mesh on this GameObject and saves it in the “Generated” folder
UVScalar: Allows you to scale and offset the UVs of any mesh, and optionally allow the UVs to change at runtime when the object’s scale changes.
Autodestruct: Destroys attached object on a timer
LineTrail: draws a straight line between the objects start and current position.
OrientationRandomizer: on start, randomly rotates the object on the y axis.
CloneFlagRemover: Removes '(Clone)' from game object name
DestroyWithMe: Destroys other objects when this one dies
DetatchOnStart: Object separates from parent on spawn. Useful to spawn a “set” of prefabs all at once
ItemSpawner: Spawns items with a fixed limit on the quantity of each
OnDestruct: Sends messages when the object is destroyed
TimedSceneChanger: changes the scene after a specified period of time.
TimeSpeedManager: Allows the time scale of the simulation to be changed in-game or via the inspector. Great for fast-forward or slow motion.
ResetTimeScale: Sets the speed of simulation back to 1
SetRecoveryRate: sets the speed that the time scale returns to 1. Default 0
SetTimeScale: sets a new time scale. Default 1
ItemSpawner: Spawns items on start or message
SpawnItem(into selector): Spawn a specific item from the list
SnapToSurface: Causes an object to snap to a surface, either in the editor or on start.
SpeedReporter: either logs, or displays via GUI the speed of a moving object.
Persistent: exists between levels
PlanarYDestructor: Destroy itself if it goes too low
QualitySelection: Quality selection window for optimizing graphics options (Set these in Edit -> Project Settings -> Quality)
Tornado: Creates a devastating cyclone!
VanishOnStart: Visible only in editor (great for triggers!)
LineGuide: Create a vector line between points defined by object transforms.
TagTargeter: Set the “Target” field of a component (not a message!) by selecting an object by tag.
Rewinder: Record object positions over several seconds, and allow the object to go back in time! (Prince of Persia style!)
TimeScore: Track the player’s completion time and maximum completion time, optionally sending messages. Great for speed runners!
UnitSpawner: Spawn objects in an area based on the player’s actions. Optionally spawn a limited number inton the scene. Extra useful for zombie games!
ActiveCollider: Sends messages, plays animation on collision
ActiveZone: Same, but for triggers
AxisFloat: Sends "message" with single floating-point value taken from an input axis
Click able: Object sends messages on click
Collectible: Creates a collectible object that the player can get by collision/trigger
InputThreshold: Sends messages when specified axis goes above/below indicated thresholds
InputVector: works with "Thruster" component, found in "Motion" folder to supply multi-directional thrust based on input axes "Horizontal" and "Vertical"
JointBreakMessage: Sends a message when attached joint is broken
KeyMessage: Send messages to components based on the state of a key or button.
KeyToggle: Turns things on/off with keys/buttons
MultiMenu: Sends messages with menus. String these together to make dialogue trees
SartMessage: sends a message when the object is created in the scene, during play, or when the scene starts if it's a scene object
TagBroadcaster: sends a message to all objects with a given tag
TimedMessage: sends a message based on a timer
RandomizedMessage: Set a probability for each in a set of messages to be sent. Randomize loot, units, or anything really!
MessageSpawner: Spawns objects
MessageToggle: Turns objects on/off
CollectionManager: Collect a collectible, and send a message when the player collects them all!
MessageAnimator: Send triggers to an Animator component
MessageDestructor: Destroy and optionally replace the object
MessageParentRelation: Parent/unparent from target or current parent
MessageRelay: Send more messages when “Relay” is received
MessageScalar: Change the scale of the object
SceneTransition: Change the scene
TagBroadcaster: Just like a relay, but sends messages to all objects with a certain tag instead
ClickPainter: Lets the user change materials on objects using a handy GUI
CollisionDestructor: Destroy when we collide with something of a given tag
AnimatorFloatReceiver: Receives floating point values which are passed to the attached Mecanim Animator component
CursorLocker: Keep the cursor always locked
Deployer: Allows Team Fortress 2 style object deploys. See accompanying documentation found in the project file.
WallSection: Added to an empty game object representing the origin of a wall, where the intersection point is in the middle. Modular wall prefabs are added to this component and instantiated based on neighboring rules.
UpdateWall: Forces the wall to update itself during the next physics loop
DeployedObject: Receives messages allowing removal
MouseFollow: Adhere to mouse position in world space
MouseOverToggle: Turn scripts/game objects on/off by hovering mouse
Selectable: Control the state of the object based on whether it’s selected or not
TransformWindow: Allow player to edit the transform of objects
Transformer: Helper component for TransformWindow (not added to game objects, you can ignore this component safely)
MouseCommander: Allows users to deploy items StarCraft style. Optionally uses the Resource Management system in which case a ResourceManager must be used. See accompanying documentation in the Project folder
Inventory: Provides inventory and item usage. Works with Pickable and ActiveObject.
Pick(KeyValuePair<string, GameObject> kvp)
ItemGrabber: On contact, grab Pickable
Pickable: An object linked to an ActiveObject that goes in Player inventory
PickableClip: Works with ClipInventory for ModernWeapon usage
MinionSpawn: Spawn a limited number of minions from an Inventory item. If the max is reached, put the item back in Inventory
LightController: Control the intensity of the light over time using a gradient
Flashlight: Uses a keypress to toggle-attached light component
Strobe: Turn the light on/off with an interval timer
Worklight: Turn the light off when the game enters playmode (useful in the Editor)
AirBrakes: Change the drag using a message to allow things in the air to slow down on user input
DoorController: Easy procedural door animations based on messages
FighterInputController: Jet fighter player controller, flight sim or space sim style!
Graviton: Object that is both affected by and affects spherical gravity
MassiveObject: Object that only affects rigidbodies with a Graviton component
GridSnap: Snap to a custom grid at runtime
HingeMotor: Apply torque to a HingeJoint
InputTorqueMotor: Apply torque to a Rigidbody based on axis input
MouseAim: Rotate the object based on mouse XY input
MouseFollow: Snap to the surface under the mouse every frame based on layer and tag
MouseTorque: Apply torque based on mouse XY input
ObjectSeeker: Move smoothly towards another object position
PhysicsToggle: Turn rigidbody physics on or off
PositionContraint: Limit the object’s position to a given plane or line (axis-aligned)
RandomSpin: Spin like crazy all over the place!
SimpleMotor: Move in a given local or global impetus vector each frame
SixAxis: Full 6DOF movement, Descent-style!
SpinMotor: Spin in a given impetus vector
StickToGround: Stick to the tagged surface below the object
Teleporter: Warp this object, or other objects from point to point
InputRotator: changes the X&Y rotation by the impetus times the input vector.
Billboard: Always faces supplied target, or MainCamera
Thruster: receives messages and applies thrust based on them
BeginThrust, EndThrust: These messages toggle the thruster on or off. If on, it will apply 'thrust' constantly.
ThrustAmount(float scalar): Applies thrust for a single time step. Thrust applied = thrust * scalar
ThrustVector(Vector3 input): Applies 'input' thrust to the rigidbody for one single time step.
Hover: Casts a ray downwards, when the ray hits anything designated by the mask, applies 'hoverForce' upwards. Requires: Rigidbody