public void Render() { if (DELETED) { return; } if (!CanRender) { return; } GUILayout.BeginHorizontal(); FieldName = GUILayout.TextField(FieldName); FieldType = (ForgeAcceptableFieldTypes)EditorGUILayout.EnumPopup(FieldType, GUILayout.Width(75)); //if (FieldType == ForgeAcceptableFieldTypes.Unknown) //Unsupported //{ // Debug.LogError("Can't set the type to unknown (Not Allowed)"); // FieldType = AcceptableTypes.INT; //} if (ForgeClassFieldValue.IsInterpolatable(FieldType)) { GUI.color = Interpolate ? Color.white : Color.gray; if (GUILayout.Button("Interpolate", GUILayout.Width(100))) { Interpolate = !Interpolate; } if (Interpolate) { InterpolateValue = EditorGUILayout.FloatField(InterpolateValue, GUILayout.Width(50)); } else { InterpolateValue = ForgeNetworkingEditor.DEFAULT_INTERPOLATE_TIME; } } GUI.color = Color.white; Rect verticleButton = EditorGUILayout.BeginVertical("Button", GUILayout.Width(50), GUILayout.Height(10)); GUI.color = Color.red; if (GUI.Button(verticleButton, GUIContent.none)) { DELETED = true; } GUI.color = Color.white; GUILayout.BeginHorizontal(); //Center the icon EditorGUILayout.Space(); GUILayout.FlexibleSpace(); GUILayout.Label(ForgeNetworkingEditor.TrashIcon, GUILayout.Height(15)); GUILayout.FlexibleSpace(); GUILayout.EndHorizontal(); GUILayout.EndVertical(); GUILayout.EndHorizontal(); }
public void Render() { if (!CanRender) { return; } GUILayout.BeginHorizontal(); FieldName = GUILayout.TextField(FieldName); FieldType = (ForgeAcceptableFieldTypes)EditorGUILayout.EnumPopup(FieldType, GUILayout.Width(75)); //if (FieldType == ForgeAcceptableFieldTypes.Unknown) //Unsupported //{ // Debug.LogError("Can't set the type to unknown (Not Allowed)"); // FieldType = AcceptableTypes.INT; //} if (!Snapshot) { if (ForgeClassFieldValue.IsInterpolatable(FieldType)) { GUI.color = Interpolate ? Color.white : Color.gray; if (GUILayout.Button("Interpolate", GUILayout.Width(100))) { Interpolate = !Interpolate; } if (Interpolate) { if (InterpolateValue == 0) { InterpolateValue = ForgeNetworkingEditor.DEFAULT_INTERPOLATE_TIME; } else { InterpolateValue = EditorGUILayout.FloatField(InterpolateValue, GUILayout.Width(50)); } } else { InterpolateValue = 0; //InterpolateValue = ForgeNetworkingEditor.DEFAULT_INTERPOLATE_TIME; } } } }
public void Render(Rect rect, bool isActive, bool isFocused) { if (!CanRender) { return; } rect.y += 2; Rect changingRect = new Rect(rect.x, rect.y, rect.width * 0.3f, EditorGUIUtility.singleLineHeight); FieldName = EditorGUI.TextField(changingRect, FieldName); changingRect.x += rect.width * 0.3f + 5; FieldType = (ForgeAcceptableFieldTypes)EditorGUI.EnumPopup(changingRect, FieldType); if (!Snapshot) { if (ForgeClassFieldValue.IsInterpolatable(FieldType)) { changingRect.x += rect.width * 0.3f + 10; changingRect.width = rect.width * 0.2f; Interpolate = EditorGUI.ToggleLeft(changingRect, " Interpolate", Interpolate); if (Interpolate) { if (InterpolateValue == 0) { InterpolateValue = ForgeNetworkingEditor.DEFAULT_INTERPOLATE_TIME; } else { changingRect.x += rect.width * 0.2f + 5; changingRect.width = rect.width * 0.3f; InterpolateValue = EditorGUI.FloatField(changingRect, InterpolateValue); } } else { InterpolateValue = 0; } } } }
/// <summary> /// Generate a source network object based on the class and button provided /// </summary> /// <param name="cObj">The class we a generating</param> /// <param name="btn">The button that holds key information to this class</param> /// <param name="identity">The network identity that we will assing this class</param> /// <returns>The generated string to save to a file</returns> public string SourceCodeNetworkObject(ForgeClassObject cObj, ForgeEditorButton btn, int identity) { TextAsset asset = Resources.Load <TextAsset>(EDITOR_RESOURCES_DIR + "/NetworkObjectTemplate"); TemplateSystem template = new TemplateSystem(asset.text); template.AddVariable("className", btn.StrippedSearchName + "NetworkObject"); template.AddVariable("identity", cObj == null ? identity : cObj.IdentityValue); template.AddVariable("bitwiseSize", Math.Ceiling(btn.ClassVariables.Count / 8.0)); List <object[]> variables = new List <object[]>(); List <object[]> rewinds = new List <object[]>(); string interpolateValues = string.Empty; string interpolateType = string.Empty; int i = 0, j = 0; for (i = 0, j = 0; i < btn.ClassVariables.Count; ++i) { Type t = ForgeClassFieldValue.GetTypeFromAcceptable(btn.ClassVariables[i].FieldType); interpolateType = ForgeClassFieldValue.GetInterpolateFromAcceptable(btn.ClassVariables[i].FieldType); if (i != 0 && i % 8 == 0) { j++; } object[] fieldData = new object[] { _referenceVariables[t.Name], // Data type btn.ClassVariables[i].FieldName.Replace(" ", string.Empty), // Field name btn.ClassVariables[i].Interpolate, // Interpolated interpolateType, // Interpolate type btn.ClassVariables[i].InterpolateValue, // Interpolate time _referenceBitWise[i % 8], // Hexcode j // Dirty fields index }; if (i + 1 < btn.ClassVariables.Count) { interpolateValues += btn.ClassVariables[i].InterpolateValue.ToString() + ","; } else { interpolateValues += btn.ClassVariables[i].InterpolateValue.ToString(); } variables.Add(fieldData); } // TODO: This should relate to the rewind variables for (i = 0; i < 0; i++) { object[] rewindData = new object[] { "Vector3", // The data type for this rewind "Position", // The name except with the first letter uppercase 5000 // The time in ms for this rewind to track }; rewinds.Add(rewindData); } template.AddVariable("variables", variables.ToArray()); template.AddVariable("rewinds", rewinds.ToArray()); template.AddVariable("interpolateValues", interpolateValues.Replace("\"", "\\\"")); return(template.Parse()); }
public ForgeClassObject(string location) { this.FileLocation = location; this.Filename = Path.GetFileName(FileLocation); this.ExactFilename = Path.GetFileNameWithoutExtension(FileLocation); if (ExactFilename == "NetworkManager") { return; } List <float> _interpolationValues = new List <float>(); JSONNode typeData = null; JSONNode typeHelperData = null; JSONNode interpolData = null; Type currentType = GetType("BeardedManStudios.Forge.Networking.Generated." + this.ExactFilename); GeneratedRPCAttribute aRPC = (GeneratedRPCAttribute)Attribute.GetCustomAttribute(currentType, typeof(GeneratedRPCAttribute)); GeneratedRPCVariableNamesAttribute aNames = (GeneratedRPCVariableNamesAttribute)Attribute.GetCustomAttribute(currentType, typeof(GeneratedRPCVariableNamesAttribute)); GeneratedInterpolAttribute aInterpol = (GeneratedInterpolAttribute)Attribute.GetCustomAttribute(currentType, typeof(GeneratedInterpolAttribute)); if (aRPC != null && !string.IsNullOrEmpty(aRPC.JsonData)) { typeData = JSON.Parse(aRPC.JsonData); } else { typeData = new JSONClass(); } if (aNames != null && !string.IsNullOrEmpty(aNames.JsonData)) { typeHelperData = JSON.Parse(aNames.JsonData); } else { typeHelperData = new JSONClass(); } if (aInterpol != null && !string.IsNullOrEmpty(aInterpol.JsonData)) { interpolData = JSON.Parse(aInterpol.JsonData); } else { interpolData = new JSONClass(); } #if FORGE_EDITOR_DEBUGGING string forgeClassDebug = "Loaded - " + this.ExactFilename + System.Environment.NewLine; #endif List <MethodInfo> uniqueMethods = new List <MethodInfo>(); List <PropertyInfo> uniqueProperties = new List <PropertyInfo>(); List <FieldInfo> uniqueFields = new List <FieldInfo>(); if (currentType == null) { throw new NullReferenceException("CANNOT PUT SOURCE CODE IN GENERATED FOLDER! PLEASE REMOVE NON GENERATED CODE!"); } MethodInfo[] methods = currentType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy).Where(m => m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType.FullName == "BeardedManStudios.Forge.Networking.RpcArgs").ToArray(); PropertyInfo[] properties = currentType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy); FieldInfo[] fields = currentType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy); uniqueMethods.AddRange(methods); uniqueProperties.AddRange(properties); uniqueFields.AddRange(fields); if (currentType.BaseType != null) { Type baseType = currentType.BaseType; Type networkBehavior = currentType.GetInterface("INetworkBehavior"); Type factoryInterface = currentType.GetInterface("INetworkObjectFactory"); bool isMonobehavior = currentType.IsSubclassOf(typeof(MonoBehaviour)); if (baseType.FullName == "BeardedManStudios.Forge.Networking.NetworkObject") { ObjectClassType = ForgeBaseClassType.NetworkObject; IdentityValue = ++IDENTITIES; } else if (networkBehavior != null && !isMonobehavior) { ObjectClassType = ForgeBaseClassType.NetworkBehavior; } else if (baseType == typeof(MonoBehaviour) || isMonobehavior) { ObjectClassType = ForgeBaseClassType.MonoBehavior; } else if (factoryInterface != null) { ObjectClassType = ForgeBaseClassType.ObjectFactory; } else if (baseType == typeof(Enum)) { ObjectClassType = ForgeBaseClassType.Enums; } else { ObjectClassType = ForgeBaseClassType.Custom; } MethodInfo[] baseMethods = baseType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy); PropertyInfo[] baseProperties = baseType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy); FieldInfo[] baseFields = baseType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy); for (int i = 0; i < baseMethods.Length; ++i) { for (int x = 0; x < uniqueMethods.Count; ++x) { if (uniqueMethods[x].Name == baseMethods[i].Name && uniqueMethods[x].GetParameters().Length == baseMethods[i].GetParameters().Length) { var argsA = uniqueMethods[x].GetParameters(); var argsB = baseMethods[i].GetParameters(); bool same = true; for (int j = 0; j < argsA.Length; j++) { if (!argsA[j].Equals(argsB[j])) { same = false; break; } } if (same) { uniqueMethods.RemoveAt(x); } break; } } } for (int i = 0; i < baseProperties.Length; ++i) { for (int x = 0; x < uniqueProperties.Count; ++x) { if (uniqueProperties[x].Name == baseProperties[i].Name) { uniqueProperties.RemoveAt(x); break; } } } for (int i = 0; i < baseFields.Length; ++i) { for (int x = 0; x < uniqueFields.Count; ++x) { if (uniqueFields[x].Name == baseFields[i].Name) { uniqueFields.RemoveAt(x); break; } } } } #region IGNORES for (int i = 0; i < uniqueFields.Count; ++i) { switch (uniqueFields[i].Name) { case "IDENTITY": case "networkObject": case "fieldAltered": case "_dirtyFields": case "dirtyFields": uniqueFields.RemoveAt(i--); //TODO: Store the types for re-use continue; } if (uniqueFields[i].Name.EndsWith("Changed")) { uniqueFields.RemoveAt(i--); continue; } if (uniqueFields[i].Name.EndsWith("Interpolation")) { uniqueFields.RemoveAt(i--); //TODO: Store the types for re-use continue; } } for (int i = 0; i < uniqueMethods.Count; ++i) { switch (uniqueMethods[i].Name.ToLower()) { case "initialize": case "networkcreateobject": uniqueMethods.RemoveAt(i--); continue; } if (uniqueMethods[i].Name.EndsWith("Changed")) { uniqueMethods.RemoveAt(i--); continue; } if (uniqueMethods[i].Name.StartsWith("get_") || uniqueMethods[i].Name.StartsWith("set_")) { uniqueMethods.RemoveAt(i--); continue; } } #endregion #if FORGE_EDITOR_DEBUGGING forgeClassDebug += "Properties:\n"; foreach (PropertyInfo a in uniqueProperties) { forgeClassDebug += a.Name + " (" + a.PropertyType + ")" + System.Environment.NewLine; } forgeClassDebug += System.Environment.NewLine; forgeClassDebug += "Fields:\n"; #endif if (ObjectClassType != ForgeBaseClassType.Enums) { if (interpolData != null) { JSONArray currentInterpolationVariables = interpolData["inter"].AsArray; if (currentInterpolationVariables != null) { for (int i = 0; i < currentInterpolationVariables.Count; ++i) { float interPolVal = currentInterpolationVariables[i].AsFloat; _interpolationValues.Add(interPolVal); } } } else { for (int i = 0; i < uniqueFields.Count; ++i) { _interpolationValues.Add(ForgeNetworkingEditor.DEFAULT_INTERPOLATE_TIME); } } for (int i = 0; i < uniqueFields.Count; ++i) { if (_interpolationValues.Count == 0) { break; } ForgeClassFieldValue val = ForgeClassFieldValue.GetClassField(uniqueFields[i], currentType, _interpolationValues[i] > 0, _interpolationValues[i]); Fields.Add(val); #if FORGE_EDITOR_DEBUGGING Debug.Log(val); forgeClassDebug += uniqueFields[i].Name + " (" + uniqueFields[i].FieldType + ")" + System.Environment.NewLine; #endif } } #if FORGE_EDITOR_DEBUGGING forgeClassDebug += System.Environment.NewLine; forgeClassDebug += "Methods:\n"; #endif List <List <ForgeAcceptableRPCTypes> > rpcSupportedTypes = new List <List <ForgeAcceptableRPCTypes> >(); if (typeData != null) { JSONArray currentRPCVariables = typeData["types"].AsArray; if (currentRPCVariables != null) { for (int i = 0; i < currentRPCVariables.Count; ++i) { JSONArray singularArray = currentRPCVariables[i].AsArray; if (singularArray != null) { List <ForgeAcceptableRPCTypes> singularSupportedTypes = new List <ForgeAcceptableRPCTypes>(); for (int x = 0; x < singularArray.Count; ++x) { ForgeAcceptableRPCTypes singularType = ForgeClassFieldRPCValue.GetTypeFromAcceptable(singularArray[x].Value); singularSupportedTypes.Add(singularType); } rpcSupportedTypes.Add(singularSupportedTypes); } } } } else { for (int i = 0; i < uniqueMethods.Count; ++i) { rpcSupportedTypes.Add(new List <ForgeAcceptableRPCTypes>()); } } List <List <string> > typeHelpers = new List <List <string> >(); if (typeHelperData != null) { JSONArray currentHelperRPCTypes = typeHelperData["types"].AsArray; if (currentHelperRPCTypes != null) { for (int i = 0; i < currentHelperRPCTypes.Count; ++i) { JSONArray singularHelperArray = currentHelperRPCTypes[i].AsArray; if (singularHelperArray != null) { List <string> singularSupportedTypes = new List <string>(new string[Mathf.Max(singularHelperArray.Count, rpcSupportedTypes.Count)]); for (int x = 0; x < singularHelperArray.Count; ++x) { string singularHelperType = singularHelperArray[x].Value.Replace(" ", string.Empty); singularSupportedTypes[x] = singularHelperType; } typeHelpers.Add(singularSupportedTypes); } } } } else { //This is missing the type helper data for (int i = 0; i < rpcSupportedTypes.Count; ++i) { typeHelpers.Add(new List <string>(new string[rpcSupportedTypes[i].Count])); } } for (int i = 0; i < uniqueMethods.Count; ++i) { RPCS.Add(new ForgeClassRPCValue(uniqueMethods[i], rpcSupportedTypes[i], typeHelpers[i])); #if FORGE_EDITOR_DEBUGGING ParameterInfo[] paramsInfo = a.GetParameters(); string parameters = ""; foreach (ParameterInfo info in paramsInfo) { parameters += info.ParameterType + ", "; } forgeClassDebug += a.Name + " (" + parameters + ")" + System.Environment.NewLine; #endif } #if FORGE_EDITOR_DEBUGGING forgeClassDebug += "Class Type: " + ObjectClassType; forgeClassDebug += "\nSearchName: " + StrippedSearchName; forgeClassDebug += "\nIsNetworkedObject: " + IsNetworkObject; forgeClassDebug += "\nIsNetworkBehavior: " + IsNetworkBehavior; forgeClassDebug += System.Environment.NewLine; Debug.Log(forgeClassDebug); #endif }