/// <summary>
/// Draws the target influence settings.
/// </summary>
/// <param name="_control">Control.</param>
/// <param name="_target">Target.</param>
public static void DrawTargetInfluenceSettings(ICECreatureControl _control, TargetObject _target)
{
ICEEditorLayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(_target.Influences.Enabled == false);
_target.Influences.Foldout = ICEEditorLayout.Foldout(_target.Influences.Foldout, "Creature Influences", "", false);
EditorGUI.EndDisabledGroup();
GUILayout.FlexibleSpace();
InteractorRuleObject _rule = _target as InteractorRuleObject;
if (_rule != null)
{
_rule.OverrideInfluences = ICEEditorLayout.CheckButtonMiddle("OVERRIDE", "Overrides initial target influences", _rule.OverrideInfluences);
_rule.Influences.Enabled = _rule.OverrideInfluences;
if (!_rule.OverrideInfluences)
{
_rule.Influences.Foldout = false;
}
}
else
{
_target.Influences.Enabled = ICEEditorLayout.EnableButton("Enables/disables the influences", _target.Influences.Enabled);
}
ICEEditorLayout.EndHorizontal(Info.TARGET_INFLUENCES);
EditorGUI.BeginDisabledGroup(_target.Influences.Enabled == false);
CreatureObjectEditor.DrawInfluenceObject(_target.Influences, EditorHeaderType.FOLDOUT_CUSTOM, _control.Creature.Status.UseAdvanced, _control.Creature.Status.InitialDurabilityMax, Info.ENVIROMENT_COLLISION_INFLUENCES);
EditorGUI.EndDisabledGroup();
}
/// <summary>
/// Draws the target move specifications.
/// </summary>
/// <returns>The target move specifications.</returns>
/// <param name="_game_object">Game object.</param>
/// <param name="_target">Target.</param>
public static TargetObject DrawTargetMoveSpecification(GameObject _owner, TargetObject _target)
{
/*
* if( ! _target.Move.Enabled )
* {
* _target.Move.StoppingDistance = CreatureEditorLayout.DrawStoppingDistance( _target.Move.StoppingDistance, ref _target.Move.StoppingDistanceMaximum, ref _target.Move.IgnoreLevelDifference, ref _target.Move.StoppingDistanceZoneRestricted, ref _target.Move.Enabled );
* return _target;
* }
*/
InteractorRuleObject _rule = _target as InteractorRuleObject;
string _title_suffix = (_rule != null && !_rule.OverrideTargetMovePosition ? " (same as in Act One)" : (!_target.Move.Enabled ? " (Transform Position)" : " (" + _target.Move.MovePositionType.ToString() + ")"));
// BEGIN TARGET MOVE SPECIFICTAION HEADER
ICEEditorLayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(_target.Move.Enabled == false);
_target.Move.Foldout = ICEEditorLayout.Foldout(_target.Move.Foldout, "Target Move Specification" + _title_suffix, "", false);
EditorGUI.EndDisabledGroup();
//GUILayout.FlexibleSpace();
//_target.Move.MovePositionType = (TargetMovePositionType)EditorGUILayout.EnumPopup( _target.Move.MovePositionType, GUILayout.MaxWidth( 200 ) );
//EditorGUI.BeginDisabledGroup( _target.Move.UseDynamicOffsetDistance == false );
//_target.UseLastKnownPosition = ICEEditorLayout.ButtonCheck( "LKP", "Use last known position", _target.UseLastKnownPosition, ICEEditorStyle.CMDButtonDouble );
//EditorGUI.EndDisabledGroup();
if (_rule != null)
{
_rule.OverrideTargetMovePosition = ICEEditorLayout.CheckButtonMiddle("OVERRIDE", "Overrides initial target move specifications", _rule.OverrideTargetMovePosition);
if (!_rule.OverrideTargetMovePosition)
{
_target.Move.Foldout = false;
}
EditorGUI.BeginDisabledGroup(_rule.OverrideTargetMovePosition == false);
_target.Move.Enabled = ICEEditorLayout.EnableButton("Enables/Disables the move specification settings", _target.Move.Enabled);
EditorGUI.EndDisabledGroup();
}
else
{
_target.Move.Enabled = ICEEditorLayout.EnableButton("Enables/Disables the move specification settings", _target.Move.Enabled);
}
ICEEditorLayout.EndHorizontal(Info.TARGET_MOVE_SPECIFICATIONS);
// END TARGET MOVE SPECIFICTAION HEADER
// BEGIN TARGET MOVE SPECIFICTAION CONTENT
if (!_target.Move.Foldout)
{
return(_target);
}
EditorGUI.BeginDisabledGroup(_target.Move.Enabled == false);
EditorGUI.indentLevel++;
_target.Move.StoppingDistance = CreatureEditorLayout.DrawStoppingDistance(_target.Move.StoppingDistance, ref _target.Move.StoppingDistanceMaximum, ref _target.Move.IgnoreLevelDifference, ref _target.Move.StoppingDistanceZoneRestricted);
ICEEditorLayout.BeginHorizontal();
_target.Move.MovePositionType = (TargetMovePositionType)ICEEditorLayout.EnumPopup("Preferred Move Position", "", _target.Move.MovePositionType);
if (_target.Move.OverlapPreventionLayerMask == 0)
{
_target.Move.UseVerifiedDesiredTargetMovePosition = false;
}
EditorGUI.BeginDisabledGroup(_target.Move.OverlapPreventionLayerMask == 0);
_target.Move.UseVerifiedDesiredTargetMovePosition = ICEEditorLayout.CheckButtonMiddle("VERIFIED", "Ensures that the determined position is outside of other colliders.", _target.Move.UseVerifiedDesiredTargetMovePosition);
EditorGUI.EndDisabledGroup();
ICEEditorLayout.EndHorizontal(Info.TARGET_MOVE_SPECIFICATIONS_OFFSET);
// BEGIN MOVE POSITION TYPE
{
// MOVE POSITION TYPE : RANGE
if (_target.Move.MovePositionType == TargetMovePositionType.Range)
{
EditorGUI.indentLevel++;
ICEEditorLayout.BeginHorizontal();
_target.Move.FixedRange = ICEEditorLayout.MaxDefaultSlider("Distance", "", _target.Move.FixedRange, Init.DECIMAL_PRECISION_DISTANCES, _target.Move.StoppingDistance, ref _target.Move.FixedRangeMaximum, 0);
ICEEditorLayout.EndHorizontal(Info.TARGET_MOVE_SPECIFICATIONS_CIRCULAR_RANGE);
EditorGUI.indentLevel--;
}
// MOVE POSITION TYPE : COVER
if (_target.Move.MovePositionType == TargetMovePositionType.Cover)
{
EditorGUI.indentLevel++;
_target.Move.CoverRange = ICEEditorLayout.MaxDefaultSlider("Range", "", _target.Move.CoverRange, Init.DECIMAL_PRECISION_DISTANCES, 0f, ref _target.Move.CoverRangeMaximum, 10, "");
EditorGUILayout.Separator();
_target.Move.CoverStepAngle = ICEEditorLayout.DefaultSlider("Scan Step Angle", "", _target.Move.CoverStepAngle, Init.DECIMAL_PRECISION_ANGLE, 1f, 36, 3.6f, "");
_target.Move.CoverMaxAngle = ICEEditorLayout.DefaultSlider("Scan Max. Angle", "", _target.Move.CoverMaxAngle, Init.DECIMAL_PRECISION_ANGLE, 45, 360, 180, "");
_target.Move.CoverHorizontalOffset = ICEEditorLayout.MaxDefaultSlider("Scan Horizontal Offset", "", _target.Move.CoverHorizontalOffset, Init.DECIMAL_PRECISION_DISTANCES, 0f, ref _target.Move.CoverHorizontalOffsetMaximum, 0.5f, "");
//_target.Move.CoverVerticalOffset = ICEEditorLayout.MaxDefaultSlider( "Scan Vertical Offset", "", _move.Cover.VerticalOffset, Init.DECIMAL_PRECISION_DISTANCES, - _move.Cover.VerticalOffsetMaximum, ref _move.Cover.VerticalOffsetMaximum, 0f, "" );
EditorGUILayout.Separator();
CreatureEditorLayout.DrawCoverCheck(_target.Move.CoverLayer.Layers, true, "");
EditorGUI.indentLevel--;
}
// MOVE POSITION TYPE : OFFSET
else if (_target.Move.MovePositionType == TargetMovePositionType.Offset)
{
if (_target.Move.UpdateOffset(ICEEditorLayout.OffsetGroup("Offset", _target.Move.Offset, _owner, _target.TargetGameObject, 0.5f, 25, Info.TARGET_MOVE_SPECIFICATIONS_OFFSET)))
{
_target.UpdateTargetMovePositionOffset(false);
}
// BEGIN OFFSET DISTANCE AND ANGLE
EditorGUI.indentLevel++;
{
// BEGIN MOVE POSITION TYPE : OFFSET DISTANCE
ICEEditorLayout.BeginHorizontal();
float _distance = _target.Move.OffsetDistance;
if (_target.Move.UseDynamicOffsetDistance)
{
float _min_distance = _target.Move.MinOffsetDistance;
float _max_distance = _target.Move.MaxOffsetDistance;
ICEEditorLayout.MinMaxDefaultSlider("Distance", "", ref _min_distance, ref _max_distance, 0, ref _target.Move.OffsetDistanceMaximum, 0, 0, Init.DECIMAL_PRECISION_DISTANCES, 40);
if (_target.Move.MinOffsetDistance != _min_distance || _target.Move.MaxOffsetDistance != _max_distance)
{
_distance = Random.Range(_min_distance, _max_distance);
}
_target.Move.MinOffsetDistance = _min_distance;
_target.Move.MaxOffsetDistance = _max_distance;
}
else
{
_distance = ICEEditorLayout.MaxDefaultSlider("Distance", "", _target.Move.OffsetDistance, Init.DECIMAL_PRECISION_DISTANCES, Init.TARGET_OFFSET_DISTANCE_MIN, ref _target.Move.OffsetDistanceMaximum, Init.TARGET_OFFSET_DISTANCE_DEFAULT);
}
_target.Move.UseDynamicOffsetDistance = ICEEditorLayout.CheckButtonSmall("DYN", "Dynamic Offset Distance", _target.Move.UseDynamicOffsetDistance);
EditorGUI.BeginDisabledGroup(_target.Move.UseDynamicOffsetDistance == false);
_target.Move.UseRandomOffsetDistance = ICEEditorLayout.CheckButtonSmall("RND", "Random Offset Distance", _target.Move.UseRandomOffsetDistance);
EditorGUI.EndDisabledGroup();
ICEEditorLayout.EndHorizontal(Info.TARGET_MOVE_SPECIFICATIONS_OFFSET_DISTANCE);
if (_target.Move.UseDynamicOffsetDistance)
{
EditorGUI.indentLevel++;
_target.Move.DynamicOffsetDistanceUpdateSpeed = ICEEditorLayout.DefaultSlider("Speed", "", _target.Move.DynamicOffsetDistanceUpdateSpeed, 0.01f, 0, 36, 0, Info.TARGET_MOVE_SPECIFICATIONS_OFFSET_ANGLE);
EditorGUI.indentLevel--;
}
// END MOVE POSITION TYPE : OFFSET DISTANCE
// BEGIN MOVE POSITION TYPE : OFFSET ANGLE
ICEEditorLayout.BeginHorizontal();
float _angle = _target.Move.OffsetAngle;
if (_target.Move.UseDynamicOffsetAngle)
{
float _min_angle = _target.Move.MinOffsetAngle;
float _max_angle = _target.Move.MaxOffsetAngle;
ICEEditorLayout.MinMaxDefaultSlider("Angle", "", ref _min_angle, ref _max_angle, 0, 360, 0, 0, Init.DECIMAL_PRECISION, 40);
if (_target.Move.MinOffsetAngle != _min_angle || _target.Move.MaxOffsetAngle != _max_angle)
{
_angle = Random.Range(_min_angle, _max_angle);
}
_target.Move.MinOffsetAngle = _min_angle;
_target.Move.MaxOffsetAngle = _max_angle;
}
else
{
_angle = ICEEditorLayout.DefaultSlider("Angle", "", _target.Move.OffsetAngle, 0.01f, 0, 360, 0);
}
_target.Move.UseDynamicOffsetAngle = ICEEditorLayout.CheckButtonSmall("DYN", "Dynamic Offset Angle", _target.Move.UseDynamicOffsetAngle);
EditorGUI.BeginDisabledGroup(_target.Move.UseDynamicOffsetAngle == false);
_target.Move.UseRandomOffsetAngle = ICEEditorLayout.CheckButtonSmall("RND", "Random Offset Angle", _target.Move.UseRandomOffsetAngle);
EditorGUI.EndDisabledGroup();
ICEEditorLayout.EndHorizontal(Info.TARGET_MOVE_SPECIFICATIONS_OFFSET_ANGLE);
if (_target.Move.UseRandomOffsetAngle || _target.Move.UseDynamicOffsetAngle)
{
EditorGUI.indentLevel++;
_target.Move.DynamicOffsetAngleUpdateSpeed = ICEEditorLayout.DefaultSlider("Speed", "", _target.Move.DynamicOffsetAngleUpdateSpeed, 0.01f, 0, 36, 0, Info.TARGET_MOVE_SPECIFICATIONS_OFFSET_ANGLE);
EditorGUI.indentLevel--;
}
// END MOVE POSITION TYPE : OFFSET ANGLE
if (_target.Move.UpdateOffset(_angle, _distance))
{
_target.UpdateTargetMovePositionOffset(false);
}
}
EditorGUI.indentLevel--;
// END OFFSET DISTANCE AND ANGLE
EditorGUILayout.Separator();
// BEGIN MOVE POSITION TYPE : OFFSET SMOOTHING
ICEEditorLayout.BeginHorizontal();
_target.Move.SmoothingSpeed = ICEEditorLayout.MaxDefaultSlider("Smoothing Speed", "Smoothing Speed affects step-size and update speed of the TargetMovePosition.", _target.Move.SmoothingSpeed, 0.01f, 0, ref _target.Move.SmoothingSpeedMaximum, 0);
_target.Move.UseCreatureSpeed = ICEEditorLayout.AutoButtonSmall("Adds the defined smoothing speed and the current speed of the creature", _target.Move.UseCreatureSpeed);
ICEEditorLayout.EndHorizontal(Info.TARGET_MOVE_SPECIFICATIONS_SMOOTHING);
// END MOVE POSITION TYPE : OFFSET SMOOTHING
// BEGIN MOVE POSITION TYPE : OFFSET RANDOM POSITIONING
ICEEditorLayout.BeginHorizontal();
if (_target.Move.UseRandomRect)
{
if (_target.Move.UpdateRandomRange(ICEEditorLayout.Vector3Field("Random Positioning Range", "", _target.Move.RandomRangeRect)))
{
_target.UpdateTargetMovePositionOffset(true);
}
if (ICEEditorLayout.RandomButton(""))
{
_target.Move.UpdateRandomRange(new Vector3(Random.Range(10, _target.Move.RandomRangeMaximum), 0, Random.Range(10, _target.Move.RandomRangeMaximum)));
}
if (ICEEditorLayout.ButtonSmall("TEST", ""))
{
_target.UpdateTargetMovePositionOffset(true);
}
}
else
{
if (_target.Move.UpdateRandomRange(ICEEditorLayout.MaxDefaultSlider("Random Positioning Range", "", _target.Move.RandomRange, Init.DECIMAL_PRECISION_DISTANCES, 0, ref _target.Move.RandomRangeMaximum, Init.TARGET_RANDOM_RANGE_DEFAULT)))
{
_target.UpdateTargetMovePositionOffset(true);
}
if (ICEEditorLayout.RandomButton(""))
{
_target.Move.UpdateRandomRange(Random.Range(10, _target.Move.RandomRangeMaximum));
}
if (ICEEditorLayout.ButtonSmall("TEST", ""))
{
_target.UpdateTargetMovePositionOffset(true);
}
}
bool _org_random_rect = _target.Move.UseRandomRect;
_target.Move.UseRandomRect = ICEEditorLayout.CheckButtonSmall("RECT", "", _target.Move.UseRandomRect);
if (_target.Move.UseRandomRect != _org_random_rect)
{
_target.UpdateTargetMovePositionOffset(true);
}
ICEEditorLayout.EndHorizontal(Info.TARGET_MOVE_SPECIFICATIONS_RANDOM_RANGE);
if (_target.Move.HasRandomRange)
{
EditorGUI.indentLevel++;
ICEEditorLayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(new GUIContent("Update Position on ... ", ""));
_target.Move.UseUpdateOffsetOnTargetChanged = ICEEditorLayout.CheckButtonFlex("CHANGED", "Update on target changed", _target.Move.UseUpdateOffsetOnTargetChanged);
_target.Move.UseUpdateOffsetOnActivateTarget = ICEEditorLayout.CheckButtonFlex("ACTIVATE", "Update on activate target", _target.Move.UseUpdateOffsetOnActivateTarget);
_target.Move.UseUpdateOffsetOnMovePositionReached = ICEEditorLayout.CheckButtonFlex("REACHED", "Update on reached MovePosition", _target.Move.UseUpdateOffsetOnMovePositionReached);
_target.Move.UseUpdateOffsetOnRandomizedTimer = ICEEditorLayout.CheckButtonFlex("TIMER", "Update on timer interval", _target.Move.UseUpdateOffsetOnRandomizedTimer);
ICEEditorLayout.EndHorizontal(Info.TARGET_MOVE_SPECIFICATIONS_OFFSET_UPDATE);
EditorGUI.indentLevel++;
if (_target.Move.UseUpdateOffsetOnRandomizedTimer == true)
{
ICEEditorLayout.MinMaxSlider("Min/Max Interval", "", ref _target.Move.OffsetUpdateTimeMin, ref _target.Move.OffsetUpdateTimeMax, 0, 360, 0.25f, 40, "");
}
EditorGUI.indentLevel--;
EditorGUI.indentLevel--;
}
// END MOVE POSITION TYPE : OFFSET RANDOM POSITIONING
}
// MOVE POSITION TYPE : OTHERTARGET
else if (_target.Move.MovePositionType == TargetMovePositionType.OtherTarget)
{
EditorGUI.indentLevel++;
_target.Move.MoveTargetName = Popups.TargetPopup("Move Target", "", _target.Move.MoveTargetName, "");
EditorGUI.indentLevel--;
}
}
// END MOVE POSITION TYPE
EditorGUILayout.Separator();
EditorGUI.indentLevel--;
EditorGUI.EndDisabledGroup();
// END TARGET MOVE SPECIFICTAION CONTENT
return(_target);
}
private static void DrawInteractorRule(ICECreatureControl _control, InteractorObject _interactor, int _index)
{
InteractorRuleObject _rule = _interactor.Rules[_index];
InteractorRuleObject _prev_rule = null;
InteractorRuleObject _next_rule = null;
float _rule_max_distance = Init.DEFAULT_MAX_DISTANCE;
float _rule_min_distance = 0;
if (_interactor.Selectors.SelectionRange >= _rule.Selectors.SelectionRange + Init.SELECTION_RANGE_STEP)
{
_rule_max_distance = _interactor.Selectors.SelectionRange - Init.SELECTION_RANGE_STEP;
}
int _prev_index = _index - 1;
int _next_index = _index + 1;
if (_prev_index >= 0)
{
_prev_rule = _interactor.Rules[_prev_index];
_rule_max_distance = _prev_rule.Selectors.SelectionRange - Init.SELECTION_RANGE_STEP;
}
if (_next_index < _interactor.Rules.Count)
{
_next_rule = _interactor.Rules[_next_index];
_rule_min_distance = _next_rule.Selectors.SelectionRange + Init.SELECTION_RANGE_STEP;
}
ICEEditorLayout.BeginHorizontal();
_rule.Enabled = ICEEditorLayout.ToggleLeft(" RULE #" + _index + " - " + (_rule.BehaviourModeKey.Trim() != ""?_rule.BehaviourModeKey:"UNDEFINED"), "", _rule.Enabled, true);
if (_interactor.Rules.Count > 1)
{
EditorGUI.BeginDisabledGroup(_index <= 0);
if (ICEEditorLayout.ButtonUp())
{
InteractorRuleObject _obj = _interactor.Rules[_index];
_interactor.Rules.RemoveAt(_index);
float _obj_selection_range = _obj.Selectors.SelectionRange;
if (_index - 1 < 0)
{
_interactor.Rules.Add(_obj);
}
else
{
_interactor.Rules.Insert(_index - 1, _obj);
}
if (_prev_rule != null)
{
_obj.Selectors.SelectionRange = _prev_rule.Selectors.SelectionRange;
_prev_rule.Selectors.SelectionRange = _obj_selection_range;
}
return;
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(_index >= _interactor.Rules.Count - 1);
if (ICEEditorLayout.ButtonDown())
{
InteractorRuleObject _obj = _interactor.Rules[_index];
_interactor.Rules.RemoveAt(_index);
float _obj_selection_range = _obj.Selectors.SelectionRange;
if (_index + 1 > _interactor.Rules.Count)
{
_interactor.Rules.Insert(0, _obj);
}
else
{
_interactor.Rules.Insert(_index + 1, _obj);
}
if (_next_rule != null)
{
_obj.Selectors.SelectionRange = _next_rule.Selectors.SelectionRange;
_next_rule.Selectors.SelectionRange = _obj_selection_range;
}
return;
}
EditorGUI.EndDisabledGroup();
}
if (GUILayout.Button("X", ICEEditorStyle.CMDButtonDouble))
{
_interactor.Rules.RemoveAt(_index);
--_index;
}
ICEEditorLayout.EndHorizontal(Info.INTERACTION_INTERACTOR_RULE);
EditorGUI.BeginDisabledGroup(_rule.Enabled == false);
EditorGUI.indentLevel++;
_rule.Selectors.CanUseDefaultPriority = true;
_rule.Selectors.DefaultPriority = _interactor.Selectors.Priority;
EditorSharedTools.DrawTargetSelectors(_control, _rule.Selectors, TargetType.INTERACTOR, _rule_min_distance, _rule_max_distance);
EditorGUILayout.Separator();
// TARGET MOVE POSITION
_rule.OverrideTargetMovePosition = ICEEditorLayout.ToggleLeft("Override Target Move Specifications", "Overriding the Target Move Specifications", _rule.OverrideTargetMovePosition, false);
if (_rule.OverrideTargetMovePosition)
{
_rule = DrawInteractorRuleOffset(_control, _interactor, _rule);
EditorGUI.indentLevel++;
EditorGUILayout.Separator();
_rule.BlockRuleUpdateUntilMovePositionReached = ICEEditorLayout.Toggle("Block Next Rule", "Blocking the next rule until the target move position was reached", _rule.BlockRuleUpdateUntilMovePositionReached, Info.INTERACTION_INTERACTOR_RULE_BLOCK);
if (_rule.BlockRuleUpdateUntilMovePositionReached)
{
string _text = "This rule will be active until your creature reached the given move-position, so please make sure, that all potential positions " +
"reachable for your creature, otherwise you will provoke a deadlock!";
if (_rule.Selectors.SelectionRange == 0)
{
_text += "\n\nThe SelectionRange of this rule is adjusted to zero ";
}
Info.Note(_text);
}
EditorGUI.indentLevel--;
}
EditorGUILayout.Separator();
// BEHAVIOUR
string _auto_key = _interactor.Name + "_action_" + _index;
_rule.BehaviourModeKey = EditorBehaviour.BehaviourSelect(_control, "Behaviour", "Action behaviour for this interaction rule", _rule.BehaviourModeKey, _auto_key);
EditorGUILayout.Separator();
EditorGUI.indentLevel--;
EditorGUI.EndDisabledGroup();
}
/*
* private static InteractorRuleObject DrawInteractorRuleOffset( ICECreatureControl _control,InteractorObject _interactor, InteractorRuleObject _rule )
* {
* TargetObject _target = _rule as TargetObject;//new TargetObject( TargetType.INTERACTOR );
* _target.TargetGameObject = _interactor.TargetGameObject;// m_creature_register.GetTargetByName( _interactor.TargetName );
* _target.TargetTag = _interactor.TargetTag;
* _target.TargetName = _interactor.TargetName;
*
* _rule.OverrideTargetMovePosition = EditorSharedTools.DrawTargetObjectBlind( _target, _rule.OverrideTargetMovePosition );
* if( _rule.OverrideTargetMovePosition )
* EditorSharedTools.DrawTargetMoveSettings( _control.gameObject, _target);
*
* return _rule;
* } */
private static bool DrawInteractorRule(ICECreatureControl _control, InteractorObject _interactor, int _index)
{
InteractorRuleObject _rule = _interactor.Rules[_index];
ICEEditorLayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(_rule.Enabled == false);
_rule.Foldout = ICEEditorLayout.Foldout(_rule.Foldout, " Act #" + (_index + 2) + " - " + _rule.Behaviour.BehaviourTitle());
if (ICEEditorLayout.CopyButtonSmall("Creates a copy of the selected interactor rule"))
{
_interactor.Rules.Insert(_index, new InteractorRuleObject(_rule, true));
}
if (ICEEditorLayout.ResetButtonSmall("Resets the selected interactor rule"))
{
_rule.Copy(new InteractorRuleObject());
}
EditorGUI.EndDisabledGroup();
GUILayout.Space(5);
if (ICEEditorLayout.ListDeleteButton <InteractorRuleObject>(_interactor.Rules, _rule))
{
return(true);
}
GUILayout.Space(5);
if (ICEEditorLayout.ListUpDownButtons <InteractorRuleObject>(_interactor.Rules, _interactor.Rules.IndexOf(_rule)))
{
return(true);
}
GUILayout.Space(5);
_rule.Enabled = ICEEditorLayout.EnableButton("Enables/disables the selected rule", _rule.Enabled);
ICEEditorLayout.PriorityButton(_rule.SelectionPriority);
ICEEditorLayout.EndHorizontal(ref _rule.ShowInfoText, ref _rule.InfoText, Info.INTERACTION_INTERACTOR_RULE);
if (_rule.Foldout)
{
EditorGUI.BeginDisabledGroup(_rule.Enabled == false);
if (!Application.isPlaying)
{
_rule.OverrideTargetGameObject(_interactor.TargetGameObject);
}
_rule.Selectors.CanUseDefaultPriority = true;
if (_rule.Selectors.UseDefaultPriority)
{
_rule.Selectors.Priority = _interactor.Selectors.Priority + _index + 1;
}
TargetEditor.DrawTargetObjectBlind(_rule as TargetObject, "", "");
TargetEditor.DrawTargetContent(_control, _rule as TargetObject, true, "IACT_" + _interactor.TargetName.ToUpper() + "_R" + (_index + 2));
//TargetEditor.DrawTargetBehaviour( _control, _rule as TargetObject );
/*
* // BEHAVIOUR
* string _auto_key = _interactor.TargetName + "_action_" + _index;
* _rule.BehaviourModeKey = BehaviourEditor.BehaviourSelect( _control, "Behaviour", "Action behaviour for this interaction rule", _rule.BehaviourModeKey, _auto_key );
*/
EditorGUILayout.Separator();
EditorGUI.EndDisabledGroup();
}
return(false);
}
private static InteractorRuleObject DrawInteractorRuleOffset(ICECreatureControl _control, InteractorObject _interactor, InteractorRuleObject _rule)
{
EditorGUI.indentLevel++;
TargetObject _target = new TargetObject(TargetType.INTERACTOR);
_target.TargetGameObject = m_creature_register.GetReferenceCreatureByName(_interactor.Name);
ICEEditorLayout.BeginHorizontal();
string _title = "Target Object";
if (PrefabUtility.GetPrefabParent(_target.TargetGameObject) == null && PrefabUtility.GetPrefabObject(_target.TargetGameObject) != null) // Is a prefab
{
_title += " (prefab)";
}
else if (_target.TargetGameObject != null)
{
_title += " (scene)";
}
else
{
_title += " (null)";
}
EditorGUILayout.LabelField(_title, _interactor.Name);
if (_target.TargetGameObject != null)
{
if (GUILayout.Button("SHOW", ICEEditorStyle.ButtonMiddle))
{
var view = SceneView.currentDrawingSceneView;
if (view != null)
{
Vector3 _pos = _target.TargetGameObject.transform.position;
_pos.y += 20;
view.rotation = new Quaternion(1, 0, 0, 1);
view.LookAt(_pos);
// view.AlignViewToObject(_target.TargetGameObject.transform);
}
}
if (GUILayout.Button("SELECT", ICEEditorStyle.ButtonMiddle))
{
Selection.activeGameObject = _target.TargetGameObject;
}
}
ICEEditorLayout.EndHorizontal();
_target.UpdateOffset(_rule.Offset);
_target.TargetStopDistance = _rule.StopDistance;
_target.TargetRandomRange = _rule.RandomRange;
_target.TargetIgnoreLevelDifference = _rule.IgnoreLevelDifference;
_target.UseUpdateOffsetOnActivateTarget = _rule.UpdateOffsetOnActivateTarget;
_target.UseUpdateOffsetOnMovePositionReached = _rule.UpdateOffsetOnMovePositionReached;
_target.TargetSmoothingMultiplier = _rule.SmoothingMultiplier;
_target = EditorSharedTools.DrawTargetOffset(_control, _target);
_rule.Offset = _target.TargetOffset;
_rule.StopDistance = _target.TargetStopDistance;
_rule.RandomRange = _target.TargetRandomRange;
_rule.UpdateOffsetOnActivateTarget = _target.UseUpdateOffsetOnActivateTarget;
_rule.UpdateOffsetOnMovePositionReached = _target.UseUpdateOffsetOnMovePositionReached;
_rule.SmoothingMultiplier = _target.TargetSmoothingMultiplier;
_rule.IgnoreLevelDifference = _target.TargetIgnoreLevelDifference;
_target.TargetGameObject = null;
_target = null;
EditorGUI.indentLevel--;
return(_rule);
}
