public override void OnInspectorGUI()
{
base.serializedObject.Update();
Effector2D effector2D = this.target as Effector2D;
this.m_ShowColliderMask.target = effector2D.useColliderMask;
EditorGUILayout.PropertyField(this.m_UseColliderMask, new GUILayoutOption[0]);
if (EditorGUILayout.BeginFadeGroup(this.m_ShowColliderMask.faded))
{
EditorGUILayout.PropertyField(this.m_ColliderMask, new GUILayoutOption[0]);
}
EditorGUILayout.EndFadeGroup();
base.serializedObject.ApplyModifiedProperties();
base.OnInspectorGUI();
if (effector2D.GetComponents <Collider2D>().Any((Collider2D collider) => collider.enabled && collider.usedByEffector))
{
return;
}
if (effector2D.requiresCollider)
{
EditorGUILayout.HelpBox("This effector will not function until there is at least one enabled 2D collider with 'Used by Effector' checked on this GameObject.", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox("This effector can optionally work without a 2D collider.", MessageType.Info);
}
}
public static void CheckEffectorWarnings(Collider2D collider)
{
if (!collider.usedByEffector)
{
return;
}
Effector2D component = collider.GetComponent <Effector2D>();
if (component == null || !component.enabled)
{
EditorGUILayout.HelpBox("This collider will not function with an effector until there is at least one enabled 2D effector on this GameObject.", MessageType.Warning);
if (component == null)
{
return;
}
}
if (component.designedForNonTrigger && collider.isTrigger)
{
EditorGUILayout.HelpBox("This collider has 'Is Trigger' checked but this should be unchecked when used with the '" + component.GetType().Name + "' component which is designed to work with collisions.", MessageType.Warning);
}
else if (component.designedForTrigger && !collider.isTrigger)
{
EditorGUILayout.HelpBox("This collider has 'Is Trigger' unchecked but this should be checked when used with the '" + component.GetType().Name + "' component which is designed to work with triggers.", MessageType.Warning);
}
}
//===============================================================================================
// Private methods
//===============================================================================================
protected override void CheckCollider(Component component)
{
var effectorType = effector != null?effector.GetType() : null;
//get existing
TempEffectors.Clear();
component.GetComponents(TempEffectors);
//find target
Effector2D targetEffector = null;
for (var i = TempEffectors.Count - 1; i >= 0; i--)
{
var tempEffector = TempEffectors[i];
if (effectorType == tempEffector.GetType())
{
targetEffector = tempEffector;
}
else
{
BGCurve.DestroyIt(tempEffector);
}
}
TempEffectors.Clear();
if (effector == null)
{
return;
}
if (targetEffector == null)
{
targetEffector = (Effector2D)component.gameObject.AddComponent(effectorType);
}
//copy values
var fields = GetFields(effectorType);
foreach (var field in fields)
{
if (field.IsStatic)
{
continue;
}
field.SetValue(targetEffector, field.GetValue(effector));
}
var props = GetProperties(effectorType);
foreach (var prop in props)
{
if (!prop.CanWrite || !prop.CanWrite || prop.Name == "name")
{
continue;
}
prop.SetValue(targetEffector, prop.GetValue(effector, null), null);
}
}
public override void OnInspectorGUI()
{
this.serializedObject.Update();
Effector2D target = this.target as Effector2D;
this.m_ShowColliderMask.target = target.useColliderMask;
EditorGUILayout.PropertyField(this.m_UseColliderMask);
if (EditorGUILayout.BeginFadeGroup(this.m_ShowColliderMask.faded))
{
EditorGUILayout.PropertyField(this.m_ColliderMask);
}
EditorGUILayout.EndFadeGroup();
this.serializedObject.ApplyModifiedProperties();
base.OnInspectorGUI();
if (((IEnumerable <Collider2D>)target.GetComponents <Collider2D>()).Any <Collider2D>((Func <Collider2D, bool>)(collider =>
{
if (collider.enabled)
{
return(collider.usedByEffector);
}
return(false);
})))
{
return;
}
if (target.requiresCollider)
{
EditorGUILayout.HelpBox("This effector will not function until there is at least one enabled 2D collider with 'Used by Effector' checked on this GameObject.", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox("This effector can optionally work without a 2D collider.", MessageType.Info);
}
}
private static bool CheckEffectorForce(GameObject i_Go)
{
if (i_Go == null)
{
return(true);
}
Effector2D effector2D = i_Go.GetComponent <Effector2D>();
if (effector2D == null)
{
LogWarning(i_Go.name + " hasn't a valid effector.");
return(true);
}
bool errorOccurred = false;
if (effector2D is AreaEffector2D)
{
AreaEffector2D areaEffector2D = (AreaEffector2D)effector2D;
errorOccurred = (Mathf.Abs(areaEffector2D.forceMagnitude) < 0.1f);
}
if (errorOccurred)
{
LogWarning(i_Go.name + " has an invalid force magnitude.");
}
return(errorOccurred);
}
private static bool CheckEffectorAngle(GameObject i_Go, float i_Angle)
{
if (i_Go == null)
{
return(true);
}
Effector2D effector2D = i_Go.GetComponent <Effector2D>();
if (effector2D == null)
{
LogWarning(i_Go.name + " hasn't a valid effector.");
return(true);
}
bool errorOccurred = false;
if (effector2D is AreaEffector2D)
{
AreaEffector2D areaEffector2D = (AreaEffector2D)effector2D;
errorOccurred = !Mathf.Approximately(areaEffector2D.forceAngle, i_Angle);
}
if (errorOccurred)
{
LogWarning(i_Go.name + " has an invalid force angle.");
}
return(errorOccurred);
}
public override void OnInspectorGUI()
{
base.serializedObject.Update();
Effector2D target = base.target as Effector2D;
this.m_ShowColliderMask.target = target.useColliderMask;
EditorGUILayout.PropertyField(this.m_UseColliderMask, new GUILayoutOption[0]);
if (EditorGUILayout.BeginFadeGroup(this.m_ShowColliderMask.faded))
{
EditorGUILayout.PropertyField(this.m_ColliderMask, new GUILayoutOption[0]);
}
EditorGUILayout.EndFadeGroup();
base.serializedObject.ApplyModifiedProperties();
if (< > f__am$cache0 == null)
{
public static int get_colliderMask(IntPtr l)
{
int result;
try
{
Effector2D effector2D = (Effector2D)LuaObject.checkSelf(l);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, effector2D.colliderMask);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
Effector2D effector2D = this.target as Effector2D;
if (effector2D.GetComponents <Collider2D>().Any((Collider2D collider) => collider.enabled && collider.usedByEffector))
{
return;
}
if (effector2D.requiresCollider)
{
EditorGUILayout.HelpBox("This effector will not function until there is at least one enabled 2D collider with 'Used by Effector' checked on this GameObject.", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox("This effector can optionally work without a 2D collider.", MessageType.Info);
}
}
public static int set_useColliderMask(IntPtr l)
{
int result;
try
{
Effector2D effector2D = (Effector2D)LuaObject.checkSelf(l);
bool useColliderMask;
LuaObject.checkType(l, 2, out useColliderMask);
effector2D.useColliderMask = useColliderMask;
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
private static bool CheckEffector(GameObject i_Go)
{
if (i_Go == null)
{
return(true);
}
Effector2D effector2D = i_Go.GetComponent <Effector2D>();
if (effector2D == null)
{
LogWarning(i_Go.name + " hasn't a valid effector.");
return(true);
}
Collider2D collider2D = i_Go.GetComponent <Collider2D>();
if (collider2D == null)
{
LogWarning(i_Go.name + " hasn't a valid collider.");
return(true);
}
if (collider2D.usedByEffector && !collider2D.isTrigger)
{
LogWarning(i_Go.name + " is not a valid trigger.");
return(true);
}
if (collider2D.sharedMaterial != null)
{
LogWarning(i_Go.name + " has a PhysicsMaterial2D assigned. Remove it.");
return(true);
}
return(false);
}
private static bool CheckEffectorColliderMask(GameObject i_Go, int i_LayerMask)
{
if (i_Go == null)
{
return(true);
}
Effector2D effector2D = i_Go.GetComponent <Effector2D>();
if (effector2D == null)
{
LogWarning(i_Go.name + " hasn't a valid effector.");
return(true);
}
bool errorOccurred = (!effector2D.useColliderMask || ((effector2D.colliderMask & i_LayerMask) == 0));
if (errorOccurred)
{
LogWarning(i_Go.name + " has an effector with an invalid ColliderMask.");
}
return(errorOccurred);
}
public EffectorEmbed(Effector2D effector, MagneticBehaviour.Side side) {
this.side = side;
this.effector = effector;
effectorDistance = calculateEffectorDistance();
}
private void Awake()
{
m_effector = GetComponent <Effector2D>();
m_effector.enabled = false;
}
// initialization
void Start()
{
_rbody = GetComponent <Rigidbody2D>();
_effect = GetComponent <Effector2D>();
}
