protected virtual void DrawEntityStatusUIContent(ICEWorldEntityStatusUI _ui)
{
if (_ui == null)
{
return;
}
WorldObjectEditor.DrawEntityStatusDisplayObject(_ui, _ui.StatusUI, m_HeaderType);
}
/// <summary>
/// Draws the target group message.
/// </summary>
/// <param name="_control">Control.</param>
/// <param name="_target">Target.</param>
/// <param name="_title">Title.</param>
/// <param name="_help">Help.</param>
public static void DrawTargetGroupMessage(ICECreatureControl _control, TargetObject _target, string _title = "", string _hint = "", string _help = "")
{
if (_control == null || _target == null)
{
return;
}
if (string.IsNullOrEmpty(_title))
{
_title = "Creature Messages";
}
if (string.IsNullOrEmpty(_hint))
{
_hint = "";
}
if (string.IsNullOrEmpty(_help))
{
_help = Info.TARGET_INFLUENCES;
}
ICEEditorLayout.BeginHorizontal();
WorldObjectEditor.DrawObjectHeaderLine(_target.GroupMessage, EditorHeaderType.FOLDOUT_ENABLED, _title, _hint);
ICEEditorLayout.EndHorizontal(_help);
// CONTENT BEGIN
if (WorldObjectEditor.BeginObjectContentOrReturn(EditorHeaderType.FOLDOUT_ENABLED, _target.GroupMessage))
{
return;
}
_target.GroupMessage.Type = (BroadcastMessageType)ICEEditorLayout.EnumPopup("Group Message", "", _target.GroupMessage.Type, Info.TARGET_GROUP_MESSAGE);
if (_target.GroupMessage.Type == BroadcastMessageType.COMMAND)
{
EditorGUI.indentLevel++;
_target.GroupMessage.Command = ICEEditorLayout.Text("Command", "Command", _target.GroupMessage.Command, Info.TARGET_GROUP_MESSAGE_COMMAND).ToUpper();
EditorGUI.indentLevel--;
}
WorldObjectEditor.EndObjectContent();
// CONTENT END
}
private static void DrawStatusBasics(ICECreatureControl _control)
{
_control.Creature.Status.Enabled = true;
if (!_control.Display.ShowStatus)
{
return;
}
EditorGUI.indentLevel++;
ICEEditorLayout.BeginHorizontal();
_control.Display.FoldoutStatusBasics = ICEEditorLayout.Foldout(_control.Display.FoldoutStatusBasics, "Basics");
ICEEditorLayout.EndHorizontal(Info.STATUS_BASICS);
if (_control.Display.FoldoutStatusBasics)
{
EditorGUI.indentLevel++;
EditorGUILayout.Separator();
CreatureObjectEditor.DrawInitialDurability(_control.Creature.Status);
//EditorGUI.BeginDisabledGroup( _control.Creature.Status.UseAdvanced == true );
// CreatureObjectEditor.DrawDurabilitySlider( _control.Creature.Status );
//EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(_control.Creature.Status.IsDestructible == false);
EditorGUI.indentLevel++;
if (_control.Creature.Status.UseAdvanced)
{
_control.Creature.Status.DamageInPercent = ICEEditorLayout.DefaultSlider("Damage", "", _control.Creature.Status.DamageInPercent, 0.025f, 0, 100, 0, Info.STATUS_DAMAGE_IN_PERCENT);
_control.Creature.Status.StressInPercent = ICEEditorLayout.DefaultSlider("Stress", "", _control.Creature.Status.StressInPercent, 0.025f, 0, 100, 0, Info.STATUS_STRESS_IN_PERCENT);
_control.Creature.Status.DebilityInPercent = ICEEditorLayout.DefaultSlider("Debility", "", _control.Creature.Status.DebilityInPercent, 0.025f, 0, 100, 0, Info.STATUS_DEBILITY_IN_PERCENT);
_control.Creature.Status.HungerInPercent = ICEEditorLayout.DefaultSlider("Hunger", "", _control.Creature.Status.HungerInPercent, 0.025f, 0, 100, 0, Info.STATUS_HUNGER_IN_PERCENT);
_control.Creature.Status.ThirstInPercent = ICEEditorLayout.DefaultSlider("Thirst", "", _control.Creature.Status.ThirstInPercent, 0.025f, 0, 100, 0, Info.STATUS_THIRST_IN_PERCENT);
EditorGUILayout.Separator();
_control.Creature.Status.Aggressivity = ICEEditorLayout.DefaultSlider("Aggressivity", "", _control.Creature.Status.Aggressivity, 0.025f, 0, 100, _control.Creature.Status.DefaultAggressivity, Info.STATUS_INFLUENCES_AGGRESSIVITY);
_control.Creature.Status.Experience = ICEEditorLayout.DefaultSlider("Experience", "", _control.Creature.Status.Experience, 0.025f, 0, 100, _control.Creature.Status.DefaultExperience, Info.STATUS_INFLUENCES_EXPERIENCE);
_control.Creature.Status.Nosiness = ICEEditorLayout.DefaultSlider("Nosiness", "", _control.Creature.Status.Nosiness, 0.025f, 0, 100, _control.Creature.Status.DefaultNosiness, Info.STATUS_INFLUENCES_NOSINESS);
_control.Creature.Status.Anxiety = ICEEditorLayout.DefaultSlider("Anxiety", "", _control.Creature.Status.Anxiety, 0.025f, 0, 100, _control.Creature.Status.DefaultAnxiety, Info.STATUS_INFLUENCES_ANXIETY);
}
else
{
_control.Creature.Status.DamageInPercent = ICEEditorLayout.Slider("Damage", "", _control.Creature.Status.DamageInPercent, Init.DECIMAL_PRECISION, 0, 100, Info.STATUS_DAMAGE_IN_PERCENT);
}
EditorGUILayout.Separator();
CreatureObjectEditor.DrawDamageTransfer(_control.Creature.Status, Info.STATUS_DAMAGE_TRANSFER_MULTIPLIER);
EditorGUI.indentLevel--;
EditorGUI.EndDisabledGroup();
EditorGUILayout.Separator();
CreatureObjectEditor.DrawStatusMass(_control.Creature.Status);
ICEEditorLayout.MinMaxDefaultSlider("Perception Time (secs.)", "",
ref _control.Creature.Status.PerceptionTimeMin,
ref _control.Creature.Status.PerceptionTimeMax,
0,
10,
0.4f,
0.6f,
Init.DECIMAL_PRECISION_TIMER,
40,
Info.STATUS_PERCEPTION_TIME);
if (_control.Creature.Status.UseAdvanced)
{
EditorGUI.indentLevel++;
_control.Creature.Status.PerceptionTimeFitnessMultiplier = ICEEditorLayout.DefaultSlider("Fitness Multiplier (inv. +)", "", _control.Creature.Status.PerceptionTimeFitnessMultiplier, 0.025f, 0, 1, 0.3f, Info.STATUS_REACTION_TIME_MULTIPLIER);
EditorGUI.indentLevel--;
}
ICEEditorLayout.MinMaxDefaultSlider("Reaction Time (secs.)", "",
ref _control.Creature.Status.ReactionTimeMin,
ref _control.Creature.Status.ReactionTimeMax,
0,
2,
0.1f,
0.2f,
Init.DECIMAL_PRECISION_TIMER,
40,
Info.STATUS_REACTION_TIME);
EditorGUILayout.Separator();
ICEEditorLayout.MinMaxRandomDefaultSlider("Recovery Phase (secs.)", "Defines how long the creature will be defenceless after spawning.", ref _control.Creature.Status.RecoveryPhaseMin, ref _control.Creature.Status.RecoveryPhaseMax, 0, ref _control.Creature.Status.RecoveryPhaseMaximum, 0.01f, 0.1f, Init.DECIMAL_PRECISION_TIMER, 30, Info.STATUS_RECOVERY_PHASE);
ICEEditorLayout.MinMaxRandomDefaultSlider("Removing Delay (secs.)", "Defines how long the creature will be visible after dying and before respawning.", ref _control.Creature.Status.RemovingDelayMin, ref _control.Creature.Status.RemovingDelayMax, 0, ref _control.Creature.Status.RemovingDelayMaximum, 0, 0, Init.DECIMAL_PRECISION_TIMER, 30, Info.STATUS_REMOVING_DELAY);
EditorGUILayout.Separator();
_control.Creature.Status.FitnessRecreationLimit = ICEEditorLayout.DefaultSlider("Recreation Limit (%)", "If the fitness value reached this limit your creature will go home to recreate.", _control.Creature.Status.FitnessRecreationLimit, 0.5f, 0, 100, 0, Info.STATUS_FITNESS_RECREATION_LIMIT);
_control.Creature.Status.FitnessVitalityLimit = ICEEditorLayout.DefaultSlider("Vitality Limit (%)", "If the fitness value reached this limit your creature will be to weak for further activities.", _control.Creature.Status.FitnessVitalityLimit, 0.5f, 0, 100, 0, Info.STATUS_FITNESS_VITALITY_LIMIT);
EditorGUILayout.Separator();
// ODOUR BEGIN
CreatureObjectEditor.DrawOdourObject(_control.Creature.Status.Odour);
// ODOUR END
// GENDER BEGIN
_control.Creature.Status.GenderType = (CreatureGenderType)ICEEditorLayout.EnumPopup("Gender", "", _control.Creature.Status.GenderType, Info.STATUS_GENDER);
// GENDER END
// TROPHIC LEVEL BEGIN
ICEEditorLayout.BeginHorizontal();
_control.Creature.Status.TrophicLevel = (TrophicLevelType)ICEEditorLayout.EnumPopup("Trophic Level", "", _control.Creature.Status.TrophicLevel);
if (ICEEditorLayout.RandomButton(""))
{
_control.Creature.Status.CalculateRandomStatusValues(_control.Creature.Status.TrophicLevel);
}
_control.Creature.Status.UseDynamicInitialisation = ICEEditorLayout.CheckButtonSmall("DYN", "", _control.Creature.Status.UseDynamicInitialisation);
ICEEditorLayout.EndHorizontal(Info.STATUS_FEEDTYPE);
EditorGUI.indentLevel++;
if (_control.Creature.Status.TrophicLevel == TrophicLevelType.OMNIVORES || _control.Creature.Status.TrophicLevel == TrophicLevelType.CARNIVORE)
{
_control.Creature.Status.IsCannibal = ICEEditorLayout.Toggle("Is Cannibal", "", _control.Creature.Status.IsCannibal, Info.STATUS_FEEDTYPE_CANNIBAL);
}
else
{
_control.Creature.Status.IsCannibal = false;
}
EditorGUI.indentLevel--;
// TROPHIC LEVEL END
EditorGUILayout.Separator();
WorldObjectEditor.DrawStatusAging(_control.Creature.Status);
_control.Creature.Status.UseEnvironmentTemperature = ICEEditorLayout.Toggle("Use Environment Temperature", "", _control.Creature.Status.UseEnvironmentTemperature, Info.STATUS_TEMPERATURE);
if (_control.Creature.Status.UseEnvironmentTemperature)
{
EditorGUI.indentLevel++;
_control.Creature.Status.ComfortEnvironmentTemperature = ICEEditorLayout.Slider("Comfort Environment Temperature", "", _control.Creature.Status.ComfortEnvironmentTemperature, 1, _control.Creature.Status.MinEnvironmentTemperature, _control.Creature.Status.MaxEnvironmentTemperature, Info.STATUS_TEMPERATURE_BEST);
EditorGUI.indentLevel++;
ICEEditorLayout.MinMaxSlider("Temperature Scope", "Minimal and maximal Temperatures",
ref _control.Creature.Status.MinEnvironmentTemperature,
ref _control.Creature.Status.MaxEnvironmentTemperature,
_control.Creature.Status.EnvironmentMinTemperature,
_control.Creature.Status.EnvironmentMaxTemperature,
1,
40,
Info.STATUS_TEMPERATURE_SCOPE);
EditorGUI.indentLevel--;
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
}
_control.Creature.Status.UseArmor = ICEEditorLayout.Toggle("Use Armor", "", _control.Creature.Status.UseArmor, Info.STATUS_ARMOR);
if (_control.Creature.Status.UseArmor)
{
EditorGUI.indentLevel++;
_control.Creature.Status.ArmorInPercent = ICEEditorLayout.DefaultSlider("Armor", "", _control.Creature.Status.ArmorInPercent, 1, 0, 100, 100, Info.STATUS_ARMOR_IN_PERCENT);
EditorGUI.indentLevel--;
}
_control.Creature.Status.UseShelter = ICEEditorLayout.Toggle("Use Shelter", "", _control.Creature.Status.UseShelter, Info.STATUS_SHELTER);
if (_control.Creature.Status.UseShelter)
{
EditorGUI.indentLevel++;
if (_control.Creature.Status.IsSheltered)
{
GUI.backgroundColor = Color.green;
}
_control.Creature.Status.ShelterTag = ICEEditorLayout.Tag("Shelter Tag", "", _control.Creature.Status.ShelterTag, Info.STATUS_SHELTER_TAG);
GUI.backgroundColor = ICEEditorLayout.DefaultBackgroundColor;
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
}
_control.Creature.Status.UseIndoor = ICEEditorLayout.Toggle("Use Indoor", "", _control.Creature.Status.UseIndoor, Info.STATUS_INDOOR);
if (_control.Creature.Status.UseIndoor)
{
EditorGUI.indentLevel++;
if (_control.Creature.Status.IsIndoor)
{
GUI.backgroundColor = Color.green;
}
_control.Creature.Status.IndoorTag = ICEEditorLayout.Tag("Indoor Tag", "", _control.Creature.Status.IndoorTag, Info.STATUS_INDOOR_TAG);
GUI.backgroundColor = ICEEditorLayout.DefaultBackgroundColor;
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
}
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
}
EditorGUI.indentLevel--;
}
public virtual void DrawCameraContent(ICEWorldCamera _target)
{
WorldObjectEditor.DrawUnderwaterCameraEffect(_target, _target.Underwater, m_HeaderType);
}
public static void DrawAnimationDataObject(ICEWorldBehaviour _component, AnimationDataObject _anim, EditorHeaderType _type, string _help = "", string _title = "", string _hint = "", List <AnimationDataObject> _list = null)
{
if (_anim == null)
{
return;
}
if (string.IsNullOrEmpty(_title))
{
_title = "Animation";
}
if (string.IsNullOrEmpty(_hint))
{
_hint = "";
}
if (string.IsNullOrEmpty(_help))
{
_help = Info.ANIMATION;
}
//--------------------------------------------------
// ANIMATION
//--------------------------------------------------
bool _enabled = _anim.Enabled;
//_anim.Enabled = (_anim.InterfaceType != AnimationInterfaceType.NONE?true:false);
ICEEditorLayout.BeginHorizontal();
if (WorldObjectEditor.IsEnabledFoldoutType(_type))
{
EditorGUI.BeginDisabledGroup(_anim.Enabled == false);
}
WorldObjectEditor.DrawObjectHeaderLine(_anim, WorldObjectEditor.GetSimpleFoldout(_type), _title, _hint);
GUILayout.FlexibleSpace();
//EditorGUI.BeginDisabledGroup( _anim.Enabled == false );
_anim.AllowInterfaceSelector = !ICEEditorLayout.CheckButtonMiddle("AUTO", "Automatic Interface Selection", !_anim.AllowInterfaceSelector);
//EditorGUI.EndDisabledGroup();
if (_list != null && _list.Count > 1)
{
if (ICEEditorLayout.Button("SHARE", "Use this move settings for all associated rules"))
{
foreach (AnimationDataObject _data in _list)
{
_data.Copy(_anim);
}
}
}
if (WorldObjectEditor.IsEnabledFoldoutType(_type))
{
EditorGUI.EndDisabledGroup();
_anim.Enabled = ICEEditorLayout.EnableButton(_anim.Enabled);
}
ICEEditorLayout.EndHorizontal(_help);
if (_enabled != _anim.Enabled && _anim.Enabled == true)
{
_anim.Foldout = true;
}
// CONTENT BEGIN
if (WorldObjectEditor.BeginObjectContentOrReturn(_type, _anim))
{
return;
}
if ((_component.GetComponentInChildren <Animator>() != null && _component.GetComponentInChildren <Animation>() != null) || _anim.AllowInterfaceSelector)
{
if (_anim.InterfaceType == AnimationInterfaceType.NONE && _component.GetComponentInChildren <Animator>() != null && _component.GetComponentInChildren <Animator>().runtimeAnimatorController != null)
{
_anim.InterfaceType = AnimationInterfaceType.MECANIM;
}
else if (_anim.InterfaceType == AnimationInterfaceType.NONE)
{
_anim.InterfaceType = AnimationInterfaceType.LEGACY;
}
_help = Info.ANIMATION_NONE;
if (_anim.InterfaceType == AnimationInterfaceType.MECANIM)
{
_help = Info.ANIMATION_ANIMATOR;
}
else if (_anim.InterfaceType == AnimationInterfaceType.LEGACY)
{
_help = Info.ANIMATION_ANIMATION;
}
else if (_anim.InterfaceType == AnimationInterfaceType.CLIP)
{
_help = Info.ANIMATION_CLIP;
}
else if (_anim.InterfaceType == AnimationInterfaceType.CUSTOM)
{
_help = Info.ANIMATION_CUSTOM;
}
_anim.InterfaceType = (AnimationInterfaceType)ICEEditorLayout.EnumPopup("Interface", "", _anim.InterfaceType, _help);
}
else if (_component.GetComponentInChildren <Animator>())
{
_anim.InterfaceType = AnimationInterfaceType.MECANIM;
}
else
{
_anim.InterfaceType = AnimationInterfaceType.LEGACY;
}
if (_anim.InterfaceType != AnimationInterfaceType.NONE)
{
if (_anim.InterfaceType == AnimationInterfaceType.MECANIM)
{
_anim.Animator = DrawBehaviourAnimationAnimatorData(_component, _anim.Animator);
}
else if (_anim.InterfaceType == AnimationInterfaceType.LEGACY)
{
_anim.Animation = DrawBehaviourAnimationAnimationData(_component, _anim.Animation);
}
else if (_anim.InterfaceType == AnimationInterfaceType.CLIP)
{
_anim.Clip = DrawBehaviourAnimationAnimationClipData(_component, _anim.Clip);
}
else if (_anim.InterfaceType == AnimationInterfaceType.CUSTOM)
{
Info.Help(_help);
}
if (_anim.InterfaceType == AnimationInterfaceType.MECANIM && _anim.Animator.Type == AnimatorControlType.DIRECT)
{
DrawAnimationEventData(_component, _anim.Events, AnimationTools.GetAnimationClipByAnimatorAndName(AnimationTools.TryGetAnimatorComponent(_component.gameObject), _anim.GetAnimationName()), EditorHeaderType.FOLDOUT_ENABLED);
}
else if (_anim.InterfaceType == AnimationInterfaceType.LEGACY)
{
DrawAnimationEventData(_component, _anim.Events, AnimationTools.GetAnimationClipByName(AnimationTools.TryGetAnimationComponent(_component.gameObject), _anim.GetAnimationName()), EditorHeaderType.FOLDOUT_ENABLED);
}
else if (_anim.InterfaceType == AnimationInterfaceType.CLIP)
{
DrawAnimationEventData(_component, _anim.Events, _anim.Clip.Clip, EditorHeaderType.FOLDOUT_ENABLED);
}
}
else
{
Info.Help(Info.ANIMATION_NONE);
}
WorldObjectEditor.EndObjectContent();
// CONTENT END
}
public void DrawWorldPlayerContect(ICEWorldPlayerController _player)
{
/*
* if( Application.isPlaying == false )
* {
* _controller.transform.position = new Vector3(
* _controller.transform.position.x,
* PositionTools.GetGroundLevel( _controller.transform.position, Groudc , GroundLayerMask );
* ICECreatureRegister.Instance.GetGroundLevel(_controller.transform.position),
* _controller.transform.position.z );
* }*/
EditorGUILayout.Separator();
ICEEditorLayout.Label("Movement", true);
EditorGUI.indentLevel++;
_player.WalkSpeed = ICEEditorLayout.DefaultSlider("Walk Speed", "", _player.WalkSpeed, 0.025f, 0, 25, 3, "");
_player.RunSpeed = ICEEditorLayout.DefaultSlider("Run Speed", "", _player.RunSpeed, 0.025f, 0, 25, 7, "");
EditorGUI.indentLevel++;
_player.RunstepLenghten = ICEEditorLayout.DefaultSlider("Runstep Lenghten", "", _player.RunstepLenghten, 0.025f, 0, 25, 7, "");
EditorGUI.indentLevel--;
_player.JumpSpeed = ICEEditorLayout.DefaultSlider("Jump Speed", "", _player.JumpSpeed, 0.025f, 0, 100, 25, "");
EditorGUI.indentLevel++;
_player.StickToGroundForce = ICEEditorLayout.DefaultSlider("Stick To Ground Force", "", _player.StickToGroundForce, 0.025f, 0, 25, 7, "");
_player.GravityMultiplier = ICEEditorLayout.DefaultSlider("Gravity", "", _player.GravityMultiplier, 0.025f, 0, 100, 9.825f, "");
EditorGUI.indentLevel--;
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
ICEEditorLayout.Label("Sounds", true);
EditorGUI.indentLevel++;
ICEEditorLayout.Label("Footsteps", false);
EditorGUI.indentLevel++;
Keyframe[] _keys = new Keyframe[3];
_keys[0] = new Keyframe(0, 0f);
_keys[1] = new Keyframe(_player.WalkSpeed, 0.6f);
_keys[2] = new Keyframe(_player.RunSpeed, 0.3f);
_player.Interval = ICEEditorLayout.DefaultCurve("Footstep Interval", "", _player.Interval, new AnimationCurve(_keys));
for (int _i = 0; _i < _player.FootstepSounds.Count; _i++)
{
AudioClip _clip = _player.FootstepSounds[_i];
_clip = (AudioClip)EditorGUILayout.ObjectField("Footstep Clip #" + _i, _clip, typeof(AudioClip), false);
if (_clip == null)
{
_player.FootstepSounds.RemoveAt(_i);
return;
}
}
AudioClip _new_clip = (AudioClip)EditorGUILayout.ObjectField("Add Footstep Clip", null, typeof(AudioClip), false);
if (_new_clip != null)
{
_player.FootstepSounds.Add(_new_clip);
}
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
_player.JumpSound = (AudioClip)EditorGUILayout.ObjectField("Jump", _player.JumpSound, typeof(AudioClip), false);
_player.LandSound = (AudioClip)EditorGUILayout.ObjectField("Land", _player.LandSound, typeof(AudioClip), false); // the sound played when character touches back on ground.
EditorGUI.indentLevel--;
WorldObjectEditor.DrawMouseLookObject(_player.MouseLook, EditorHeaderType.LABEL_BOLD);
EditorGUILayout.Separator();
ICEEditorLayout.Label("Debug Mode", true);
EditorGUI.indentLevel++;
_player.UseDebugMode = ICEEditorLayout.Toggle("Enable Debug Mode", "", _player.UseDebugMode, "");
_player.KeyFlightMode = (KeyCode)ICEEditorLayout.EnumPopup("Toogle Flight Mode", "", _player.KeyFlightMode);
EditorGUI.indentLevel++;
_player.KeyUp = (KeyCode)ICEEditorLayout.EnumPopup("Up", "", _player.KeyUp);
_player.KeyDown = (KeyCode)ICEEditorLayout.EnumPopup("Down", "", _player.KeyDown);
_player.FlightSpeedMultiplier = (int)ICEEditorLayout.DefaultSlider("Flight Speed Multiplier", "", _player.FlightSpeedMultiplier, 1, 1, 100, 10, "");
EditorGUI.indentLevel--;
EditorGUI.indentLevel--;
}
private static void DrawEnvironmentSurfaceSettings(ICECreatureControl _control)
{
ICEEditorLayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(_control.Creature.Environment.SurfaceHandler.Enabled == false);
WorldObjectEditor.DrawObjectHeaderLine(ref _control.Creature.Environment.SurfaceHandler.Enabled, ref _control.Creature.Environment.SurfaceHandler.Foldout, EditorHeaderType.FOLDOUT_BOLD, "Surfaces", "");
EditorGUI.EndDisabledGroup();
if (ICEEditorLayout.AddButton("Adds a new surface rule"))
{
_control.Creature.Environment.SurfaceHandler.Surfaces.Add(new SurfaceDataObject());
_control.Creature.Environment.SurfaceHandler.Enabled = true;
}
if (ICEEditorLayout.SaveButton("Saves surface data to file"))
{
CreatureEditorIO.SaveEnvironmentSurfaceToFile(_control.Creature.Environment.SurfaceHandler, _control.gameObject.name);
}
if (ICEEditorLayout.LoadButton("Loads surface data to file"))
{
_control.Creature.Environment.SurfaceHandler = CreatureEditorIO.LoadEnvironmentSurfaceFromFile(_control.Creature.Environment.SurfaceHandler);
}
if (ICEEditorLayout.ResetButton("Resets the surface data"))
{
_control.Creature.Environment.SurfaceHandler.Reset();
}
_control.Creature.Environment.SurfaceHandler.Enabled = ICEEditorLayout.EnableButton(_control.Creature.Environment.SurfaceHandler.Enabled);
ICEEditorLayout.EndHorizontal(Info.ENVIROMENT_SURFACE);
if (_control.Creature.Environment.SurfaceHandler.Enabled == true && _control.Creature.Environment.SurfaceHandler.Surfaces.Count == 0)
{
_control.Creature.Environment.SurfaceHandler.Surfaces.Add(new SurfaceDataObject());
_control.Creature.Environment.SurfaceHandler.Foldout = true;
}
// CONTENT BEGIN
if (WorldObjectEditor.BeginObjectContentOrReturn(EditorHeaderType.FOLDOUT_BOLD, _control.Creature.Environment.SurfaceHandler))
{
return;
}
_control.Creature.Environment.SurfaceHandler.GroundScanInterval = ICEEditorLayout.MaxDefaultSlider("Ground Scan Interval (secs.)", "Defines the interval for the ground check", _control.Creature.Environment.SurfaceHandler.GroundScanInterval, 0.25f, 0, ref _control.Creature.Environment.SurfaceHandler.GroundScanIntervalMaximum, 1, Info.ENVIROMENT_SURFACE_SCAN_INTERVAL);
for (int i = 0; i < _control.Creature.Environment.SurfaceHandler.Surfaces.Count; ++i)
{
// HEADER BEGIN
SurfaceDataObject _surface = _control.Creature.Environment.SurfaceHandler.Surfaces[i];
if (_surface.Name == "")
{
_surface.Name = "Surface Rule #" + (i + 1);
}
ICEEditorLayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(_surface.Enabled == false);
_surface.Foldout = ICEEditorLayout.Foldout(_surface.Foldout, _surface.Name);
EditorGUI.EndDisabledGroup();
if (ICEEditorLayout.ListDeleteButton <SurfaceDataObject>(_control.Creature.Environment.SurfaceHandler.Surfaces, _surface, "Removes the selected surface rule"))
{
if (_control.Creature.Environment.SurfaceHandler.Surfaces.Count == 0)
{
_control.Creature.Environment.SurfaceHandler.Enabled = false;
}
return;
}
GUILayout.Space(5);
if (ICEEditorLayout.ListUpDownButtons <SurfaceDataObject>(_control.Creature.Environment.SurfaceHandler.Surfaces, i))
{
return;
}
_surface.Enabled = ICEEditorLayout.EnableButton("Activates/deactivates the the selected surfaces rule", _surface.Enabled);
ICEEditorLayout.EndHorizontal(Info.ENVIROMENT_SURFACE_RULE);
// HEADER END
if (_surface.Foldout)
{
EditorGUI.BeginDisabledGroup(_surface.Enabled == false);
ICEEditorLayout.BeginHorizontal();
_surface.Name = ICEEditorLayout.Text("Name", "", _surface.Name);
if (ICEEditorLayout.ResetButtonSmall())
{
_surface.Name = "";
}
ICEEditorLayout.EndHorizontal(Info.ENVIROMENT_SURFACE_RULE_NAME);
//_surface.Interval = ICEEditorLayout.DefaultSlider( "Interval", "", _surface.Interval, 0.005f, 0, 30, 1, Info.ENVIROMENT_SURFACE_RULE_INTERVAL );
//ICEEditorStyle.SplitterByIndent( EditorGUI.indentLevel + 1 );
DrawEnvironmentTextures(_surface);
ICEEditorLayout.Label("Procedures", true, Info.ENVIROMENT_SURFACE_RULE_PROCEDURES);
EditorGUI.indentLevel++;
EditorGUI.BeginDisabledGroup(_surface.Textures.Count == 0);
_surface.UseBehaviourModeKey = ICEEditorLayout.Toggle("Behaviour", "", _surface.UseBehaviourModeKey, Info.ENVIROMENT_SURFACE_BEHAVIOUR);
if (_surface.UseBehaviourModeKey)
{
EditorGUI.indentLevel++;
_surface.BehaviourModeKey = BehaviourEditor.BehaviourSelect(_control, "Behaviour", "Reaction to this impact", _surface.BehaviourModeKey, "SURFACE_" + _surface.Name.ToUpper(), Info.ENVIROMENT_SURFACE_BEHAVIOUR);
EditorGUI.indentLevel--;
}
EditorHeaderType _header = EditorHeaderType.TOGGLE;
CreatureObjectEditor.DrawInfluenceObject(_surface.Influences, _header, _control.Creature.Status.UseAdvanced, _control.Creature.Status.InitialDurabilityMax, Info.ENVIROMENT_SURFACE_INFLUENCES);
CreatureObjectEditor.DrawFootstepAudioObject(_surface.Footsteps, _header, Info.ENVIROMENT_SURFACE_AUDIO);
CreatureObjectEditor.DrawAudioObject(_surface.Audio, _header, Info.ENVIROMENT_SURFACE_AUDIO);
CreatureObjectEditor.DrawEffectObject(_control, _surface.Effect, _header, Info.ENVIROMENT_SURFACE_EFFECT);
EditorGUI.EndDisabledGroup();
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
EditorGUI.EndDisabledGroup();
ICEEditorStyle.SplitterByIndent(EditorGUI.indentLevel + 1);
}
}
ICEEditorLayout.DrawListAddLine <SurfaceDataObject>(_control.Creature.Environment.SurfaceHandler.Surfaces, new SurfaceDataObject(), false, "Add Surface Rule");
WorldObjectEditor.EndObjectContent();
// CONTENT END
}
private static void DrawEnvironmentCollisionSettings(ICECreatureControl _control)
{
// IMPACT HEADER BEGIN
ICEEditorLayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(_control.Creature.Environment.CollisionHandler.Enabled == false);
WorldObjectEditor.DrawObjectHeaderLine(ref _control.Creature.Environment.CollisionHandler.Enabled, ref _control.Creature.Environment.CollisionHandler.Foldout, EditorHeaderType.FOLDOUT_BOLD, "Collisions", "");
_control.Creature.Environment.CollisionHandler.AllowChildCollisions = ICEEditorLayout.CheckButtonSmall("ACC", "Allow Child Collisions", _control.Creature.Environment.CollisionHandler.AllowChildCollisions);
_control.Creature.Environment.CollisionHandler.UseCollider = ICEEditorLayout.CheckButtonSmall("COL", "Use Collider events", _control.Creature.Environment.CollisionHandler.UseCollider);
_control.Creature.Environment.CollisionHandler.UseTrigger = ICEEditorLayout.CheckButtonSmall("TRI", "Use Trigger events", _control.Creature.Environment.CollisionHandler.UseTrigger);
EditorGUI.BeginDisabledGroup(_control.GetComponent <CharacterController>() == null);
_control.Creature.Environment.CollisionHandler.UseCharacterController = ICEEditorLayout.CheckButtonSmall("CON", "Use CharacterController events", _control.Creature.Environment.CollisionHandler.UseCharacterController);
EditorGUI.EndDisabledGroup();
GUILayout.Space(5);
EditorGUI.EndDisabledGroup();
if (ICEEditorLayout.AddButton("Adds a new collision rule"))
{
_control.Creature.Environment.CollisionHandler.Collisions.Add(new CollisionDataObject());
_control.Creature.Environment.CollisionHandler.Enabled = true;
}
if (ICEEditorLayout.SaveButton("Saves collision data to file"))
{
CreatureEditorIO.SaveEnvironmentCollisionToFile(_control.Creature.Environment.CollisionHandler, _control.gameObject.name);
}
if (ICEEditorLayout.LoadButton("Loads collision data to file"))
{
_control.Creature.Environment.CollisionHandler = CreatureEditorIO.LoadEnvironmentCollisionFromFile(_control.Creature.Environment.CollisionHandler);
}
if (ICEEditorLayout.ResetButton("Resets the collision data"))
{
_control.Creature.Environment.CollisionHandler.Reset();
}
_control.Creature.Environment.CollisionHandler.Enabled = ICEEditorLayout.EnableButton(_control.Creature.Environment.CollisionHandler.Enabled);
ICEEditorLayout.EndHorizontal(Info.ENVIROMENT_COLLISION);
// IMPACT HEADER END
if (_control.Creature.Environment.CollisionHandler.Enabled == true && _control.Creature.Environment.CollisionHandler.Collisions.Count == 0)
{
_control.Creature.Environment.CollisionHandler.Collisions.Add(new CollisionDataObject());
_control.Creature.Environment.CollisionHandler.Foldout = true;
}
// CONTENT BEGIN
if (WorldObjectEditor.BeginObjectContentOrReturn(EditorHeaderType.FOLDOUT_BOLD, _control.Creature.Environment.CollisionHandler))
{
return;
}
for (int i = 0; i < _control.Creature.Environment.CollisionHandler.Collisions.Count; i++)
{
CollisionDataObject _collision = _control.Creature.Environment.CollisionHandler.Collisions[i];
if (_collision != null)
{
if (_collision.Name.Trim() == "")
{
_collision.Name = "Collision Rule #" + (i + 1);
}
// IMPACT RULE HEADER BEGIN
ICEEditorLayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(_collision.Enabled == false);
_collision.Foldout = ICEEditorLayout.Foldout(_collision.Foldout, _collision.Name);
EditorGUI.EndDisabledGroup();
if (ICEEditorLayout.ListDeleteButton <CollisionDataObject>(_control.Creature.Environment.CollisionHandler.Collisions, _collision, "Removes the selected collision rule"))
{
if (_control.Creature.Environment.CollisionHandler.Collisions.Count == 0)
{
_control.Creature.Environment.CollisionHandler.Enabled = false;
}
return;
}
GUILayout.Space(5);
if (ICEEditorLayout.ListUpDownButtons <CollisionDataObject>(_control.Creature.Environment.CollisionHandler.Collisions, i))
{
return;
}
_collision.Enabled = ICEEditorLayout.EnableButton("Activates/deactivates the selected collision rule", _collision.Enabled);
ICEEditorLayout.EndHorizontal(Info.ENVIROMENT_COLLISION_RULE);
// IMPACT RULE HEADER END
// IMPACT RULE CONTENT BEGIN
if (_collision.Foldout)
{
EditorGUI.BeginDisabledGroup(_collision.Enabled == false);
ICEEditorLayout.BeginHorizontal();
_collision.Name = ICEEditorLayout.Text("Name", "", _collision.Name);
if (ICEEditorLayout.ResetButtonSmall())
{
_collision.Name = "";
}
ICEEditorLayout.EndHorizontal(Info.ENVIROMENT_COLLISION_RULE_NAME);
EditorGUILayout.Separator();
ICEEditorLayout.BeginHorizontal();
ICEEditorLayout.Label("Conditions", true);
_collision.UseTag = ICEEditorLayout.CheckButtonMiddle("TAG", "", _collision.UseTag);
_collision.UseLayer = ICEEditorLayout.CheckButtonMiddle("LAYER", "", _collision.UseLayer);
_collision.UseBodyPart = ICEEditorLayout.CheckButtonMiddle("COLLIDER", "", _collision.UseBodyPart);
ICEEditorLayout.EndHorizontal(Info.ENVIROMENT_COLLISION_RULE_CONDITIONS);
EditorGUI.indentLevel++;
if (_collision.UseLayer)
{
_collision.Layer = ICEEditorLayout.Layer("Layer", "Desired collision layer", _collision.Layer, Info.ENVIROMENT_COLLISION_RULE_LAYER);
}
if (_collision.UseTag)
{
_collision.Tag = ICEEditorLayout.Tag("Tag", "Desired collision tag", _collision.Tag, Info.ENVIROMENT_COLLISION_RULE_TAG);
}
if (_collision.UseBodyPart)
{
_collision.BodyPart = ICEEditorLayout.ColliderPopup(_control.gameObject, "Body Part", "Desired body part", _collision.BodyPart, Info.ENVIROMENT_COLLISION_RULE_BODYPART);
}
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
ICEEditorLayout.Label("Procedures", true, Info.ENVIROMENT_COLLISION_RULE_PROCEDURES);
EditorGUI.indentLevel++;
_collision.UseBehaviourModeKey = ICEEditorLayout.Toggle("Behaviour", "", _collision.UseBehaviourModeKey, Info.ENVIROMENT_COLLISION_BEHAVIOUR);
if (_collision.UseBehaviourModeKey)
{
EditorGUI.indentLevel++;
_collision.BehaviourModeKey = BehaviourEditor.BehaviourSelect(_control, "Behaviour", "Reaction to this impact", _collision.BehaviourModeKey, "COLLISION_" + _collision.Name.ToUpper(), Info.ENVIROMENT_COLLISION_BEHAVIOUR);
EditorGUI.indentLevel--;
}
EditorHeaderType _header = EditorHeaderType.TOGGLE;
CreatureObjectEditor.DrawInfluenceObject(_collision.Influences, _header, _control.Creature.Status.UseAdvanced, _control.Creature.Status.InitialDurabilityMax, Info.ENVIROMENT_COLLISION_INFLUENCES);
//CreatureObjectEditor.DrawAudioObject( _collision.Audio, _header, Info.ENVIROMENT_COLLISION_AUDIO );
//CreatureObjectEditor.DrawEffectObject( _control, _collision.Effect, _header, Info.ENVIROMENT_COLLISION_EFFECT );
//_impact.ForceInteraction = EditorGUILayout.Toggle("Force Interaction", _impact.ForceInteraction );
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
EditorGUI.EndDisabledGroup();
ICEEditorStyle.SplitterByIndent(EditorGUI.indentLevel + 1);
}
// IMPACT RULE CONTENT END
}
}
ICEEditorLayout.DrawListAddLine <CollisionDataObject>(_control.Creature.Environment.CollisionHandler.Collisions, new CollisionDataObject(), false, "Add Collision Rule");
WorldObjectEditor.EndObjectContent();
// CONTENT END
}
private static void DrawReferenceGroup(ICECreatureRegister _register, ReferenceGroupObject _obj)
{
if (_obj == null || _obj.Foldout == false)
{
return;
}
EditorGUI.BeginDisabledGroup(_obj.Enabled == false);
// BEGIN OBJECT
ICEEditorLayout.BeginHorizontal();
_obj.ReferenceGameObject = (GameObject)EditorGUILayout.ObjectField("Reference Object", _obj.ReferenceGameObject, typeof(GameObject), true);
EditorGUI.BeginDisabledGroup(_obj.ReferenceGameObject == null);
if (_obj.ReferenceGameObject != null)
{
ICEEditorLayout.ButtonDisplayObject(_obj.ReferenceGameObject.transform.position);
}
else
{
ICEEditorLayout.ButtonDisplayObject(Vector3.zero);
}
ICEEditorLayout.ButtonSelectObject(_obj.ReferenceGameObject, ICEEditorStyle.CMDButtonDouble);
//_obj.GroupByTag = ICEEditorLayout.ButtonCheck( "TAG", "Allows to find a group in addition to its name also by its tag.", _obj.GroupByTag, ICEEditorStyle.CMDButtonDouble );
_obj.GroupByTag = false;
_obj.UseGroupParent = ICEEditorLayout.CheckButtonMiddle("GROUP", "Assorts instances to the defined Hierarchy Group", _obj.UseGroupParent);
EditorGUI.EndDisabledGroup();
ICEEditorLayout.EndHorizontal(Info.REGISTER_REFERENCE_OBJECT);
// END OBJECT
//_obj.UseHierarchyGroupObject = ICEEditorLayout.Toggle( "Use Hierarchy Group", "", _obj.UseHierarchyGroupObject, Info.REGISTER_REFERENCE_OBJECT_POOL_GROUP_USE );
if (_obj.UseGroupParent)
{
EditorGUI.indentLevel++;
ICEEditorLayout.BeginHorizontal();
_obj.CustomGroupParent = (GameObject)EditorGUILayout.ObjectField("Custom Hierarchy Group", _obj.CustomGroupParent, typeof(GameObject), true);
ICEEditorLayout.EndHorizontal(Info.REGISTER_REFERENCE_OBJECT_POOL_GROUP_CUSTOM);
if (_obj.CustomGroupParent == null)
{
EditorGUILayout.HelpBox(Info.REGISTER_REFERENCE_OBJECT_POOL_GROUP_INFO, MessageType.Info);
}
EditorGUI.indentLevel--;
}
// BEGIN POOL MANAGEMENT
if (_obj.PoolManagementEnabled == true && _register.UsePoolManagement == true)
{
// PLAYER
if (_obj.EntityType == EntityClassType.Player)
{
_obj.MaxCoexistingObjects = 1;
_obj.UseInitialSpawn = true;
_obj.InitialSpawnPriority = 0;
_obj.UseRandomization = false;
_obj.SpawnWaveMin = 1;
_obj.SpawnWaveMax = 1;
_obj.UseSoftRespawn = true;
ICEEditorLayout.MinMaxRandomDefaultSlider("Spawn Interval (min/max)", "", ref _obj.MinSpawnInterval, ref _obj.MaxSpawnInterval, 0, ref _obj.RespawnIntervalMax, 0, 0, 0.25f, 30, Info.REGISTER_REFERENCE_OBJECT_POOL_SPAWN_INTERVAL);
if (_obj.MinSpawnInterval > 0 && _obj.ReferenceGameObject != null && _obj.ReferenceGameObject.GetComponentsInChildren <Camera>() != null)
{
//Debug.Log( "test" );
}
}
// CREATURES AND OTHER OBJECTS
else
{
ICEEditorLayout.BeginHorizontal();
float _maximum = _obj.MaxCoexistingObjectsMaximum;
_obj.MaxCoexistingObjects = (int)ICEEditorLayout.MaxDefaultSlider("Max. Coexistent Objects (" + _obj.ActiveObjectsCount + ")", "Specifies the limit of coexistent objects", _obj.MaxCoexistingObjects, 1, 0, ref _maximum, 25, "");
_obj.MaxCoexistingObjectsMaximum = (int)_maximum;
_obj.UseMaxSpawnCycles = ICEEditorLayout.CheckButtonSmall("MAX", "Specifies the total number of objects", _obj.UseMaxSpawnCycles);
_obj.UseInitialSpawn = ICEEditorLayout.CheckButtonMiddle("INITIAL", "Spawns all instances on start according to the given priority", _obj.UseInitialSpawn);
ICEEditorLayout.EndHorizontal(Info.REGISTER_REFERENCE_OBJECT_POOL_SPAWN_MAX);
if (_obj.UseMaxSpawnCycles)
{
if (_obj.MaxSpawnCycles < _obj.MaxCoexistingObjects)
{
_obj.MaxSpawnCycles = _obj.MaxCoexistingObjects;
}
if (_obj.MaxSpawnCyclesMaximum < _obj.MaxCoexistingObjectsMaximum)
{
_obj.MaxSpawnCyclesMaximum = _obj.MaxCoexistingObjectsMaximum;
}
float _max_spawn_cycles = _obj.MaxSpawnCyclesMaximum;
_obj.MaxSpawnCycles = (int)ICEEditorLayout.MaxDefaultSlider("Max. Spawn Cycles (" + _obj.TotalSpawnCycles + ")", "", _obj.MaxSpawnCycles, 1, _obj.MaxCoexistingObjects, ref _max_spawn_cycles, 25, "");
_obj.MaxSpawnCyclesMaximum = (int)_max_spawn_cycles;
}
if (_obj.UseInitialSpawn)
{
EditorGUI.indentLevel++;
_obj.InitialSpawnPriority = (int)ICEEditorLayout.DefaultSlider("Initial Spawn Priority", "", _obj.InitialSpawnPriority, 1, 0, 100, 0, Info.REGISTER_REFERENCE_OBJECT_POOL_SPAWN_PRIORITY);
EditorGUI.indentLevel--;
}
ICEEditorLayout.BeginHorizontal();
ICEEditorLayout.MinMaxRandomDefaultSlider("Spawn Interval (min/max)", "", ref _obj.MinSpawnInterval, ref _obj.MaxSpawnInterval, 0, ref _obj.RespawnIntervalMax, 0, 0, 0.25f, 30);
_obj.UseSpawnWave = ICEEditorLayout.CheckButton("WAVE", "", _obj.UseSpawnWave, ICEEditorStyle.ButtonMiddle);
ICEEditorLayout.EndHorizontal(Info.REGISTER_REFERENCE_OBJECT_POOL_SPAWN_INTERVAL);
if (_obj.UseSpawnWave)
{
EditorGUI.indentLevel++;
ICEEditorLayout.MinMaxRandomDefaultSlider("Wave Size (min/max)", "Amount per Wave", ref _obj.SpawnWaveMin, ref _obj.SpawnWaveMax, 1, ref _obj.SpawnWaveMaximum, 1, 5, 30, Info.REGISTER_REFERENCE_OBJECT_POOL_SPAWN_WAVE);
EditorGUI.indentLevel--;
}
EditorGUILayout.Separator();
_obj.UseRandomization = ICEEditorLayout.Toggle("Spawn Randomization", "", _obj.UseRandomization, Info.REGISTER_REFERENCE_OBJECT_POOL_RANDOM_SIZE);
if (_obj.UseRandomization)
{
EditorGUI.indentLevel++;
ICEEditorLayout.MinMaxRandomDefaultSlider("Random Size Variance (min/max)", "", ref _obj.RandomSizeMin, ref _obj.RandomSizeMax, -1, 1, 0, 0, 0.025f, 30, Info.REGISTER_REFERENCE_OBJECT_POOL_RANDOM_SIZE_VARIANCE);
EditorGUI.indentLevel--;
EditorGUILayout.Separator();
}
WorldObjectEditor.DrawCullingOptionsObject(_register, _obj.CullingOptions, EditorHeaderType.TOGGLE, Info.REGISTER_REFERENCE_OBJECT_POOL_SPAWN_CONDITIONS, "Spawn Conditions");
}
ICEEditorLayout.BeginHorizontal();
ICEEditorLayout.Label("Spawn Areas", false);
if (ICEEditorLayout.AddButton("Adds a new spawn point entry"))
{
_obj.SpawnPoints.Add(new SpawnPointObject());
}
ICEEditorLayout.EndHorizontal(Info.REGISTER_REFERENCE_OBJECT_SPAWN_POINTS);
EditorGUI.indentLevel++;
if (_obj.SpawnPoints.Count == 0)
{
if (_obj.EntityCreature != null)
{
_obj.SpawnPoints.Add(new SpawnPointObject(_obj.EntityCreature.Creature.Essentials.Target));
}
else if (_obj.ReferenceGameObject != null)
{
ICECreatureTargetAttribute _target = _obj.ReferenceGameObject.GetComponent <ICECreatureTargetAttribute>();
if (_target != null)
{
_obj.SpawnPoints.Add(new SpawnPointObject(_target.Target));
}
else
{
_obj.SpawnPoints.Add(new SpawnPointObject(_obj.ReferenceGameObject));
}
}
}
foreach (SpawnPointObject _point in _obj.SpawnPoints)
{
if (CreatureObjectEditor.DrawSpawnPointObject(_point, _obj.SpawnPoints, EditorHeaderType.FOLDOUT_ENABLED))
{
return;
}
}
EditorGUI.indentLevel--;
}
// END POOL MANAGEMENT
EditorGUI.EndDisabledGroup();
EditorGUILayout.Separator();
}
