public FieldInstance(E_OverlapEvent overlapEvent, ObjectField objectField, WorldAnchor anchor)
: base(objectField.CollisionWidth, objectField.CollisionHeigth, anchor)
{
this.objectField = objectField;
this.overlapEvent = overlapEvent;
vectorControl = new VectorControl(this);
}
public LockObstacle(ObjectField objectField, ObjectStage objectStage, ItemDropManager itemDropManager, FSM parentFsm)
: base(objectField, objectStage, itemDropManager, parentFsm)
{
objectLockObstacle = TableLoader.GetTable<ObjectLockObstacle>().Get(objectStage.ObjectID);
int lockCount = objectLockObstacle.LockCount;
this.name = StringTableLoader.Instance.Get(objectField.ObjectName);
InitStatus<LockStatus>(
new object[] { LockStatus.Lock, 0, lockCount, lockCount }
);
RegisterDeathCondition(
delegate(Status current)
{
return current.Get(LockStatus.Lock) == 0;
}
);
AddAction(Action.E_Type.Unlock,
delegate(float value, GameInstance firer, string[] param)
{
FSMEvent("damage");
return new ActionHandler.Result(LockStatus.Lock, -value);
}
);
AddAction(Action.E_Type.Attack,
delegate(float value, GameInstance firer, string[] param)
{
FSMEvent("damage");
return new ActionHandler.Result(LockStatus.Lock, -1);
}
);
}
public Projectile(GameInstance parent, float initX, float initY, ObjectField objectField, ObjectProjectile objectProjectile)
: base(parent.Rect.point.layer, initX, objectField, parent.ToLeft)
{
Move(new Vector2(0, initY));
this.objectProjectile = objectProjectile;
this.parent = parent;
}
public StageObject(ObjectField objectField, ObjectStage objectStage, ItemDropManager itemDropManager, FSM parentFsm)
: base(objectStage.OverlapEvent, objectField, true)
{
Assert.IsTrue(objectStage != null);
this.objectStage = objectStage;
this.itemDropManager = itemDropManager;
this.parentFsm = parentFsm;
label = string.Format("{0}\n{1}", objectStage.Type.ToString(), objectStage.ObjectID);
}
// I wonder if the next methods could be merged into one....
public static int GetUpdateField(ObjectField objectField)
{
var typeString = string.Format("WowPacketParser.Enums.Version.{0}.ObjectField", ClientVersion.GetVersionString());
var newEnumType = _assembly.GetType(typeString);
foreach (int val in Enum.GetValues(newEnumType))
if (Enum.GetName(newEnumType, val) == objectField.ToString())
return val;
return (int)objectField;
}
public ProceduralTexture2DSlotControlView(ProceduralTexture2DInputMaterialSlot slot)
{
styleSheets.Add(Resources.Load <StyleSheet>("ProceduralTexture2DSlotControlView"));
m_Slot = slot;
proceduralTexture2DField = new ObjectField
{
value = m_Slot.proceduralTexture2D,
allowSceneObjects = false,
objectType = typeof(ProceduralTexture2D)
};
proceduralTexture2DField.RegisterCallback <ChangeEvent <Object> >(RegisterValueChangedCallback, TrickleDown.NoTrickleDown);
Add(proceduralTexture2DField);
}
VisualTreeAsset SetUpStaticObject()
{
VisualTreeAsset aAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/UXML Files/StaticObjectEditor.uxml");
mCurrentObjectElement = aAsset.CloneTree();
mSObjSprite = mCurrentObjectElement.Q <ObjectField>("static_object_sprite");
mSObjSprite.objectType = typeof(Sprite);
mSObjSprite.RegisterCallback <ChangeEvent <Object> >((aEv) => GenHelpers.OnSpriteSelection((Sprite)aEv.newValue, mSObjSprite));
mColliderType = mCurrentObjectElement.Q <EnumField>("static_object_collider");
mColliderType.Init(GameScriptable.ColliderType.None);
mColliderType.RegisterCallback <ChangeEvent <System.Enum> >((aEv) => OnColliderTypeChanged((GameScriptable.ColliderType)aEv.newValue));
return(aAsset);
}
public SelectedScriptableObjectElement(VisualElement parent, System.Action <ChangeEvent <Object> > OnSelectedObjectChange)
{
this.ObjectField = new ObjectField();
this.ObjectField.objectType = typeof(ScriptableObject);
this.ObjectField.RegisterCallback <ChangeEvent <Object> >((evt) =>
{
OnSelectedObjectChange(evt);
evt.StopPropagation();
});
this.Add(this.ObjectField);
parent.Add(this);
}
private void CollectInheritedDirectives(
HashSet <string> processed,
List <IDirective> directives,
ObjectField field)
{
foreach (IDirective directive in field.ExecutableDirectives)
{
if (processed.Add(directive.Name))
{
directives.Add(directive);
}
}
}
public override void Action(int instanceId, string pathName, string resourceFile)
{
var newAsset = CreateInstance <EnvironmentLibrary>();
newAsset.name = Path.GetFileName(pathName);
AssetDatabase.CreateAsset(newAsset, pathName);
ProjectWindowUtil.ShowCreatedAsset(newAsset);
if (m_Field != null)
{
m_Field.value = newAsset;
}
m_Field = null;
}
void InitializeDebug()
{
shaderNode.onProcessed += () => {
debugCustomRenderTextureField.value = shaderNode.output;
};
debugCustomRenderTextureField = new ObjectField("Output")
{
value = shaderNode.output
};
debugContainer.Add(debugCustomRenderTextureField);
}
/// <summary>
/// Creates an editor for a node.
/// </summary>
/// <param name="node">The node to create the editor for.</param>
/// <returns>The editor.</returns>
protected override Control CreateEditor(TreeNodeAdv node)
{
ObjectField field = node.Tag as ObjectField;
Control control = base.CreateEditor(node);
if (field != null)
{
control.Text = field.NameTag.ToString();
}
return(control);
}
/// <summary>
/// Creates a new field selection.
/// </summary>
/// <param name="selection">
/// The query field selection.
/// </param>
/// <param name="field">
/// The <see cref="ObjectField"/> the <paramref name="selection"/>
/// referrs to.
/// </param>
/// <param name="responseName">
/// The name the field shall have in the query result.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="field"/> is <c>null</c>
/// or
/// <paramref name="selection"/> is <c>null</c>
/// or
/// <paramref name="responseName"/> is <c>null</c>
/// or
/// <paramref name="responseName"/> is <see cref="string.Empty"/>.
/// </exception>
/// <returns>
/// Returns a new field selection.
/// </returns>
public static FieldSelection Create(
FieldNode selection,
ObjectField field,
string responseName)
{
return(new FieldSelection
(
selection,
field,
responseName,
ImmutableList <FieldNode> .Empty.Add(selection)
));
}
void CreateVisualTree()
{
var visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/EditorComponents/PlayerEditor.uxml");
var styleSheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Editor/LevelEditorWindow.uss");
playerEditor = visualTree.CloneTree();
playerPropertiesContainer = playerEditor.Q <Box>("playerPropertiesContainer");
playerAnimationContainer = playerEditor.Q <Box>("playerAnimationContainer");
var playerSpriteSheet = new Label("Sprite Sheet");
playerSpriteSheet.name = "playerSpriteSheet";
var playerSpriteSelection = new ObjectField {
objectType = typeof(UnityEngine.Texture)
};
playerSpriteSelection.name = "playerSpriteSelection";
var playerSpeed = new Label("Speed");
playerSpeed.name = "playerSpeed";
var playerSpeedSelection = new FloatField();
playerSpeedSelection.name = "playerSpeedSelection";
var playerHealth = new Label("Health");
playerHealth.name = "playerHealth";
var playerHealthSelection = new FloatField();
playerHealthSelection.name = "playerHealthSelection";
playerPropertiesContainer.Add(playerSpriteSheet);
playerPropertiesContainer.Add(playerSpriteSelection);
playerPropertiesContainer.Add(playerSpeed);
playerPropertiesContainer.Add(playerSpeedSelection);
playerPropertiesContainer.Add(playerHealth);
playerPropertiesContainer.Add(playerHealthSelection);
animationListContainer = new IMGUIContainer(DrawAnimationList);
animationListContainer.onGUIHandler = DrawAnimationList;
animationList = new ReorderableList(animationNames, typeof(AnimationObject));
animationList.drawElementCallback = DrawList;
animationList.drawHeaderCallback = WriteHeader;
animationList.onReorderCallback = ChangeListOrder;
animationList.onSelectCallback = SelectListItem;
animationList.onAddCallback = AddToList;
animationList.onRemoveCallback = RemoveFromList;
playerAnimationContainer.Add(animationListContainer);
}
/// <summary>
/// Build the message to be sent to MySQL Server to execute statement "Create" or "Modify" collection with schema options
/// </summary>
/// <param name="ns">The namespace</param>
/// <param name="stmt">The name of the command to be executed on MySql Server</param>
/// <param name="args">Array of KeyValuePairs with the parameters required to build the message</param>
/// <returns>void.</returns>
public void SendExecuteStatementOptions(string ns, string stmt, params KeyValuePair <string, object>[] args)
{
StmtExecute stmtExecute = new StmtExecute();
stmtExecute.Namespace = ns;
stmtExecute.Stmt = ByteString.CopyFromUtf8(stmt);
stmtExecute.CompactMetadata = false;
if (args != null)
{
var options = new ObjectField();
var validation = new ObjectField();
var reuse_obj = new ObjectField();
var optionsAny = ExprUtil.BuildEmptyAny(Any.Types.Type.Object);
var any = ExprUtil.BuildEmptyAny(Any.Types.Type.Object);
var innerAny = ExprUtil.BuildEmptyAny(Any.Types.Type.Object);
var reuse_any = ExprUtil.BuildEmptyAny(Any.Types.Type.Object);
foreach (var arg in args)
{
if (arg.Value is Dictionary <string, object> && arg.Key == "options")
{
foreach (var field in arg.Value as Dictionary <string, object> )
{
innerAny.Obj.Fld.Add(CreateObject(field.Key, field.Value));
}
}
else if (arg.Key == "reuse_existing")
{
reuse_any = ExprUtil.BuildAny(arg.Value);
}
else
{
any.Obj.Fld.Add(CreateObject(arg.Key, arg.Value));
}
}
options.Key = "options";
validation.Key = "validation";
validation.Value = innerAny;
reuse_obj.Key = "reuse_existing";
reuse_obj.Value = reuse_any;
optionsAny.Obj.Fld.Add(validation);
if (stmt == "create_collection")
{
optionsAny.Obj.Fld.Add(reuse_obj);
}
options.Value = optionsAny;
any.Obj.Fld.Add(options);
stmtExecute.Args.Add(any);
}
_writer.Write(ClientMessageId.SQL_STMT_EXECUTE, stmtExecute);
}
/// <summary>
/// Gets called when an item is dropped over the treeview.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">More information about the event.</param>
private void trvTree_DragDrop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent(typeof(TreeNodeAdv[])) && trvTree.DropPosition.Node != null)
{
TreeNodeAdv[] nodes = e.Data.GetData(typeof(TreeNodeAdv[])) as TreeNodeAdv[];
TreeNodeAdv parent = trvTree.DropPosition.Node;
if (nodes != null && nodes.Length == 1 && parent != null)
{
ObjectField draggedField = nodes[0].Tag as ObjectField;
ObjectField destField = parent.Tag as ObjectField;
if (draggedField != null && destField != null)
{
bool ownNode = trvTree.FindNodeByTag(draggedField) != null;
if (ownNode)
{
ObjectFieldList parentList = destField.Parent as ObjectFieldList;
if (parentList != null)
{
int index = parentList.Items.IndexOf(destField);
index = trvTree.DropPosition.Position == NodePosition.After ? index + 1 : index;
bool expanded = nodes[0].IsExpanded;
parentList.Move(draggedField, index);
trvTree.FindNodeByTag(draggedField).IsExpanded = expanded;
}
}
else
{
ObjectFieldDictionary parentDestDict = destField.Parent as ObjectFieldDictionary;
ObjectFieldList parentDestList = destField.Parent as ObjectFieldList;
ObjectField clonedField = draggedField.Clone() as ObjectField;
if (clonedField != null)
{
clonedField.Parent = destField.Parent;
//TODO: The cloned field still wraps the uncloned value. Cloning this is not easy since
// we can't use Clone() on it since it could not be implemented.
if (parentDestDict != null)
{
parentDestDict.Add(clonedField);
}
else if (parentDestList != null)
{
int index = parentDestList.Items.IndexOf(destField);
index += trvTree.DropPosition.Position == NodePosition.After ? 1 : 0;
parentDestList.Insert(index, clonedField);
}
}
}
}
}
}
}
private void Search()
{
// リセット処理
if (_missingData.Count > 0)
{
_missingData.Clear();
_resultVisualElement.Clear();
}
var allPaths = AssetDatabase.GetAllAssetPaths()
.Where(_ => Path.GetExtension(_) == ExtensionPath && Path.GetDirectoryName(_) == DirectoryName).ToList();
foreach (var path in allPaths)
{
SearchMissing(path);
}
// Missingがある時
if (_missingData.Count <= 0)
{
return;
}
// UXMLのUIを表示
var uxmlVisualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/MissingCheckResult.uxml");
var styleSheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Editor/MissingCheck.uss");
VisualElement ve = uxmlVisualTree.CloneTree();
ve.styleSheets.Add(styleSheet);
_resultVisualElement.Add(ve);
var scrollView = new ScrollView();
scrollView.name = "scroll";
scrollView.verticalPageSize = 200;
_resultVisualElement.Add(scrollView);
scrollView.styleSheets.Add(styleSheet);
for (int i = 0; i < _missingData.Count; i++)
{
Label pathLabel = new Label(_missingData[i].MissingPath);
scrollView.Add(pathLabel);
ObjectField objectField = new ObjectField("該当Prefab:");
objectField.objectType = typeof(GameObject);
objectField.SetValueWithoutNotify(_missingData[i].MissingPrefab);
scrollView.Add(objectField);
}
rootVisualElement.Add(_resultVisualElement);
}
public override VisualElement CreateInspectorGUI()
{
currentSettings = target as ActiveLocalizationSettings;
rootElement = new VisualElement {
name = "ActiveSettings"
};
activeSettingsField = new ObjectField("Active Settings")
{
objectType = typeof(LocalizationSettings)
};
activeSettingsField.BindProperty(new SerializedObject(currentSettings).FindProperty("activeSettings"));
activeSettingsField.RegisterValueChangedCallback(evt => {
if (evt.previousValue == null && evt.newValue != null)
{
createAssetContainer.AddToClassList("hidden");
}
else if (evt.previousValue != null && evt.newValue == null)
{
createAssetContainer.RemoveFromClassList("hidden");
}
OnActiveSettingsChanged?.Invoke(evt.newValue as LocalizationSettings);
if (evt.newValue == null)
{
EditorPrefs.DeleteKey(Constants.ACTIVE_SETTINGS_PREFS_KEY);
}
else
{
var assetPath = AssetDatabase.GetAssetPath(evt.newValue);
EditorPrefs.SetString(Constants.ACTIVE_SETTINGS_PREFS_KEY, assetPath);
}
});
createAssetContainer = new VisualElement();
createAssetContainer.Add(new HelpBox("There is no active Localization Settings selected. Would you like to create one?", HelpBoxMessageType.Info));
var createAssetButton = new Button(TriggerCreateAsset)
{
text = "Create"
};
createAssetContainer.Add(createAssetButton);
if (currentSettings.ActiveSettings != null)
{
createAssetContainer.AddToClassList("hidden");
}
activeSettingsField.value = currentSettings.ActiveSettings;
rootElement.Add(activeSettingsField);
rootElement.Add(createAssetContainer);
return(rootElement);
}
public static string ExtractExtraData(Node node)
{
foreach (VisualElement ele in node.mainContainer)
{
if (ele is ObjectField)
{
ObjectField field = (ele as ObjectField);
string path = AssetDatabase.GetAssetPath(field.value);
return(AssetDatabase.AssetPathToGUID(path));
}
}
return(null);
}
public static void DrawControl(this FieldControl <GameObject> control)
{
ObjectField input = control.AddObjectField(typeof(GameObject), false);
input.value = control.value;
control.eventManager.AddListener <ListItemInputChange>(e => {
if (e.input != input)
{
return;
}
control.value = (GameObject)input.value;
control.eventManager.Raise <FieldControlUpdated <GameObject> >(new FieldControlUpdated <GameObject>(control));
});
}
private static void FieldAndIconPair(ObjectField iconField, VisualElement iconDisplay)
{
iconField.objectType = typeof(Sprite);
iconField.RegisterValueChangedCallback(evt =>
StyleBackgroundImage(iconDisplay, evt.newValue));
StyleBackgroundImage(iconDisplay, iconField.value);
void StyleBackgroundImage(VisualElement appliedTo, Object sprite)
{
appliedTo.style.backgroundImage =
new StyleBackground((sprite as Sprite).AsUnityNull()?.texture);
}
}
void BuildCubemapPropertyField(CubemapShaderProperty property)
{
var field = new ObjectField {
value = property.value.cubemap, objectType = typeof(Cubemap)
};
field.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change property value");
property.value.cubemap = (Cubemap)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
void BuildTexture3DPropertyField(Texture3DShaderProperty property)
{
var field = new ObjectField {
value = property.value.texture, objectType = typeof(Texture3D)
};
field.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change property value");
property.value.texture = (Texture3D)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
private bool DrawBaseField(FieldInfo fieldInfo, string parentPath, int indent)
{
VisualElement element = null;
var path = (string.IsNullOrEmpty(parentPath)) ? fieldInfo.Name : $"{parentPath}/{fieldInfo.Name}";
if (fieldInfo.FieldType == typeof(int))
{
element = PropertyItem.CreatItem <IntegerField, int>(new IntegerField(fieldInfo.Name), _target, path, indent);
}
else if (fieldInfo.FieldType == typeof(float))
{
element = PropertyItem.CreatItem <FloatField, float>(new FloatField(fieldInfo.Name), _target, path, indent);
}
else if (fieldInfo.FieldType == typeof(string))
{
element = PropertyItem.CreatItem <TextField, string>(new TextField(fieldInfo.Name), _target, path, indent);
}
else if (fieldInfo.FieldType.IsEnum)
{
var field = new EnumField(fieldInfo.Name, (Enum)Activator.CreateInstance(fieldInfo.FieldType));
element = PropertyItem.CreatItem <EnumField, Enum>(field, _target, path, indent);
}
else if (fieldInfo.FieldType == typeof(Object) || fieldInfo.FieldType.IsSubclassOf(typeof(Object)))
{
var field = new ObjectField(fieldInfo.Name)
{
objectType = fieldInfo.FieldType
};
element = PropertyItem.CreatItem <ObjectField, Object>(field, _target, path, indent);
}
else if (fieldInfo.FieldType == typeof(Vector3))
{
var field = new Vector3Field(fieldInfo.Name);
element = PropertyItem.CreatItem <Vector3Field, Vector3>(field, _target, path, indent);
}
if (element != null)
{
if (_container == null)
{
Add(element);
}
else
{
_container.Add(element);
}
return(true);
}
return(false);
}
private static void CollectTypeSystemDirectives(
HashSet <string> processed,
List <IDirective> directives,
ObjectField field)
{
foreach (IDirective directive in field.ExecutableDirectives)
{
if (!processed.Add(directive.Name))
{
directives.Remove(directive);
}
directives.Add(directive);
}
}
protected virtual void CreateNewShader(VisualElement shaderCreationUI, ObjectField shaderField)
{
// TODO: create a popupwindow instead of a context menu
var menu = new GenericMenu();
var dim = (OutputDimension)shaderNode.settings.GetResolvedTextureDimension(owner.graph);
#if MIXTURE_SHADERGRAPH
GUIContent shaderGraphContent = EditorGUIUtility.TrTextContentWithIcon("Graph", Resources.Load <Texture2D>("sg_graph_icon@64"));
menu.AddItem(shaderGraphContent, false, () => SetShader(MixtureEditorUtils.CreateNewShaderGraph(owner.graph, title, dim), shaderCreationUI, shaderField));
#endif
GUIContent shaderTextContent = EditorGUIUtility.TrTextContentWithIcon("Text", "Shader Icon");
menu.AddItem(shaderTextContent, false, () => SetShader(MixtureEditorUtils.CreateNewShaderText(owner.graph, title, dim), shaderCreationUI, shaderField));
menu.ShowAsContext();
}
private IEnumerable <IDirective> GetFieldSelectionDirectives(
ObjectField field,
FieldNode selection)
{
foreach (DirectiveNode directive in selection.Directives)
{
if (_schema.TryGetDirectiveType(directive.Name.Value,
out DirectiveType directiveType) &&
directiveType.IsExecutable)
{
yield return(new Directive(directiveType, directive, field));
}
}
}
private static BindableElement GetField(Type type)
{
var map = GetValueElementMap();
if (map.TryGetValue(type, out var be))
{
var inst = Activator.CreateInstance(be) as BindableElement;
return inst;
}
var of = new ObjectField();
of.objectType = type;
return of;
}
public override RegisterLabelContext Visit(ObjectField objectField)
{
string nextRegister1 = _state.NewRegister, nextRegister2 = _state.NewRegister;
var objectExpr = Visit(objectField.IdExpr);
var field = _globalState.NameToClass[objectExpr.Type.GetText()].Fields[objectField.FieldId];
_llvmGenerator.Emit($"{nextRegister1} = getelementptr %{objectExpr.Type.GetText()}, " +
$"%{objectExpr.Type.GetText()}* {objectExpr.Register}, i32 0, i32 {field.Number + 1}");
_llvmGenerator.Emit($"{nextRegister2} = load {AstToLlvmString.Type(field.Type)}, " +
$"{AstToLlvmString.Type(field.Type)}* {nextRegister1}");
return(new RegisterLabelContext(nextRegister2, _state.CurrentLabel, field.Type));
}
void Init(bool autoLayout)
{
if (config.type is RuntimeType)
{
if (config.owner.targetNode.owner.IsRuntimeGraph())
{
var field = new ObjectRuntimeField()
{
objectType = config.type as RuntimeType,
value = config.value as UnityEngine.Object,
allowSceneObjects = uNodeEditorUtility.IsSceneObject(config.owner.targetNode)
};
field.RegisterValueChangedCallback((e) => {
config.OnValueChanged(e.newValue);
MarkDirtyRepaint();
});
Add(field);
}
else
{
var button = new Label()
{
text = "null"
};
button.AddToClassList("PopupButton");
button.EnableInClassList("Layout", autoLayout);
Add(button);
// if(config.value != null) {
// try {
// config.OnValueChanged(null);
// } catch{ }
// }
}
}
else
{
ObjectField field = new ObjectField()
{
objectType = config.type,
value = config.value as UnityEngine.Object,
};
field.RegisterValueChangedCallback((e) => {
config.OnValueChanged(e.newValue);
MarkDirtyRepaint();
});
field.allowSceneObjects = uNodeEditorUtility.IsSceneObject(config.owner.targetNode) && !GraphUtility.IsTempGraphObject(config.owner.targetNode.gameObject);
Add(field);
}
}
void AddShaderFields()
{
ObjectField initializationShader = new ObjectField("Initialization")
{
value = node.initializationMaterial.shader,
objectType = typeof(Shader),
};
initializationShader.RegisterValueChangedCallback((v) => {
owner.RegisterCompleteObjectUndo("Updated Shader of ShaderNode");
node.initializationMaterial.shader = (Shader)v.newValue;
// TODO: factorize the code
// UpdateShaderCreationUI();
// We fore the update of node ports
ForceUpdatePorts();
});
controlsContainer.Add(new Button(OpenCurrentShader)
{
text = "Open"
});
void OpenCurrentShader()
{
AssetDatabase.OpenAsset(node.updateMaterial.shader);
}
ObjectField shaderField = new ObjectField("Update")
{
value = node.updateMaterial.shader,
objectType = typeof(Shader),
};
shaderField.RegisterValueChangedCallback((v) => {
owner.RegisterCompleteObjectUndo("Updated Shader of ShaderNode");
node.updateMaterial.shader = (Shader)v.newValue;
// TODO: factorize the code
// UpdateShaderCreationUI();
// We fore the update of node ports
ForceUpdatePorts();
});
controlsContainer.Add(initializationShader);
controlsContainer.Add(shaderField);
}
private void UpdateChoices(SerializedProperty property, InputActionAsset inputActionAsset, VisualElement result)
{
result.Clear();
if (inputActionAsset == null)
{
var propertyField = new ObjectField(property.displayName);
propertyField.SetEnabled(false);
result.Add(propertyField);
return;
}
var assetReferences = AssetDatabase
.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(inputActionAsset))
.OfType <InputActionReference>()
.ToList();
// Ugly hack: GenericMenu interprets "/" as a submenu path. But luckily, "/" is not the only slash we have in Unicode.
var choices = inputActionAsset.Select(a => a.actionMap.name + "\uFF0F" + a.name).ToList();
choices.Insert(0, "None");
var references = inputActionAsset.Select(a => assetReferences.Find(r => a == r.action)).ToList();
references.Insert(0, null);
var field = new PopupField <string>(property.displayName, choices, 0);
{
var selectedAction = ((InputActionReference)property.objectReferenceValue)?.action;
field.value = choices[Mathf.Max(0, references.FindIndex(a => (a == null ? null : a.action) == selectedAction))];
}
field.RegisterCallback <ChangeEvent <string> >(ev =>
{
property.objectReferenceValue = references[Mathf.Clamp(field.index, 0, references.Count - 1)];
property.serializedObject.ApplyModifiedProperties();
});
field.schedule.Execute(() =>
{
//if (!property.isValid) return;
if (!property.Next(false))
{
return;
}
var selectedAction = ((InputActionReference)property.objectReferenceValue)?.action;
field.value = choices[Mathf.Max(0, references.FindIndex(a => (a == null ? null : a.action) == selectedAction))];
}).Every(100);
result.Add(field);
}
public override VisualElement CreateInspectorGUI()
{
#region Fields
// Find the visual element with the name "systemSprite" and make it display the star system sprite if it has one.
VisualElement systemSprite = rootElement.Query <VisualElement>("systemSprite").First();
systemSprite.style.backgroundImage = starSystem.sprite ? starSystem.sprite.texture : null;
// Find an object field with the name "systemSpriteField", set that it only accepts objects of type Sprite,
// set its initial value and register a callback that will occur if the value of the filed changes.
ObjectField spriteField = rootElement.Query <ObjectField>("systemSpriteField").First();
spriteField.objectType = typeof(Sprite);
spriteField.value = starSystem.sprite;
spriteField.RegisterCallback <ChangeEvent <Object> >(
e =>
{
starSystem.sprite = (Sprite)e.newValue;
systemSprite.style.backgroundImage = starSystem.sprite.texture;
// Set StarSystem as being dirty. This tells the editor that there have been changes made to the asset and that it requires a save.
EditorUtility.SetDirty(starSystem);
}
);
FloatField scaleField = rootElement.Query <FloatField>("starScale").First();
scaleField.value = starSystem.scale;
scaleField.RegisterCallback <ChangeEvent <float> >(
e => {
starSystem.scale = e.newValue;
EditorUtility.SetDirty(starSystem);
}
);
#endregion
#region Display Planet Data
// Store visual element that will contain the planet sub-inspectors.
planetList = rootElement.Query <VisualElement>("planetList").First();
UpdatePlanets();
#endregion
#region Buttons
// Assign methods to the click events of the two buttons.
Button btnAddPlanet = rootElement.Query <Button>("btnAddNew").First();
btnAddPlanet.clickable.clicked += AddPlanet;
Button btnRemoveAllPlanets = rootElement.Query <Button>("btnRemoveAll").First();
btnRemoveAllPlanets.clickable.clicked += RemoveAll;
#endregion
return(rootElement);
}
protected GameObject DrawObjectField()
{
Div container;
ListItem titleItem = DrawShelf("Model", out container);
ListItem objectItem = new ListItem();
objectItem.AddLabel("Resource:", true);
ObjectField objectField = objectItem.AddObjectField(typeof(GameObject));
GameObject gameObject = ((ModelBank)collection).LoadModel(chosenKey);
if (gameObject != null)
{
objectField.value = gameObject;
}
objectItem.eventManager.AddListener <ListItemInputChange>(e => {
if (e.input == objectField)
{
string assetPath = AssetDatabase.GetAssetPath(objectField.value);
if (objectField.value == null)
{
((ModelBank)collection).SetResourcePath(chosenKey, assetPath);
eventManager.Raise <SetSceneDirtyEvent>(new SetSceneDirtyEvent(SceneManager.GetActiveScene()));
eventManager.Raise <DrawColumnEventArgs <string> >(new DrawColumnEventArgs <string>(1));
return;
}
if (assetPath.Contains(@"/Resources/"))
{
((ModelBank)collection).SetResourcePath(chosenKey, assetPath);
eventManager.Raise <SetSceneDirtyEvent>(new SetSceneDirtyEvent(SceneManager.GetActiveScene()));
eventManager.Raise <DrawColumnEventArgs <string> >(new DrawColumnEventArgs <string>(1));
}
else
{
if (objectField.value != null)
{
Debug.LogWarning("Not Resource");
objectField.value = null;
}
}
}
});
container.Add(objectItem);
entryEditorScroller.Add(titleItem, container);
return(gameObject);
}
void CreateRunInUnitySimulationUI()
{
var root = rootVisualElement;
AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(
$"{StaticData.uxmlDir}/RunInUnitySimulationWindow.uxml").CloneTree(root);
m_RunNameField = root.Q <TextField>("run-name");
SetViewDataKey(m_RunNameField);
m_TotalIterationsField = root.Q <IntegerField>("total-iterations");
SetViewDataKey(m_TotalIterationsField);
m_InstanceCountField = root.Q <IntegerField>("instance-count");
SetViewDataKey(m_InstanceCountField);
m_MainSceneField = root.Q <ObjectField>("main-scene");
m_MainSceneField.objectType = typeof(SceneAsset);
if (SceneManager.sceneCount > 0)
{
var path = SceneManager.GetSceneAt(0).path;
var asset = AssetDatabase.LoadAssetAtPath <SceneAsset>(path);
m_MainSceneField.value = asset;
}
m_ScenarioField = root.Q <ObjectField>("scenario");
m_ScenarioField.objectType = typeof(ScenarioBase);
m_ScenarioField.value = FindObjectOfType <ScenarioBase>();
var sysParamDefinitions = API.GetSysParams();
var sysParamMenu = root.Q <ToolbarMenu>("sys-param");
foreach (var definition in sysParamDefinitions)
{
sysParamMenu.menu.AppendAction(
definition.description,
action =>
{
m_SysParam = definition;
sysParamMenu.text = definition.description;
});
}
sysParamMenu.text = sysParamDefinitions[0].description;
m_SysParam = sysParamDefinitions[0];
m_RunButton = root.Q <Button>("run-button");
m_RunButton.clicked += RunInUnitySimulation;
}
public HeroCharacter(ObjectField objectField, ItemHeroEntity heroEntity, ItemHeroLevel itemHeroLevel, int[] equipIds, bool toLeft, InGameUser user, PuzzlePanel puzzlePanel, Buff.Handle onBuff, Buff.Handle onDeBuff)
: base(E_OverlapEvent.Collision, objectField, toLeft)
{
this.heroEntity = heroEntity;
this.user = user;
this.puzzlePanel = puzzlePanel;
InitStat(itemHeroLevel.Level, equipIds);
InitStatus(onBuff, onDeBuff);
RegistActions();
int skillId = heroEntity.ActiveSkill1;
SkillCommand skillCommand = InitSkill(this, skillId, itemHeroLevel.Level);
AddCommandSet("skill", 1, false, E_CommandConsume.Skill, null).TryAdd(skillCommand);
}
public MoneyObstacle(ObjectField objectField, ObjectStage objectStage, ItemDropManager itemDropManager, FSM parentFsm)
: base(objectField, objectStage, itemDropManager, parentFsm)
{
InitStatus<Mob>(
new object[] { Mob.Gold, 0, 100000, 0 }
);
RegisterDeathCondition(
delegate(Status current)
{
return current.Get(Mob.Gold) > 0;
}
);
AddAction(Action.E_Type.Money,
delegate(float value, GameInstance firer, string[] param)
{
return new ActionHandler.Result(Mob.Gold, value);
}
);
}
protected override void OnInitialize()
{
Vector2 winSize = new Vector3( 312.0f, 265.0f );
maxSize = winSize;
minSize = winSize;
autoRepaintOnSceneChange = true;
m_root = new Control();
m_root.SetSize( 100.0f, 100.0f, Control.MetricsUnits.Percentage, Control.MetricsUnits.Percentage );
m_root.AddDecorator( new StackContent() );
AddChild( m_root );
// Input object field
m_original = new ObjectField( typeof( GameObject ), true, null, "Original" );
m_original.SetHeight( 26.0f, Control.MetricsUnits.Pixel );
m_original.SetWidth( 100.0f, Control.MetricsUnits.Percentage );
m_original.SetMargin( 5.0f, 5.0f, 5.0f, 5.0f );
m_root.AddChild( m_original );
// Rotation pivot point
m_pivot = new Vector3Field( Vector3.zero, "Pivot:" );
m_pivot.SetHeight( 40.0f, Control.MetricsUnits.Pixel );
m_pivot.SetWidth( 100.0f, Control.MetricsUnits.Percentage );
m_pivot.SetMargin( 5.0f, 5.0f, 5.0f, 5.0f );
m_root.AddChild( m_pivot );
// Transform control
m_transform = new TransformControl();
m_transform.SetWidth( 100.0f, Control.MetricsUnits.Percentage );
m_transform.SetMargin( 5.0f, 5.0f, 5.0f, 5.0f );
m_root.AddChild( m_transform );
// Count field
m_count = new IntField( 1, "Duplicate Count:" );
m_count.SetHeight( 26.0f, Control.MetricsUnits.Pixel );
m_count.SetWidth( 100.0f, Control.MetricsUnits.Percentage );
m_count.SetMargin( 5.0f, 5.0f, 5.0f, 5.0f );
m_root.AddChild( m_count );
// Space field
m_space = new EnumDropdown( Space.World, "Space:" );
m_space.SetHeight( 26.0f, Control.MetricsUnits.Pixel );
m_space.SetWidth( 100.0f, Control.MetricsUnits.Percentage );
m_space.SetMargin( 5.0f, 5.0f, 5.0f, 5.0f );
m_root.AddChild( m_space );
// Duplicate button
m_duplicate = new Button( "Duplicate" );
m_duplicate.SetWidth( 100.0f, Control.MetricsUnits.Percentage );
m_duplicate.SetMargin( 5.0f, 5.0f, 5.0f, 5.0f );
m_duplicate.Enabled = false;
m_root.AddChild( m_duplicate );
// Events
m_original.ValueChange += m_original_ValueChange;
m_count.ValueChange += m_count_ValueChange;
m_duplicate.Clicked += m_duplicate_Clicked;
SceneView.onSceneGUIDelegate += SceneViewGUI;
}
public SpotBuffer(ObjectField objectField, ObjectStage objectStage, ItemDropManager itemDropManager, FSM parentFsm)
: base(objectField, objectStage, itemDropManager, parentFsm, GetRandomBuffer())
{
InitFSM("Shrine.fsm", this, false);
}
public BossMonster(ObjectField objectField, ObjectStage objectStage, ItemDropManager itemDropManager, FSM parentFsm)
: base(objectField, objectStage, itemDropManager, parentFsm)
{
}
public StageEndDoor(ObjectField objectField, ObjectStage objectStage, ItemDropManager itemDropManager, FSM parentFsm)
: base(objectField, objectStage, itemDropManager, parentFsm)
{
}
/// <summary>
/// Gets an object's field addresses.
/// </summary>
/// <param name="objectNumber">
/// The object number.
/// </param>
/// <param name="objectField">
/// The object field.
/// </param>
/// <returns>
/// The object's field addresses.
/// </returns>
private int GetFieldAddress(ushort objectNumber, ObjectField objectField)
{
return this.GetObjectAddress(objectNumber) + this.AttributeFieldlength + (this.ObjectFieldLength * (byte)objectField);
}
protected Automaton(E_OverlapEvent overlapEvent, ObjectField objectField, bool toLeft)
: base(overlapEvent, objectField, toLeft)
{
this.commandQueue = new Dictionary<string, CommandSet>();
}
public ActionCollider(Layer layer, float initX, ObjectField objectField, bool toLeft)
: base(E_OverlapEvent.Collision, objectField, toLeft)
{
}
/// <summary>
/// Reads an object field.
/// </summary>
/// <param name="objectNumber">
/// The object number.
/// </param>
/// <param name="objectField">
/// The object field.
/// </param>
/// <returns>
/// The field value.
/// </returns>
private ushort ReadField(ushort objectNumber, ObjectField objectField)
{
if (this.InvalidObject(objectNumber))
{
this.FrontEnd.ErrorNotification(ErrorCondition.InvalidObject, "Tried to read " + objectField + " of invalid object " + objectNumber + ".");
return 0;
}
return this.ReadField(this.GetFieldAddress(objectNumber, objectField));
}
public ProjectileCustom(GameInstance parent, float initX, float initY, ObjectField objectField, ObjectProjectile objectProjectile, Action action)
: base(parent, initX, initY, objectField, objectProjectile)
{
List<VectorEntity> pattern = VectorGenerator.Custom(objectProjectile.Speed, objectProjectile.SpeedY, objectProjectile.Gravity, parent.ToLeft);
//pattern.Add(new LinearVelocity(parent.Velocity));
SetMove(pattern);
InitAction(action);
}
public Spot(ObjectField objectField, ObjectStage objectStage, ItemDropManager itemDropManager, FSM parentFsm, string actionPattern)
: base(objectField, objectStage, itemDropManager, parentFsm)
{
this.actionPattern = actionPattern;
name = objectStage.Type.ToString();
}
/// <summary>
/// Writes to an object field.
/// </summary>
/// <param name="objectNumber">
/// The object number.
/// </param>
/// <param name="objectField">
/// The object field.
/// </param>
/// <param name="fieldValue">
/// The field value.
/// </param>
private void WriteField(ushort objectNumber, ObjectField objectField, ushort fieldValue)
{
if (this.InvalidObject(objectNumber))
{
this.FrontEnd.ErrorNotification(ErrorCondition.InvalidObject, "Tried to write " + objectField + " of invalid object " + objectNumber + ".");
return;
}
this.WriteField(this.GetFieldAddress(objectNumber, objectField), fieldValue);
}
public BattleObstacle(ObjectField objectField, ObjectStage objectStage, ItemDropManager itemDropManager, FSM parentFsm)
: base(objectField, objectStage, itemDropManager, parentFsm)
{
var statTable = StatLoader.Instance.GetStatTable<int, ObjectMonsterStat>("ObjectID");
Stat = statTable.Get(objectStage.ObjectID);
objectMonster = TableLoader.GetTable<ObjectMonster>().Get(objectStage.ObjectID);
name = StringTableLoader.Instance.Get(objectField.ObjectName);
InitStatus<Mob>(
new object[] { Mob.HP, 0, ObjectMonsterStat.MaximumLife, ObjectMonsterStat.MaximumLife, }
);
RegisterDeathCondition(
delegate(Status current)
{
return current.Get(Mob.HP) == 0;
}
);
AddAction(Action.E_Type.Attack,
delegate(float value, GameInstance firer, string[] param)
{
bool isCritical = false;
if (param != null)
{
foreach (var entity in param)
{
if (entity == "critical")
{
isCritical = true;
}
else if (entity == "charged")
{
FSMEvent("chargedAttack");
}
}
}
string meterRes = "FieldEffect/TextPhysicalDmg";
if (isCritical)
{
meterRes = "FieldEffect/TextPhysicCriticalDmg";
PlaySound(79);
}
float damage = OnHit(value, ObjectMonsterStat.damageReduction, meterRes);
return new ActionHandler.Result(Mob.HP, -damage);
}
);
AddAction(Action.E_Type.Suicide,
delegate(float value, GameInstance firer, string[] param)
{
RemoveOverlapEvent();
RemoveHUD();
FSMEvent("Suicide");
return new ActionHandler.Result(Mob.HP, 0);
}
);
/*
AddAction(Action.E_Type.Attack,
delegate(float value, GameInstance firer, string[] param)
{
bool isCritical = false;
if (param != null)
{
foreach (var entity in param)
{
if (entity == "critical")
{
isCritical = true;
}
}
}
string meterRes = "FieldEffect/TextMagicalDmg";
if (isCritical)
{
meterRes = "FieldEffect/TextMagicCriticalDmg";
PlaySound(79);
}
float damage = OnHit(value, ObjectMonsterStat.MagicResistance, meterRes);
return new ActionHandler.Result(Mob.HP, -damage);
}
);
AddAction(Action.E_Type.NoneDefensiveAttack,
delegate(float value, GameInstance firer, string[] param)
{
FSMEvent("damage");
CameraEffect.Instance.Flick(new Vector2(1, 1));
float damage = value;
AttachMeter("FieldEffect/TextMagicalDmg", (int)damage);
return new ActionHandler.Result(Mob.HP, -damage);
}
);
* */
AddAction(Action.E_Type.Buff,
delegate(float value, GameInstance firer, string[] param)
{
Buff.Handle onBuff = null;
Buff.Handle onDebuff = null;
int? buffID = Cast.To<int>(value);
Status.AddBuff(buffID.Value, firer.Stat, onBuff, onDebuff);
return new ActionHandler.Result(null, value);
}
);
AddAction(Action.E_Type.Dispel,
delegate(float value, GameInstance firer, string[] param)
{
Status.Dispel();
return new ActionHandler.Result(null, value);
}
);
if (!string.IsNullOrEmpty(objectMonster.fsm))
{
InitFSM(objectMonster.fsm, this, false);
}
}
