public override void Draw(Rect position, GUIContent label)
{
if (Creature.Species != null)
{
var speciesHeight = _instructionCaller.GetHeight(null);
var speciesRect = RectHelper.TakeHeight(ref position, speciesHeight);
RectHelper.TakeVerticalSpace(ref position);
var labelRect = RectHelper.TakeWidth(ref speciesRect, speciesRect.width * 0.25f);
var editRect = RectHelper.AdjustHeight(RectHelper.TakeTrailingIcon(ref speciesRect), EditorGUIUtility.singleLineHeight, RectVerticalAlignment.Top);
EditorGUI.LabelField(labelRect, Creature.Species.Name);
_instructionCaller.Draw(speciesRect, GUIContent.none);
if (GUI.Button(editRect, _editSpeciesButton.Content, GUIStyle.none))
{
Selection.activeObject = Creature.Species;
}
}
if (Creature.Creature != null)
{
var editRect = RectHelper.TakeTrailingIcon(ref position);
EditorGUI.LabelField(position, Creature.Creature.Name);
if (GUI.Button(editRect, _editCreatureButton.Content, GUIStyle.none))
{
Selection.activeObject = Creature.Creature;
}
}
}
private void DrawVariable(Rect rect, IList list, int index)
{
var name = _pool.Names[index];
var variable = _pool.Variables[index];
var definition = _pool.Definitions[index];
var labelRect = RectHelper.TakeWidth(ref rect, _labelWidth);
labelRect = RectHelper.TakeHeight(ref labelRect, EditorGUIUtility.singleLineHeight);
var editRect = RectHelper.TakeLeadingIcon(ref labelRect);
if (GUI.Button(editRect, _editButton.Content, GUIStyle.none))
{
_editPopup.Setup(this, index);
PopupWindow.Show(editRect, _editPopup);
}
EditorGUI.LabelField(labelRect, name);
using (var changes = new EditorGUI.ChangeCheckScope())
{
var value = VariableValueDrawer.Draw(rect, GUIContent.none, variable, definition, true);
if (changes.changed)
{
_pool.SetVariable(index, value);
}
}
}
private void DrawDoor(Rect rect, IList list, int index)
{
var door = _building.Doors[index];
var nameRect = RectHelper.TakeLine(ref rect);
RectHelper.TakeWidth(ref rect, RectHelper.LeftMargin);
var positionRect = RectHelper.TakeLine(ref rect);
var orderRect = RectHelper.TakeLine(ref rect);
var spriteRect = RectHelper.TakeLine(ref rect);
var openARect = RectHelper.TakeLine(ref rect);
var closeARect = RectHelper.TakeLine(ref rect);
var openSRect = RectHelper.TakeLine(ref rect);
var closeSRect = RectHelper.TakeLine(ref rect);
door.GameObject.name = EditorGUI.TextField(nameRect, door.GameObject.name);
var position = EditorGUI.Vector2Field(positionRect, _accessoryPositionContent, door.Bounds.position);
door.OrderOffset = door.Renderer.sortingOrder = EditorGUI.IntSlider(orderRect, _orderOffsetContent, door.Renderer.sortingOrder, 0, _MaxOrderOffset);
door.Renderer.sprite = EditorGUI.ObjectField(spriteRect, _spriteContent, door.Renderer.sprite, typeof(Sprite), false) as Sprite;
door.Door.OpenAnimation = EditorGUI.ObjectField(openARect, _openAnimationContent, door.Door.OpenAnimation, typeof(AnimationClip), false) as AnimationClip;
door.Door.CloseAnimation = EditorGUI.ObjectField(closeARect, _closeAnimationContent, door.Door.CloseAnimation, typeof(AnimationClip), false) as AnimationClip;
door.Door.OpenSound = EditorGUI.ObjectField(openSRect, _openSoundContent, door.Door.OpenSound, typeof(AudioClip), false) as AudioClip;
door.Door.CloseSound = EditorGUI.ObjectField(closeSRect, _closeSoundContent, door.Door.CloseSound, typeof(AudioClip), false) as AudioClip;
UpdatePartTransform(door, position);
}
private static void DrawIndentedLabel(ref Rect rect, GUIContent label)
{
var labelRect = RectHelper.TakeWidth(ref rect, RectHelper.CurrentLabelWidth);
RectHelper.TakeWidth(ref labelRect, RectHelper.Indent);
EditorGUI.LabelField(labelRect, label);
}
private void DrawEncounter(Rect rect, IList list, int index)
{
var encounter = _table.GetValue(index);
var weight = _table.GetWeight(index);
var percent = _table.GetPercentageWeight(index);
var control = GetControl(index, encounter);
var creatureHeight = control.GetHeight(null);
var creatureRect = RectHelper.TakeHeight(ref rect, creatureHeight);
control.Draw(creatureRect, null);
RectHelper.TakeVerticalSpace(ref rect);
RectHelper.TakeWidth(ref rect, rect.width * 0.25f);
var percentRect = RectHelper.TakeTrailingWidth(ref rect, rect.width * 0.25f);
var sliderRect = RectHelper.TakeWidth(ref rect, rect.width - RectHelper.HorizontalSpace);
EditorGUI.LabelField(percentRect, string.Format("({0:f1}%)", percent));
var selectedWeight = EditorGUI.IntSlider(sliderRect, weight, 1, _table.TotalWeight);
if (weight != selectedWeight)
{
_table.ChangeWeight(index, selectedWeight);
}
}
private void DrawRule(Rect rect, IList list, int index)
{
var rule = _ruleOverrideTile.Rules[index];
var overrideRule = _ruleOverrideTile.OverrideTile.Rules[index];
var width = EditorGUIUtility.singleLineHeight * 3 + RectHelper.VerticalSpace * 2;
var referenceRect = RectHelper.TakeLine(ref rect);
var isReferenceRect = RectHelper.TakeWidth(ref referenceRect, referenceRect.width * 0.5f - RectHelper.HorizontalSpace);
RectHelper.TakeHorizontalSpace(ref referenceRect);
var matrixRect = RectHelper.TakeWidth(ref rect, width);
RectHelper.TakeHorizontalSpace(ref rect);
DrawRuleMatrix(_ruleOverrideTile.OverrideTile, matrixRect, overrideRule);
rule.UseReference = EditorGUI.Toggle(isReferenceRect, _isReferenceContent.Content, rule.UseReference);
if (rule.UseReference)
{
rule.Tile.Sprite = null;
rule.Reference = EditorGUI.ObjectField(referenceRect, _referenceContent, rule.Reference, typeof(TileBase), false) as TileBase;
if (rule.Reference == _ruleOverrideTile)
{
rule.Reference = null;
}
}
else
{
rule.Tile = TileTransformInfoControl.Draw(rect, GUIContent.none, rule.Tile);
rule.Reference = null;
}
}
public static ValueDefinition Draw(Rect position, GUIContent label, ValueDefinition definition, VariableInitializerType initializer, TagList tags, bool showConstraintLabel, ref bool isExpanded)
{
var tag = definition.Tag;
var constraint = definition.Constraint;
var hasInitializer = HasInitializer(definition.Type, initializer);
var hasConstraint = HasConstraint(definition.Type, definition.Constraint, definition.IsConstraintLocked);
var hasTag = HasTags(tags);
var typeRect = RectHelper.TakeLine(ref position);
if (label != GUIContent.none)
{
var labelRect = RectHelper.TakeWidth(ref typeRect, RectHelper.CurrentLabelWidth);
EditorGUI.LabelField(labelRect, label);
}
var type = DrawType(typeRect, definition.IsTypeLocked, definition.Type);
if (hasConstraint)
{
var constraintHeight = GetConstraintHeight(definition.Type, definition.Constraint);
var constraintRect = RectHelper.TakeHeight(ref position, constraintHeight);
DrawConstraint(constraintRect, type, definition.IsConstraintLocked, ref constraint, showConstraintLabel);
}
if (hasInitializer && definition.Initializer != null)
{
if (initializer == VariableInitializerType.Expression)
{
var initializerHeight = ExpressionControl.GetFoldoutHeight(definition.Initializer, isExpanded, true, 2, 3);
var initializerRect = RectHelper.TakeHeight(ref position, initializerHeight);
RectHelper.TakeVerticalSpace(ref position);
DrawInitializer(initializerRect, ref definition, ref isExpanded);
}
else if (initializer == VariableInitializerType.DefaultValue)
{
var initializerRect = RectHelper.TakeLine(ref position);
DrawDefaultValue(initializerRect, ref definition);
}
}
if (hasTag)
{
var tagRect = RectHelper.TakeLine(ref position);
tag = DrawTag(tagRect, tag, tags);
}
return(ValueDefinition.Create(type, constraint, tag, definition.Initializer, definition.IsTypeLocked, definition.IsConstraintLocked));
}
private void Draw(Rect rect, IList list, int index)
{
var command = _composition.CustomCommands[index];
var labelRect = RectHelper.TakeWidth(ref rect, _labelWidth);
EditorGUI.LabelField(labelRect, command.Name);
using (var changes = new EditorGUI.ChangeCheckScope())
{
ExpressionControl.DrawFoldout(rect, command.Expression, GUIContent.none);
if (changes.changed)
{
_composition.SetExpression(index, command.Expression);
}
}
}
private static void DrawError(Rect rect, Expression expression, GUIContent label, bool fullWidth)
{
if (expression.HasError)
{
RectHelper.TakeVerticalSpace(ref rect);
if (fullWidth)
{
RectHelper.TakeWidth(ref rect, RectHelper.Indent);
}
else if (!string.IsNullOrEmpty(label.text))
{
RectHelper.TakeLabel(ref rect);
}
EditorGUI.HelpBox(rect, expression.CompilationResult.Message, MessageType.Error);
}
}
private void DrawAccessory(Rect rect, IList list, int index)
{
var accessory = _building.Accessories[index];
var nameRect = RectHelper.TakeLine(ref rect);
RectHelper.TakeWidth(ref rect, RectHelper.LeftMargin);
var orderRect = RectHelper.TakeLine(ref rect);
var positionRect = RectHelper.TakeLine(ref rect);
var spriteRect = RectHelper.TakeLine(ref rect);
var animationRect = RectHelper.TakeLine(ref rect);
var animationLabelRect = RectHelper.TakeLabel(ref animationRect);
var animationToggleRect = RectHelper.TakeLeadingIcon(ref animationRect);
accessory.GameObject.name = EditorGUI.TextField(nameRect, accessory.GameObject.name);
var position = EditorGUI.Vector2Field(positionRect, _accessoryPositionContent, accessory.Bounds.position);
accessory.OrderOffset = accessory.Renderer.sortingOrder = EditorGUI.IntSlider(orderRect, _orderOffsetContent, accessory.Renderer.sortingOrder, 0, _MaxOrderOffset);
accessory.Renderer.sprite = EditorGUI.ObjectField(spriteRect, _spriteContent, accessory.Renderer.sprite, typeof(Sprite), false) as Sprite;
EditorGUI.LabelField(animationLabelRect, _animationsContent);
var hasAnimations = accessory.Animation != null;
var selectedHasAnimations = EditorGUI.Toggle(animationToggleRect, hasAnimations);
if (selectedHasAnimations && !hasAnimations)
{
AddAnimations(accessory);
}
else if (!selectedHasAnimations && hasAnimations)
{
RemoveAnimations(accessory);
}
if (selectedHasAnimations)
{
accessory.Animation.Animation = EditorGUI.ObjectField(animationRect, accessory.Animation.Animation, typeof(AnimationClip), false) as AnimationClip;
}
UpdatePartTransform(accessory, position);
}
private static TileTransformInfo Draw(Rect position, GUIContent label, Sprite sprite, int rotation, bool horizontal, bool vertical)
{
var rect = EditorGUI.PrefixLabel(position, label);
var spriteRect = RectHelper.TakeWidth(ref rect, Height);
RectHelper.TakeHorizontalSpace(ref rect);
var rotationRect = RectHelper.TakeLine(ref rect);
var horizontalRect = RectHelper.TakeLine(ref rect);
var verticalRect = RectHelper.TakeLine(ref rect);
var info = new TileTransformInfo
{
Sprite = EditorGUI.ObjectField(spriteRect, sprite, typeof(Sprite), false) as Sprite,
Rotation = EditorGUI.IntPopup(rotationRect, _rotationContent.Content, rotation, _rotationsContent, TileTransformInfo.Rotations),
FlipHorizontal = EditorGUI.Toggle(horizontalRect, _flipHorizontalContent.Content, horizontal),
FlipVertical = EditorGUI.Toggle(verticalRect, _flipVerticalContent.Content, vertical)
};
return(info);
}
private void DrawOutput(Rect rect, IList list, int index)
{
var labelWidth = rect.width * 0.25f;
var typeWidth = rect.width * 0.25f;
var output = _caller.Outputs[index];
var labelRect = RectHelper.TakeWidth(ref rect, labelWidth);
var typeRect = RectHelper.TakeWidth(ref rect, typeWidth);
RectHelper.TakeHorizontalSpace(ref rect);
EditorGUI.LabelField(labelRect, output.Name);
output.Type = (InstructionOutputType)EditorGUI.EnumPopup(typeRect, output.Type);
switch (output.Type)
{
case InstructionOutputType.Ignore: break;
case InstructionOutputType.Reference: VariableReferenceControl.Draw(rect, output.Reference, GUIContent.none); break;
}
}
private void DrawInput(Rect rect, IList list, int index)
{
var labelWidth = rect.width * 0.25f;
var typeWidth = rect.width * 0.25f;
var input = _caller.Inputs[index];
var definition = _caller.GetInputDefinition(input);
var labelRect = RectHelper.TakeWidth(ref rect, labelWidth);
var typeRect = RectHelper.TakeWidth(ref rect, typeWidth);
RectHelper.TakeHorizontalSpace(ref rect);
EditorGUI.LabelField(labelRect, definition.Name);
input.Type = (InstructionInputType)EditorGUI.EnumPopup(typeRect, input.Type);
switch (input.Type)
{
case InstructionInputType.Reference: VariableReferenceControl.Draw(rect, input.Reference, GUIContent.none); break;
case InstructionInputType.Value: input.Value = VariableValueDrawer.Draw(rect, GUIContent.none, input.Value, definition.Definition, true); break;
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var target = PropertyHelper.GetObject <VariableValueSource>(property);
var typeRect = RectHelper.TakeLine(ref position);
RectHelper.TakeLabel(ref position);
using (new EditObjectScope(property.serializedObject))
{
using (new UndoScope(property.serializedObject.targetObject, false))
{
target.Type = (VariableSourceType)EnumDisplayDrawer.Draw(typeRect, label, (int)target.Type, typeof(VariableSourceType), EnumDisplayType.Buttons, false, 50);
if (target.Type == VariableSourceType.Value)
{
if (!target.Definition.IsTypeLocked)
{
var variableRect = RectHelper.TakeWidth(ref position, position.width * 0.5f);
RectHelper.TakeHorizontalSpace(ref position);
var definitionType = (VariableType)EditorGUI.EnumPopup(variableRect, target.Definition.Type);
if (definitionType != target.Definition.Type)
{
target.Definition = ValueDefinition.Create(definitionType, target.Definition.Constraint, target.Definition.Tag, target.Definition.Initializer, false, false);
target.Value = target.Definition.Generate(null);
}
}
target.Value = VariableValueDrawer.Draw(position, GUIContent.none, target.Value, target.Definition, true);
}
else if (target.Type == VariableSourceType.Reference)
{
VariableReferenceControl.Draw(position, target.Reference, GUIContent.none);
}
}
}
}
private void DrawInput(Rect rect, IList list, int index)
{
var labelWidth = rect.width * 0.25f;
var typeWidth = rect.width * 0.25f;
var input = _caller.Inputs[index];
var labelRect = RectHelper.TakeWidth(ref rect, labelWidth);
var typeRect = RectHelper.TakeWidth(ref rect, typeWidth);
RectHelper.TakeHorizontalSpace(ref rect);
EditorGUI.LabelField(labelRect, input.Definition.Name);
if (input.Definition.Type == VariableType.Empty)
{
var typeIndex = input.Type == InstructionInputType.Reference ? 6 : GetIndexForType(input.Value.Type);
var newIndex = EditorGUI.Popup(typeRect, typeIndex, _inputTypeOptions);
if (newIndex != typeIndex)
{
input.Type = newIndex == 6 ? InstructionInputType.Reference : InstructionInputType.Value;
input.Value = VariableValue.Create(GetTypeFromIndex(newIndex));
}
}
else
{
input.Type = (InstructionInputType)EditorGUI.EnumPopup(typeRect, input.Type);
}
switch (input.Type)
{
case InstructionInputType.Reference: VariableReferenceControl.Draw(rect, input.Reference, GUIContent.none); break;
case InstructionInputType.Value: input.Value = VariableValueDrawer.Draw(rect, GUIContent.none, input.Value, input.Definition); break;
}
}
protected override void Draw(Rect rect, int index)
{
var name = _proxy.GetName(index);
var value = Store.GetVariable(name);
var definition = ValueDefinition.Create(VariableType.Empty);
if (value.IsEmpty)
{
EditorGUI.LabelField(rect, name, EmptyText);
}
else
{
if (value.HasStore)
{
if (DrawStoreView(ref rect))
{
Selected = value.Store;
SelectedName = name;
}
}
using (var changes = new EditorGUI.ChangeCheckScope())
{
var labelRect = RectHelper.TakeWidth(ref rect, _labelWidth);
labelRect = RectHelper.TakeHeight(ref labelRect, EditorGUIUtility.singleLineHeight);
EditorGUI.LabelField(labelRect, name);
value = VariableValueDrawer.Draw(rect, GUIContent.none, value, definition, false);
if (changes.changed)
{
Store.SetVariable(name, value);
}
}
}
}
private static void DrawNumberConstraint(Rect rect, VariableType type, ref VariableConstraint constraint)
{
var fromLabel = _minimumConstraintLabel;
var toLabel = _maximumConstraintLabel;
var fromSize = EditorStyles.label.CalcSize(fromLabel);
var toSize = EditorStyles.label.CalcSize(toLabel);
var spacing = 5.0f;
var inputWidth = (rect.width - rect.height - fromSize.x - toSize.x - spacing * 4) * 0.5f;
var checkboxRect = RectHelper.TakeWidth(ref rect, rect.height);
RectHelper.TakeWidth(ref rect, spacing);
var fromRect = RectHelper.TakeWidth(ref rect, fromSize.x);
RectHelper.TakeWidth(ref rect, spacing);
var minimumRect = RectHelper.TakeWidth(ref rect, inputWidth);
RectHelper.TakeWidth(ref rect, spacing);
var toRect = RectHelper.TakeWidth(ref rect, toSize.x);
RectHelper.TakeWidth(ref rect, spacing);
var maximumRect = RectHelper.TakeWidth(ref rect, inputWidth);
var useRangeConstraint = GUI.Toggle(checkboxRect, constraint != null, _useRangeConstraintLabel);
if (!useRangeConstraint)
{
constraint = null;
}
else if (type == VariableType.Int)
{
if (!(constraint is IntVariableConstraint intConstraint))
{
intConstraint = new IntVariableConstraint {
Minimum = 0, Maximum = 100
};
constraint = intConstraint;
}
GUI.Label(fromRect, fromLabel);
intConstraint.Minimum = EditorGUI.IntField(minimumRect, intConstraint.Minimum);
GUI.Label(toRect, toLabel);
intConstraint.Maximum = EditorGUI.IntField(maximumRect, intConstraint.Maximum);
}
else if (type == VariableType.Float)
{
if (!(constraint is FloatVariableConstraint floatConstraint))
{
floatConstraint = new FloatVariableConstraint {
Minimum = 0, Maximum = 100
};
constraint = floatConstraint;
}
GUI.Label(fromRect, fromLabel);
floatConstraint.Minimum = EditorGUI.FloatField(minimumRect, floatConstraint.Minimum);
GUI.Label(toRect, toLabel);
floatConstraint.Maximum = EditorGUI.FloatField(maximumRect, floatConstraint.Maximum);
}
}
private static VariableValue DrawStore(Rect rect, VariableValue value, StoreVariableConstraint constraint, bool drawStores)
{
if (drawStores)
{
var names = value.Store.GetVariableNames();
var remove = string.Empty;
var first = true;
var empty = ValueDefinition.Create(VariableType.Empty);
foreach (var name in names)
{
if (!first)
{
RectHelper.TakeVerticalSpace(ref rect);
}
var index = constraint?.Schema != null?constraint.Schema.GetIndex(name) : -1;
var definition = index >= 0 ? constraint.Schema[index].Definition : empty;
var item = value.Store.GetVariable(name);
var height = GetHeight(item, definition, true);
var itemRect = RectHelper.TakeHeight(ref rect, height);
var labelRect = RectHelper.TakeWidth(ref itemRect, _storeLabelWidth);
labelRect = RectHelper.TakeLine(ref labelRect);
EditorGUI.LabelField(labelRect, name);
if (constraint?.Schema == null && value.Store is VariableStore)
{
var removeRect = RectHelper.TakeTrailingIcon(ref itemRect);
if (GUI.Button(removeRect, _removeStoreButton.Content, GUIStyle.none))
{
remove = name;
}
}
item = Draw(itemRect, GUIContent.none, item, definition, true);
value.Store.SetVariable(name, item);
first = false;
}
if (constraint?.Schema == null && value.Store is VariableStore store)
{
var addRect = RectHelper.TakeTrailingIcon(ref rect);
if (GUI.Button(addRect, _addStoreButton.Content, GUIStyle.none))
{
AddToStorePopup.Store = store;
AddToStorePopup.Name = "";
PopupWindow.Show(addRect, AddToStorePopup.Instance);
}
if (!string.IsNullOrEmpty(remove))
{
(value.Store as VariableStore).RemoveVariable(remove);
}
}
}
else
{
EditorGUI.LabelField(rect, value.Store.ToString());
}
return(value);
}