koobas.hobune.stream
Alternative to SendMessage
First, let me say that I wouldn't ask without doing some research myself. However, there's nothing specific (or at least enough so that I would understand) on the matter.
At first, I was trying to implement a SendMessage system so that "Spell" could kill the "Enemy".
Sendmessage("Function", #)
And then on the Enemy:
function Function(var : int)
...bunch of ifs
Basically, depending on the element of the Spell the Enemy will react a certain way.
While trying to implement SendMessage (I was having issues referencing the clone, and not the prefab) I've come across several people recommending avoiding SendMessage altogether for a better alternative.
In this scenario, what's the better alternative?
Thank you in advance for your wisdom.
this link http://unity3d.com/support/resources/unite-presentations/techniques-for-making-reusable-code edges to using an alternative to sendmessage... I say use whatever it takes to get the job done. :)
One alternative I have used to SendMessage is to have a class (or an abstract class) that extends MonoBehaviour that basically describes the behavior and properties that encapsulates those related facets of the entity and has the method you want. Then use the GetComponent<> method or GetComponentInChildren<>. If it's not found then you don't bother sending the "message".
For example, if I wanted a GameObject to be able to be hit and damaged in the game I would define a class (or abstract if there were going to be multiple strategies) maybe called 'Hittable' or something that had methods like 'public void TakeHit(WeaponType type, int force)' and properties like 'public float HitPointOffset' and other things like these.
The advantages of this approach are that it requires a much stronger (compile time) contract between the sender and receiver than SendMessage even if you specify that a recipient is required. Also, I suspect that SendMessage uses reflection to check for the method on each MonoBehaviour (and invokes it) so from that perspective being able to do a selective broadcast by GetComponentInChildren<>() and then calling your method on those found may buy you a little efficiency. I wouldn't read to much into the efficiency thing though as I think Unity uses the SendMessage approach a whole lot internally. I am not sure that this is 'better' but I like it because of the strong contract and easy refactoring.
Hope some of that helps.
An interface would probably make more sense here. That way you would have to base your inheritance chains on a single class
An interface would not work as GetComponent can only retrieve object derived from Component (thus class or abstract class).
GetComponent does work with interfaces, but not the generic version because the generic parameter has a constraint to Component. The System.Type version work pretty well with interfaces. The generic version is just a wrapper of the System.Type version with an "as-cast".
However, if the OP uses UnityScript interfaces are kinda usless since you can derive / "extend" only from one type in Unityscript. C# works fine. It's one of the few differences between the languages.
Nobody should recommend avoiding SendMessage for a "better" alternative. Calling functions directly is faster than SendMessage, but that doesn't necessarily make it better. If SendMessage is appropriate for what you're doing and you don't need to call it a huge number of times then there's no reason to avoid it.
I have a similar doubt, on the side of performance, what is better:
Call Send$$anonymous$$essage on a $$anonymous$$onoBehaviour
$$anonymous$$yScript.Send$$anonymous$$essage("$$anonymous$$ethod", params);Cast the $$anonymous$$onoBehaviour to a defined interface
I$$anonymous$$ethod script = $$anonymous$$yScript as I$$anonymous$$ethod;
if (script != null)
script.$$anonymous$$ethod(params);
Thought I suspect that in this example if I can cache the cast script it most probably will be better calling via interface, right?
Yeah as previously stated, dont use SendMessage. Use GetComponent<> with interfaces. You get type safety way more speed. Since you are calling typed methods through an interface you can also have listeners respond back with results. Take a look at my ComponentBase.cs which handles getting all the listeners and adds way more granular control to scoping for GetComponent. https://gist.github.com/digital-synapse/12bc70e494067b85564a2039d184b65c
