public static void DelayFloatField(SerializedProperty o, GUIContent _title, GUIContent _width = null)
{
Rect size = GUILayoutUtility.GetRect(_title, GUI.skin.label);
float width = 0;
if (_width != null)
{
width = GUI.skin.label.CalcSize(_width).x;
}
else
{
width = GUI.skin.label.CalcSize(_title).x;
}
size.x += width + 0.5f;
size.width -= width;
if (o.hasMultipleDifferentValues)
{
EditorGUI.BeginProperty(size, new GUIContent(""), o);
int input = Random.Range(int.MinValue, int.MaxValue);
float v = EditorGUI.DelayedFloatField(size, input);
if (v != input)
{
o.floatValue = v;
}
EditorGUI.EndProperty();
}
else
{
o.floatValue = EditorGUI.DelayedFloatField(size, o.floatValue);
}
size.x -= width + 1.5f;
EditorGUI.LabelField(size, _title);
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(position, label, property);
var value = property.objectReferenceValue as SharedFloatSO;
if (value != null)
{
EditorGUI.BeginChangeCheck();
float totalWidth = position.width;
float positionX = position.x;
float ElementWidth = totalWidth * 0.9f;
EditorGUI.PropertyField(new Rect(positionX, position.y, ElementWidth, position.height), property, label, true);
positionX += ElementWidth;
ElementWidth = totalWidth * 0.1f;
var newValue = EditorGUI.DelayedFloatField(new Rect(positionX, position.y, ElementWidth, position.height), value.Value);
if (EditorGUI.EndChangeCheck())
{
value.Value = newValue;
}
}
else
{
EditorGUI.PropertyField(position, property, label, false);
}
EditorGUI.EndProperty();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (property.propertyType == SerializedPropertyType.Vector2)
{
Vector2 range = property.vector2Value;
float min = range.x;
float max = range.y;
MinMaxSliderAttribute attr = (MinMaxSliderAttribute)attribute;
EditorGUI.BeginChangeCheck();
Rect context = EditorGUI.PrefixLabel(position, label);
Rect[] cols = context.SplitLeft(50f);
min = EditorGUI.DelayedFloatField(cols[0], min);
cols = cols[1].SplitRight(50f);
EditorGUI.MinMaxSlider(cols[0], ref min, ref max, attr.min, attr.max);
max = EditorGUI.DelayedFloatField(cols[1], max);
if (EditorGUI.EndChangeCheck())
{
range.x = min;
range.y = max;
property.vector2Value = range;
}
}
else
{
EditorGUI.LabelField(position, label, "Use only with Vector2");
}
}
private void DrawPoint(Rect position, SerializedProperty property)
{
var isReadOnlyProp = property.FindPropertyRelative(ChronoPoint.kIsReadOnlyPropName);
var valueProp = property.FindPropertyRelative(ChronoPoint.kValuePropName);
bool isReadOnly = isReadOnlyProp != null
? isReadOnlyProp.boolValue
: false;
position.y += kHeightReduction * 0.5f;
position.height -= kHeightReduction;
float valueRectWidth = position.width - kValueRectWidth - kGapWidth - kMarginWidth;
var valueRect = new Rect(position)
{
width = kValueRectWidth,
x = position.x + kMarginWidth
};
var displayRect = new Rect(position)
{
width = valueRectWidth,
x = valueRect.x + kValueRectWidth + kGapWidth
};
using (var group = new EditorGUI.DisabledGroupScope(isReadOnly))
{
float value = valueProp.floatValue;
string displayValue = GetDisplayValue(value);
valueProp.floatValue = EditorGUI.DelayedFloatField(valueRect, GUIContent.none, value, _styles.chronoValueField);
EditorGUI.LabelField(displayRect, displayValue);
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var key = property.FindPropertyRelative("Key");
var value = property.FindPropertyRelative("Value");
var once = property.FindPropertyRelative("Once");
var priority = property.FindPropertyRelative("Priority");
EditorGUI.indentLevel++;
GUI.Box(position, "");
float width = position.width;
position.width = 30;
value.boolValue = EditorGUI.Toggle(position, "", value.boolValue);
position.x += position.width;
position.width = width - 200;
key.stringValue = EditorGUI.DelayedTextField(position, key.stringValue);
position.x += position.width + 5;
position.width = 50;
once.boolValue = GUI.Toggle(position, once.boolValue, new GUIContent("Once", "是否是一次性目标，若是一次性，则在完成目标后移除该目标"), "ButtonMid");
position.x += position.width - 10;
position.width = 120;
float lableWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 75;
priority.floatValue = EditorGUI.DelayedFloatField(position, new GUIContent("Priority", "优先级，越高越先执行"), priority.floatValue);
EditorGUIUtility.labelWidth = lableWidth;
EditorGUI.indentLevel--;
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("HP / Max HP");
var hpRect = GUILayoutUtility.GetRect(50, 20, EditorStyles.numberField);
EditorGUI.DelayedFloatField(hpRect, HPprop, GUIContent.none);
EditorGUILayout.LabelField("/", EditorStyles.miniLabel, miniButtonWidth);
hpRect = GUILayoutUtility.GetRect(50, 20, "TextField");
EditorGUI.DelayedFloatField(hpRect, maxHPprop.floatValue);
EditorGUILayout.EndHorizontal();
if (!HPprop.hasMultipleDifferentValues || !maxHPprop.hasMultipleDifferentValues)
{
ProgressBar(HPprop.floatValue / maxHPprop.floatValue, "HP");
}
RenderFieldWithButtons(ATTprop, "ATT");
RenderFieldWithButtons(DEFprop, "DEF");
//EditorGUILayout.PropertyField(dataProp, new GUIContent("Resistance"), true);
RenderListUI(dataProp, "Resistance");
serializedObject.ApplyModifiedProperties();
//EditorGUILayout.LabelField("The HP is" + _target.HP);
//DrawDefaultInspector();
}
private MinMax DrawMinMaxSlider(float minIn, float maxIn, float minLimit, float maxLimit, bool showDegrees = true)
{
//int holdindent = EditorGUI.indentLevel;
const float input1offset = 10;
float inputWidth = (holdindent < 2) ? (showDegrees ? 40f : 50f) : showDegrees ? 30f : 40f;
float degreeSpace = showDegrees ? 10f : 0;
GUIContent lbl = showDegrees ? new GUIContent("°") : GUIContent.none;
//float sliderwidth = fieldwidth - inputWidth + input1offset - PADDING * 2 - degreeSpace * 2;
float left = r.xMin;
float input1left = fieldleft - inputWidth - input1offset;
float input2left = rightinputsleft;
float sliderleft = fieldleft /*- input1offset + PADDING */ /*+ degreeSpace*/; // + fieldwidth + padding;
float sliderwidth = /*fieldwidth -*/ (input2left - fieldleft) - PADDING;
//EditorGUI.indentLevel = 0;
float minOut = EditorGUI.DelayedFloatField(new Rect(input1left, line, inputWidth, LINEHEIGHT), GUIContent.none, minIn, (GUIStyle)"MiniTextField");
float maxOut = EditorGUI.DelayedFloatField(new Rect(input2left, line, inputWidth, LINEHEIGHT), GUIContent.none, maxIn, (GUIStyle)"MiniTextField");
EditorGUI.LabelField(new Rect(input1left, line, inputWidth + degreeSpace, LINEHEIGHT), lbl, (GUIStyle)"RightLabel");
EditorGUI.LabelField(new Rect(input2left, line, inputWidth + degreeSpace, LINEHEIGHT), lbl, (GUIStyle)"RightLabel");
EditorGUI.MinMaxSlider(new Rect(sliderleft, line - 1, sliderwidth, LINEHEIGHT), ref minOut, ref maxOut, minLimit, maxLimit);
//EditorGUI.indentLevel = holdindent;
return(new MinMax()
{
min = minOut, max = maxOut
});
}
private MinMax DrawMinMaxSlider(float minIn, float maxIn, float minLimit, float maxLimit, bool showDegrees = true)
{
const float input1offset = 10;
float inputWidth = (holdindent < 2) ? (showDegrees ? 40f : 50f) : showDegrees ? 30f : 40f;
float degreeSpace = showDegrees ? 10f : 0;
GUIContent lbl = showDegrees ? new GUIContent("°") : GUIContent.none;
float left = r.xMin;
float input1left = fieldleft - inputWidth - input1offset;
float input2left = rightinputsleft;
float sliderleft = fieldleft;
float sliderwidth = (input2left - fieldleft) - PADDING;
float minOut = EditorGUI.DelayedFloatField(new Rect(input1left, line, inputWidth, LINEHEIGHT), GUIContent.none, minIn, MINI_TXT_FLD_STYLE);
float maxOut = EditorGUI.DelayedFloatField(new Rect(input2left, line, inputWidth, LINEHEIGHT), GUIContent.none, maxIn, MINI_TXT_FLD_STYLE);
EditorGUI.LabelField(new Rect(input1left, line, inputWidth + degreeSpace, LINEHEIGHT), lbl, (GUIStyle)"RightLabel");
EditorGUI.LabelField(new Rect(input2left, line, inputWidth + degreeSpace, LINEHEIGHT), lbl, (GUIStyle)"RightLabel");
EditorGUI.MinMaxSlider(new Rect(sliderleft, line - 1, sliderwidth, LINEHEIGHT), ref minOut, ref maxOut, minLimit, maxLimit);
return(new MinMax()
{
min = minOut, max = maxOut
});
}
/************************************************************************************************************************/
/// <summary>
/// Draws controls for <see cref="AnimancerNode.FadeSpeed"/> and <see cref="AnimancerNode.TargetWeight"/>.
/// </summary>
private void DoFadeDetailsGUI()
{
var area = AnimancerGUI.LayoutSingleLineRect(AnimancerGUI.SpacingMode.Before);
area = EditorGUI.IndentedRect(area);
var speedLabel = AnimancerGUI.GetNarrowText("Fade Speed");
var targetLabel = AnimancerGUI.GetNarrowText("Target Weight");
float speedWidth, weightWidth;
Rect speedRect, weightRect;
AnimancerGUI.SplitHorizontally(area, speedLabel, targetLabel,
out speedWidth, out weightWidth, out speedRect, out weightRect);
var labelWidth = EditorGUIUtility.labelWidth;
var indentLevel = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
EditorGUI.BeginChangeCheck();
// Fade Speed.
EditorGUIUtility.labelWidth = speedWidth;
Target.FadeSpeed = EditorGUI.DelayedFloatField(speedRect, speedLabel, Target.FadeSpeed);
if (AnimancerGUI.TryUseClickEvent(speedRect, 2))
{
Target.FadeSpeed = Target.FadeSpeed != 0 ?
0 :
Math.Abs(Target.Weight - Target.TargetWeight) / AnimancerPlayable.DefaultFadeDuration;
}
// Target Weight.
EditorGUIUtility.labelWidth = weightWidth;
Target.TargetWeight = EditorGUI.FloatField(weightRect, targetLabel, Target.TargetWeight);
if (AnimancerGUI.TryUseClickEvent(weightRect, 2))
{
if (Target.TargetWeight != Target.Weight)
{
Target.TargetWeight = Target.Weight;
}
else if (Target.TargetWeight != 1)
{
Target.TargetWeight = 1;
}
else
{
Target.TargetWeight = 0;
}
}
if (EditorGUI.EndChangeCheck() && Target.FadeSpeed != 0)
{
Target.StartFade(Target.TargetWeight, 1 / Target.FadeSpeed);
}
EditorGUI.indentLevel = indentLevel;
EditorGUIUtility.labelWidth = labelWidth;
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
Vec2AsRangeAttribute attr = attribute as Vec2AsRangeAttribute;
EditorGUI.BeginProperty(position, label, property);
Vector2 vec2 = property.vector2Value;
float min = Mathf.Min(vec2.x, vec2.y);
float max = Mathf.Max(vec2.x, vec2.y);
if (attr.Slider)
{
var sliderRect = position;
sliderRect.xMax -= 2 * FLOAT_WIDTH + PAD;
position.xMin = position.xMax - 2 * FLOAT_WIDTH;
EditorGUI.MinMaxSlider(sliderRect, label, ref min, ref max, attr.LowerBound, attr.UpperBound);
var mid = position.x + position.width / 2;
var rectA = position;
rectA.xMax = mid;
min = EditorGUI.DelayedFloatField(rectA, GUIContent.none, min);
var rectB = position;
rectB.xMin = mid;
if (!attr.HideMax)
{
max = EditorGUI.DelayedFloatField(rectB, GUIContent.none, max);
}
}
else
{
position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);
var mid = position.x + position.width / 2;
EditorGUIUtility.labelWidth = SOLO_LABEL_WIDTH;
var rectA = position;
rectA.xMax = mid;
min = EditorGUI.DelayedFloatField(rectA, "min", min);
var rectB = position;
rectB.xMin = mid;
if (!attr.HideMax)
{
max = EditorGUI.DelayedFloatField(rectB, "max", max);
}
EditorGUIUtility.labelWidth = 0;
}
Vector2 newVec2 = new Vector2(min, max);
if (newVec2 != vec2)
{
property.vector2Value = newVec2;
}
EditorGUI.EndProperty();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(position, label, property);
EditorGUI.indentLevel = 0;
position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), new GUIContent("Biome mapping"));
Undo.RecordObject(property.serializedObject.targetObject, "name");
EditorGUI.BeginChangeCheck();
float[] rectWidthPercents = new float[] { 0.0f, 0.1f, 0.2f, 0.3f, 0.5f, 0.6f, 0.8f, 1.0f };
string[] propertyNames = new string[] { "m_originClass", "m_targetClass", "m_failClass", "m_predicateType", "m_predicatePerlinScale", "m_predicateThresholdA", "m_predicateThresholdB" };
Rect[] rects = new Rect[rectWidthPercents.Length - 1];
SerializedProperty predciateTypeProperty = property.FindPropertyRelative(propertyNames[3]);
bool isPerlinBlend = !HeightmapBiomeFilter.IsBlendedExterior(predciateTypeProperty.intValue);
for (int i = 0; i < rects.Length; i++)
{
// for perlin blend function, skip drawing m_predicateThresholdA and m_predicateThresholdB. Just draw m_predicatePerlinScale
if (i > 4 && !isPerlinBlend)
{
continue;
}
float rectStartX = position.x + position.width * rectWidthPercents[i];
float rectWidth = position.width * (rectWidthPercents[i + 1] - rectWidthPercents[i]);
rects[i] = new Rect(rectStartX, position.y, rectWidth, position.height);
SerializedProperty propertyI = property.FindPropertyRelative(propertyNames[i]);
switch (i)
{
default:
case 0:
case 1:
case 2:
propertyI.intValue = EditorGUI.DelayedIntField(rects[i], propertyI.intValue);
break;
case 3:
propertyI.intValue = EditorGUI.Popup(rects[i], propertyI.intValue, HeightmapBiomeFilter.predicateTypes);
break;
case 4:
case 5:
case 6:
propertyI.floatValue = EditorGUI.DelayedFloatField(rects[i], propertyI.floatValue);
break;
}
}
EditorGUI.EndProperty();
property.serializedObject.ApplyModifiedProperties();
}
public void DelayedFloatField()
{
EditorGUI.BeginChangeCheck();
float num = EditorGUI.DelayedFloatField(rect, guiContent.text, serializedProperty.floatValue);
if (EditorGUI.EndChangeCheck())
{
serializedProperty.floatValue = num;
}
}
void DrawDelayedFloatProperty(MaterialProperty prop, GUIContent content)
{
Rect position = EditorGUILayout.GetControlRect();
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = prop.hasMixedValue;
float newValue = EditorGUI.DelayedFloatField(position, content, prop.floatValue);
EditorGUI.showMixedValue = false;
if (EditorGUI.EndChangeCheck())
prop.floatValue = newValue;
}
public void DrawProperties(SerializedObject toDraw, Rect rect)
{
Rect drawRect = new Rect(rect.position + new Vector2(2, 4), new Vector2(rect.width - 4, 0));
EditorGUI.LabelField(new Rect(drawRect.position, new Vector2(drawRect.width, 24)), toDraw.targetObject.name + ": " + toDraw.targetObject.GetType());
drawRect = new Rect(drawRect.position + new Vector2(0, 32), drawRect.size);
toDraw.Update();
var obj = toDraw.GetIterator();
if (obj.Next(true))
{
do
{
if (obj.propertyPath != "m_ObjectHideFlags")
{
if (obj.propertyType == SerializedPropertyType.Integer)
{
EditorGUI.LabelField(new Rect(drawRect.position, new Vector2(drawRect.width, 24)), obj.displayName + ":");
obj.intValue = EditorGUI.DelayedIntField(new Rect(drawRect.position + new Vector2(0, 24), new Vector2(drawRect.width, 19)), obj.intValue);
drawRect = new Rect(drawRect.position + new Vector2(0, 48), drawRect.size);
}
else if (obj.propertyType == SerializedPropertyType.Float)
{
EditorGUI.LabelField(new Rect(drawRect.position, new Vector2(drawRect.width, 24)), obj.displayName + ":");
obj.floatValue = EditorGUI.DelayedFloatField(new Rect(drawRect.position + new Vector2(0, 24), new Vector2(drawRect.width, 19)), obj.floatValue);
drawRect = new Rect(drawRect.position + new Vector2(0, 48), drawRect.size);
}
else if (obj.propertyType == SerializedPropertyType.Boolean)
{
obj.boolValue = EditorGUI.Toggle(new Rect(drawRect.position, new Vector2(32, 24)), obj.boolValue);
EditorGUI.LabelField(new Rect(drawRect.position + new Vector2(24, 0), new Vector2(drawRect.width - 32, 24)), obj.displayName);
drawRect = new Rect(drawRect.position + new Vector2(0, 48), drawRect.size);
}
else if (obj.propertyType == SerializedPropertyType.Color)
{
EditorGUI.LabelField(new Rect(drawRect.position, new Vector2(drawRect.width, 24)), obj.displayName + ":");
obj.colorValue = EditorGUI.ColorField(new Rect(drawRect.position + new Vector2(0, 24), new Vector2(drawRect.width, 24)), obj.colorValue);
drawRect = new Rect(drawRect.position + new Vector2(0, 48), drawRect.size);
}
else if (obj.propertyType == SerializedPropertyType.Vector3)
{
obj.vector3Value = EditorGUI.Vector3Field(new Rect(drawRect.position, new Vector2(drawRect.width, 28)), obj.displayName, obj.vector3Value);
drawRect = new Rect(drawRect.position + new Vector2(0, 36), drawRect.size);
}
else
{
}
}
//EditorGUI.ObjectField(new Rect(rect.position, new Vector2(rect.width, 64)), ref1test, typeof(Component));
//EditorGUI.FloatField(new Rect(rect.position + new Vector2(0, 128), new Vector2(rect.width, 64)), ref3test);
} while (obj.NextVisible(false));
}
toDraw.ApplyModifiedProperties();
}
protected float DrawPerLevelGain(float startX, float startY, LevelProgressionStats stats)
{
string text = "Stats Gain Per Level " + (!foldPerLevelGain ? "(show):" : "(hide):");
foldPerLevelGain = EditorGUI.Foldout(new Rect(startX, startY, width, height), foldPerLevelGain, text, foldoutStyle);
if (foldPerLevelGain)
{
cont = new GUIContent(" - HitPoint:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.hitPointGain = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, widthS, height), stats.hitPointGain);
cont = new GUIContent(" - HitPoint Regen:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.hitPointRegenGain = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, widthS, height), stats.hitPointRegenGain);
startY += 5;
cont = new GUIContent(" - Energy:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.energyGain = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, widthS, height), stats.energyGain);
cont = new GUIContent(" - Energy Regen:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.energyRegenGain = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, widthS, height), stats.energyRegenGain);
startY += 5;
cont = new GUIContent(" - Speed Multiplier:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.speedMulGain = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, widthS, height), stats.speedMulGain);
startY += 5;
cont = new GUIContent(" - Damage Multiplier:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.dmgMulGain = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, widthS, height), stats.dmgMulGain);
cont = new GUIContent(" - Critical Chance Mul.:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.critChanceMulGain = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, widthS, height), stats.critChanceMulGain);
cont = new GUIContent(" - Critical Multiplier Mul.:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.critMultiplierMulGain = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, widthS, height), stats.critMultiplierMulGain);
startY += 10;
cont = new GUIContent(" - Perk Currency:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.perkCurrencyGain = EditorGUI.DelayedIntField(new Rect(startX + spaceX, startY, widthS, height), stats.perkCurrencyGain);
}
return(startY);
}
private float DrawExpListGenerator(float startX, float startY, LevelProgressionStats stats)
{
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), "Generate Exp List:", headerStyle);
cont = new GUIContent(" - Sum Recursively:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.sumRecursively = EditorGUI.Toggle(new Rect(startX + spaceX, startY, widthS, height), stats.sumRecursively);
cont = new GUIContent(" - Increment Rate:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.expTHM = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, widthS, height), stats.expTHM);
cont = new GUIContent(" - Starting Value:", "");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
stats.expTHC = EditorGUI.DelayedIntField(new Rect(startX + spaceX, startY, widthS, height), stats.expTHC);
if (GUI.Button(new Rect(startX + 15, startY += spaceY + 2, widthS - 5, height + 2), "Reset"))
{
stats.sumRecursively = stats.sumRecursively_Cached;
stats.expTHM = stats.expTHM_Cached;
stats.expTHC = stats.expTHC_Cached;
}
bool regenNeeded = stats.sumRecursively != stats.sumRecursively_Cached;
regenNeeded = regenNeeded || stats.expTHM != stats.expTHM_Cached;
regenNeeded = regenNeeded || stats.expTHC != stats.expTHC_Cached;
regenNeeded = regenNeeded || stats.expThresholdList.Count != stats.levelCap;
if (regenNeeded)
{
GUI.color = new Color(0, 1f, 1f, 1f);
}
if (GUI.Button(new Rect(startX + 10 + widthS, startY, spaceX + 5 - 15, height + 2), "Generate Exp"))
{
stats.expThresholdList = PlayerProgression.GenerateExpTH(stats.sumRecursively, stats.expTHM, stats.expTHC, stats.levelCap);
stats.sumRecursively_Cached = stats.sumRecursively;
stats.expTHM_Cached = stats.expTHM;
stats.expTHC_Cached = stats.expTHC;
}
string textRS = stats.sumRecursively ? "Σ(" : "";
string textRE = stats.sumRecursively ? ")" : "";
cont = new GUIContent("exp = " + textRS + "(" + stats.expTHM + "*lvl)+" + stats.expTHC + textRE, "The formula used to generate current exp list");
//cont=new GUIContent(" - Starting Value:", "");
EditorGUI.LabelField(new Rect(startX + spaceX + width - 80, startY, width * 2, height), cont);
GUI.color = Color.white;
return(startY);
}
private static void DrawGUI(Rect position, SerializedProperty minProperty, SerializedProperty maxProperty, bool delayed)
{
position.height = EditorGUIUtility.singleLineHeight;
const float spacing = 2;
const float labelWidth = 28;
float totalWidth = position.width;
float fieldWith = totalWidth / 2 - spacing / 2 - labelWidth;
using (EditorGUI.PropertyScope propertyScope = new EditorGUI.PropertyScope(position, new GUIContent(nameof(FloatRange.Min)), minProperty))
{
position.width = labelWidth;
EditorGUI.LabelField(position, propertyScope.content);
position.x += position.width;
position.width = fieldWith;
using (EditorGUI.ChangeCheckScope changeCheckScope = new EditorGUI.ChangeCheckScope())
{
float value = delayed
? EditorGUI.DelayedFloatField(position, minProperty.floatValue)
: EditorGUI.FloatField(position, minProperty.floatValue);
if (changeCheckScope.changed)
{
minProperty.floatValue = value;
maxProperty.floatValue = Mathf.Max(value, maxProperty.floatValue);
}
}
}
using (EditorGUI.PropertyScope propertyScope = new EditorGUI.PropertyScope(position, new GUIContent(nameof(FloatRange.Max)), maxProperty))
{
position.x += position.width + spacing;
position.width = labelWidth;
EditorGUI.LabelField(position, propertyScope.content);
position.x += position.width;
position.width = fieldWith;
using (EditorGUI.ChangeCheckScope changeCheckScope = new EditorGUI.ChangeCheckScope())
{
float value = delayed
? EditorGUI.DelayedFloatField(position, maxProperty.floatValue)
: EditorGUI.FloatField(position, maxProperty.floatValue);
if (changeCheckScope.changed)
{
maxProperty.floatValue = Mathf.Max(value, minProperty.floatValue);
}
}
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
label = EditorGUI.BeginProperty(position, label, property);
position = EditorGUI.PrefixLabel(position, label);
SerializedProperty minProp = property.FindPropertyRelative("min");
SerializedProperty maxProp = property.FindPropertyRelative("max");
float min = minProp.floatValue;
float max = maxProp.floatValue;
float rangeMin = 0;
float rangeMax = 1;
var ranges = (MinMaxRangeAttribute[])fieldInfo.GetCustomAttributes(typeof(MinMaxRangeAttribute), true);
if (ranges.Length > 0)
{
rangeMin = ranges[0].Min;
rangeMax = ranges[0].Max;
}
EditorGUI.BeginChangeCheck();
const float floatFieldRectWidth = 50f;
// Min value
var minFloatFieldRect = new Rect(position);
minFloatFieldRect.width = floatFieldRectWidth;
min = EditorGUI.DelayedFloatField(minFloatFieldRect, min);
min = Mathf.Min(min, max);
position.xMin += floatFieldRectWidth + 5;
// Max value
var maxFloatFieldRect = new Rect(position);
maxFloatFieldRect.xMin = maxFloatFieldRect.xMax - floatFieldRectWidth;
max = EditorGUI.DelayedFloatField(maxFloatFieldRect, max);
max = Mathf.Max(min, max);
position.xMax -= floatFieldRectWidth + 5;
//Slider
EditorGUI.MinMaxSlider(position, ref min, ref max, rangeMin, rangeMax);
if (EditorGUI.EndChangeCheck())
{
minProp.floatValue = min;
maxProp.floatValue = max;
}
EditorGUI.EndProperty();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
// Store min-max sub-properties for ease of use
SerializedProperty min = property.FindPropertyRelative("_min");
SerializedProperty max = property.FindPropertyRelative("_max");
// Put in the prefix label
position = EditorGUI.PrefixLabel(position, label);
// Store the old indent
int oldIndent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
// Build a single-line layout where the float editors stretch and the labels stay at the same width
Layout.Builder builder = new Layout.Builder();
builder.PushChild(LayoutChild.Width(LayoutSize.Exact(35f)));
builder.PushChild(LayoutChild.Width(LayoutSize.RatioOfRemainder(0.5f), LayoutMargin.Right(5f)));
builder.PushChild(LayoutChild.Width(LayoutSize.Exact(35f)));
builder.PushChild(LayoutChild.Width(LayoutSize.RatioOfRemainder(0.5f)));
Layout layout = builder.Compile(position);
// Create the min label
EditorGUI.LabelField(layout.Next(), new GUIContent("Min:"));
// Create the min editor
EditorGUI.BeginChangeCheck();
min.floatValue = EditorGUI.DelayedFloatField(layout.Next(), min.floatValue);
// If the max was modified, ensure that the max is not smaller than the new min
if (EditorGUI.EndChangeCheck())
{
max.floatValue = Mathf.Max(min.floatValue, max.floatValue);
}
// Create the max label
EditorGUI.LabelField(layout.Next(), new GUIContent("Max:"));
// Create the max editor
EditorGUI.BeginChangeCheck();
max.floatValue = EditorGUI.DelayedFloatField(layout.Next(), max.floatValue);
// If the max was modified, ensure that the min is not bigger than the new max
if (EditorGUI.EndChangeCheck())
{
min.floatValue = Mathf.Min(min.floatValue, max.floatValue);
}
// Restore indent level
EditorGUI.indentLevel = oldIndent;
}
public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
{
var mp = prop.FindPropertyRelative("min");
var np = prop.FindPropertyRelative("max");
var mm = attribute as MinMaxAttribute;
if (mp != null && np != null && mm != null)
{
var oldColor = GUI.color;
if (mm.colorize)
{
GUI.color = ColorizeDrawer.GetColor(prop.propertyPath);
}
int i = EditorGUI.indentLevel;
float mv = mp.floatValue;
float nv = np.floatValue;
float dx1 = EditorGUIUtility.fieldWidth * 2 + Mathf.Clamp01(i) * 9;
float dx2 = EditorGUIUtility.fieldWidth * 2 + (i - 1) * 9;
Rect r = pos;
r.width = r.width - dx1;
EditorGUI.MinMaxSlider(
new GUIContent(ObjectNames.NicifyVariableName(prop.name)), r,
ref mv, ref nv, mm.min, mm.max);
EditorGUI.indentLevel = 0;
r.x = pos.width - dx2 + i * 9 + 3;
r.width = EditorGUIUtility.fieldWidth;
var s = new GUIStyle(EditorStyles.numberField);
s.fixedWidth = EditorGUIUtility.fieldWidth;
mv = EditorGUI.DelayedFloatField(r, mv, s);
r.x += EditorGUIUtility.fieldWidth + 2;
nv = EditorGUI.DelayedFloatField(r, nv, s);
mp.floatValue = Mathf.Min(Mathf.Max(mv, mm.min), Mathf.Min(nv, mm.max));
np.floatValue = Mathf.Max(Mathf.Max(mv, mm.min), Mathf.Min(nv, mm.max));
EditorGUI.indentLevel = i;
if (mm.colorize)
{
GUI.color = oldColor;
}
}
}
private void DelayedPropertyField(Rect position, SerializedProperty property)
{
switch (property.propertyType)
{
case SerializedPropertyType.Integer:
property.intValue = EditorGUI.DelayedIntField(position, property.displayName, property.intValue);
break;
case SerializedPropertyType.Float:
property.floatValue = EditorGUI.DelayedFloatField(position, property.displayName, property.floatValue);
break;
default:
break;
}
}
/// <inheritdoc />
public override Rect Draw(Rect rect, object currentValue, Action <object> changeValueCallback, GUIContent label)
{
rect.height = EditorDrawingHelper.SingleLineHeight;
float value = (float)currentValue;
float newValue = EditorGUI.DelayedFloatField(rect, label, value);
// Rounding error can't take place here.
// ReSharper disable once CompareOfFloatsByEqualityOperator
if (value != newValue)
{
ChangeValue(() => newValue, () => value, changeValueCallback);
}
return(rect);
}
public static void RectOneline(Rect position, SerializedProperty property, GUIContent label)
{
var labelWidth = 0f;
if (!string.IsNullOrEmpty(label.text))
{
var labelRect = new Rect(position.x, position.y, EditorGUIUtility.labelWidth, position.height);
EditorGUI.LabelField(labelRect, label.text);
labelWidth = labelRect.width;
}
var perWidth = (position.width - labelWidth) / 4;
var x = position.x + labelWidth;
using (var check = new EditorGUI.ChangeCheckScope())
{
var charWidth = EditorStyles.label.CalcSize(new GUIContent("W")).x;
var xLabelRect = new Rect(x, position.y, 25f, position.height);
var xValueRect = new Rect(x + charWidth + 1, position.y, perWidth - charWidth - 1, position.height);
EditorGUI.LabelField(xLabelRect, "X");
var valX = EditorGUI.DelayedFloatField(xValueRect, property.rectValue.x);
x += perWidth;
var yLabelRect = new Rect(x, position.y, 25f, position.height);
var yValueRect = new Rect(x + charWidth + 1, position.y, perWidth - charWidth - 1, position.height);
EditorGUI.LabelField(yLabelRect, "Y");
var valY = EditorGUI.DelayedFloatField(yValueRect, property.rectValue.y);
x += perWidth;
var zLabelRect = new Rect(x, position.y, 30f, position.height);
var zValueRect = new Rect(x + charWidth + 1, position.y, perWidth - charWidth - 1, position.height);
EditorGUI.LabelField(zLabelRect, "W");
var valWidth = EditorGUI.DelayedFloatField(zValueRect, property.rectValue.width);
x += perWidth;
var wLabelRect = new Rect(x, position.y, 30f, position.height);
var wValueRect = new Rect(x + charWidth, position.y, perWidth - charWidth - 1, position.height);
EditorGUI.LabelField(wLabelRect, "H");
var valHeight = EditorGUI.DelayedFloatField(wValueRect, property.rectValue.height);
if (check.changed)
{
property.rectValue = new Rect(valX, valY, valWidth, valHeight);
}
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var minProp = property.FindPropertyRelative("Min");
var maxProp = property.FindPropertyRelative("Max");
var min = minProp.floatValue;
var max = maxProp.floatValue;
position = EditorGUI.PrefixLabel(position, label);
EditorGUI.MinMaxSlider(new Rect(position.x + width + 5, position.y, position.width - width - width - 10, position.height), ref min, ref max, 0f, 1f);
var newmin = EditorGUI.DelayedFloatField(new Rect(position.x, position.y, width, position.height), min);
if (newmin > max)
{
min = max;
}
else
{
min = newmin;
}
var right = new GUIStyle(GUI.skin.FindStyle("label"));
right.fontStyle = FontStyle.Normal;
right.alignment = TextAnchor.MiddleRight;
var newmax = EditorGUI.DelayedFloatField(new Rect(position.x + position.width - width, position.y, width, position.height), max);
if (newmax <= min)
{
max = min;
}
else
{
max = newmax;
}
minProp.floatValue = min;
maxProp.floatValue = max;
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
// Now draw the property as a Slider or an IntSlider based on whether it's a float or integer.
if (property.propertyType == SerializedPropertyType.Float)
{
EditorGUI.DelayedFloatField(position, property, label);
}
else if (property.propertyType == SerializedPropertyType.Integer)
{
EditorGUI.DelayedIntField(position, property, label);
}
else if (property.propertyType == SerializedPropertyType.String)
{
EditorGUI.DelayedTextField(position, property, label);
}
else
{
EditorGUI.LabelField(position, label.text, "Use MultiRange with float or int.");
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(position, label, property);
Rect rect = new Rect(position)
{
width = label.text.Length * DVariableDrawer.CHARACTER_WIDTH
};
EditorGUI.LabelField(rect, label);
rect.x += rect.width;
rect.width = 6f * DVariableDrawer.CHARACTER_WIDTH;
EditorGUI.LabelField(rect, "Priority");
rect.x += rect.width + DVariableDrawer.SPACE;
rect.width = 3 * DVariableDrawer.CHARACTER_WIDTH;
SerializedProperty priorityProperty = property.FindPropertyRelative("priority");
priorityProperty.intValue = EditorGUI.DelayedIntField(rect, priorityProperty.intValue);
rect.x += rect.width + DVariableDrawer.SPACE;
rect.width = 5 * DVariableDrawer.CHARACTER_WIDTH;
SerializedProperty typeProperty = property.FindPropertyRelative("type");
typeProperty.enumValueIndex = EditorGUI.Popup(rect, typeProperty.enumValueIndex, typeProperty.enumDisplayNames);
rect.x += rect.width + DVariableDrawer.SPACE;
rect.xMax = position.xMax;
SerializedProperty valueProperty = property.FindPropertyRelative("value");
switch (valueProperty.type)
{
case "int": valueProperty.intValue = EditorGUI.DelayedIntField(rect, valueProperty.intValue); break;
case "long": valueProperty.longValue = EditorGUI.LongField(rect, valueProperty.longValue); break;
case "float": valueProperty.floatValue = EditorGUI.DelayedFloatField(rect, valueProperty.floatValue); break;
}
EditorGUI.EndProperty();
}
public static T OnGUI <T>(Rect position, T decorator, GUIContent label) where T : VariableDecorator, new ()
{
decorator = decorator ?? new T();
Rect rect = new Rect(position)
{
width = label.text.Length * DVariableDrawer.CHARACTER_WIDTH
};
EditorGUI.LabelField(rect, label);
rect.x += rect.width;
rect.width = 6f * DVariableDrawer.CHARACTER_WIDTH;
EditorGUI.LabelField(rect, "Priority");
rect.x += rect.width + DVariableDrawer.SPACE;
rect.width = 3 * DVariableDrawer.CHARACTER_WIDTH;
decorator.priority = EditorGUI.DelayedIntField(rect, decorator.priority);
rect.x += rect.width + DVariableDrawer.SPACE;
rect.width = 5 * DVariableDrawer.CHARACTER_WIDTH;
decorator.type = (VariableDecoratorType)EditorGUI.EnumPopup(rect, decorator.type);
rect.x += rect.width + DVariableDrawer.SPACE;
rect.xMax = position.xMax;
if (typeof(T) == typeof(IntDecorator))
{
(decorator as IntDecorator).value = EditorGUI.DelayedIntField(rect, (decorator as IntDecorator).value);
}
else if (typeof(T) == typeof(LongDecorator))
{
(decorator as LongDecorator).value = EditorGUI.LongField(rect, (decorator as LongDecorator).value);
}
else if (typeof(T) == typeof(FloatDecorator))
{
(decorator as FloatDecorator).value = EditorGUI.DelayedFloatField(rect, (decorator as FloatDecorator).value);
}
return(decorator);
}
internal override void OnGUI(Rect position, SerializedProperty property, GUIContent label, DecoratedDrawer drawer)
{
switch (property.propertyType)
{
case SerializedPropertyType.Float:
EditorGUI.DelayedFloatField(position, property, label);
break;
case SerializedPropertyType.Integer:
EditorGUI.DelayedIntField(position, property, label);
break;
case SerializedPropertyType.String:
EditorGUI.DelayedTextField(position, property, label);
break;
default:
EditorGUI.LabelField(position, label.text, "Delayed: must be float, integer, or string.");
break;
}
}
private void DrawBasicRanges()
{
EditorGUI.LabelField(new Rect(ir.xMin + PADDING, line - 2, labelwidth, LINEHEIGHT), new GUIContent(holdindent < 2 ? "Range:" : "Rng:"), (GUIStyle)"MiniLabel");
//int holdindent = EditorGUI.indentLevel;
//EditorGUI.indentLevel = 0;
const float labelW = 48f;
const float inputW = 50f;
float input1Left = fieldleft;
float input2Left = paddedright - inputW;
float label1Left = input1Left - labelW;
float label2Left = input2Left - labelW;
EditorGUI.LabelField(new Rect(label1Left, line - 2, labelW, LINEHEIGHT), new GUIContent("min: "), miniLabelRight);
float min = EditorGUI.DelayedFloatField(new Rect(input1Left, line, inputW, LINEHEIGHT), GUIContent.none, fc.Min, (GUIStyle)"MiniTextField");
if (fc.Min != min)
{
haschanged = true;
Undo.RecordObject(p.serializedObject.targetObject, "Min value Change");
fc.Min = min;
}
EditorGUI.LabelField(new Rect(label2Left, line - 2, labelW, LINEHEIGHT), new GUIContent("max: "), miniLabelRight);
float max = EditorGUI.DelayedFloatField(new Rect(input2Left, line, inputW, LINEHEIGHT), GUIContent.none, fc.Max, (GUIStyle)"MiniTextField");
if (fc.Max != max)
{
haschanged = true;
Undo.RecordObject(p.serializedObject.targetObject, "Max value change");
fc.Max = max;
}
EditorGUI.indentLevel = holdindent;
}
protected Vector2 DrawDestroyEffectObj(float startX, float startY, Unit unit)
{
cont = new GUIContent("Spawn Immunity:", "How long the unit will stay immune to all attack when it's first spawned/respawned.");
EditorGUI.LabelField(new Rect(startX, startY, width, height), cont);
unit.spawnImmunity = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, 40, height), unit.spawnImmunity);
startY += 10;
cont = new GUIContent("DestroyCamShake:", "The camera shake magnitude whenever the unit is destroyed");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
unit.destroyCamShake = EditorGUI.DelayedFloatField(new Rect(startX + spaceX, startY, 40, height), unit.destroyCamShake);
startY += 10;
cont = new GUIContent("DestroyedEffectObj:", "The object to be spawned when the unit is destroyed (optional)");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
unit.destroyedEffectObj = (GameObject)EditorGUI.ObjectField(new Rect(startX + spaceX, startY, width, height), unit.destroyedEffectObj, typeof(GameObject), false);
cont = new GUIContent("AutoDestroy Effect:", "Check if the effect object needs to be removed from the game");
EditorGUI.LabelField(new Rect(startX, startY += spaceY, width, height), cont);
if (unit.destroyedEffectObj != null)
{
unit.autoDestroyDObj = EditorGUI.Toggle(new Rect(startX + spaceX, startY, 40, height), unit.autoDestroyDObj);
if (unit.autoDestroyDObj)
{
cont = new GUIContent(" - Duration:", "The delay in seconds before the effect object is destroyed");
EditorGUI.LabelField(new Rect(startX + spaceX + 15, startY, width, height), cont);
unit.dObjActiveDuration = EditorGUI.DelayedFloatField(new Rect(startX + spaceX + width - 58, startY, 40, height), unit.dObjActiveDuration);
}
}
else
{
EditorGUI.LabelField(new Rect(startX + spaceX, startY, 40, height), "-");
}
return(new Vector2(startX, startY));
}