public override void NodeUI(UnityEditor.Graphs.GraphGUI host)
{
base.graphGUI = host as UnityEditor.Graphs.AnimationStateMachine.GraphGUI;
Assert.NotNull(base.graphGUI);
if (UnityEditor.Graphs.AnimationStateMachine.Node.IsLeftClick())
{
host.edgeGUI.EndSlotDragging(Enumerable.First<Slot>(base.inputSlots), true);
}
if (UnityEditor.Graphs.AnimationStateMachine.Node.IsDoubleClick())
{
if (this.stateMachine == base.graphGUI.stateMachineGraph.parentStateMachine)
{
base.graphGUI.tool.GoToBreadCrumbTarget(this.stateMachine);
}
else
{
base.graphGUI.tool.AddBreadCrumb(this.stateMachine);
}
Event.current.Use();
}
if (UnityEditor.Graphs.AnimationStateMachine.Node.IsRightClick() && (this.stateMachine != base.graphGUI.stateMachineGraph.parentStateMachine))
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Make Transition"), false, new GenericMenu.MenuFunction(this.MakeTransitionCallback));
menu.AddItem(new GUIContent("Copy"), false, new GenericMenu.MenuFunction(this.CopyStateMachineCallback));
menu.AddItem(new GUIContent("Delete"), false, new GenericMenu.MenuFunction(this.DeleteStateMachineCallback));
menu.ShowAsContext();
Event.current.Use();
}
}
/// <summary>
/// Construct from a Unity SceneSetup
/// </summary>
public SceneEntry( UnityEditor.SceneManagement.SceneSetup sceneSetup )
{
scene = new AmsSceneReference( sceneSetup.path );
loadInEditor = sceneSetup.isLoaded;
loadMethod = LoadMethod.Additive;
}
public override void Connect(UnityEditor.Graphs.AnimationStateMachine.Node toNode, UnityEditor.Graphs.Edge edge)
{
if (toNode is StateNode)
{
base.graphGUI.stateMachineGraph.rootStateMachine.AddAnyStateTransition((toNode as StateNode).state);
base.graphGUI.stateMachineGraph.RebuildGraph();
}
if (toNode is StateMachineNode)
{
StateMachineNode node = toNode as StateMachineNode;
if (node.stateMachine != base.graphGUI.parentStateMachine)
{
UnityEditor.Graphs.AnimationStateMachine.Node.GenericMenuForStateMachineNode(toNode as StateMachineNode, true, delegate (object data) {
if (data is AnimatorState)
{
base.graphGUI.stateMachineGraph.rootStateMachine.AddAnyStateTransition(data as AnimatorState);
}
else if (data is AnimatorStateMachine)
{
base.graphGUI.stateMachineGraph.rootStateMachine.AddAnyStateTransition(data as AnimatorStateMachine);
}
base.graphGUI.stateMachineGraph.RebuildGraph();
});
}
}
if (toNode is EntryNode)
{
base.graphGUI.stateMachineGraph.rootStateMachine.AddAnyStateTransition(base.graphGUI.activeStateMachine);
}
}
public override void NodeUI(UnityEditor.Graphs.GraphGUI host)
{
if (UnityEditor.Graphs.AnimationStateMachine.Node.IsLeftClick())
{
host.edgeGUI.EndSlotDragging(Enumerable.First<Slot>(base.inputSlots), true);
}
}
public static UnityEngine.Object[] GetFiltered(System.Type type, UnityEditor.SelectionMode mode)
{
ArrayList list = new ArrayList();
if ((type == typeof(Component)) || type.IsSubclassOf(typeof(Component)))
{
foreach (Transform transform in GetTransforms(mode))
{
Component component = transform.GetComponent(type);
if (component != null)
{
list.Add(component);
}
}
}
else if ((type == typeof(GameObject)) || type.IsSubclassOf(typeof(GameObject)))
{
foreach (Transform transform2 in GetTransforms(mode))
{
list.Add(transform2.gameObject);
}
}
else
{
foreach (UnityEngine.Object obj2 in GetObjectsMode(mode))
{
if ((obj2 != null) && ((obj2.GetType() == type) || obj2.GetType().IsSubclassOf(type)))
{
list.Add(obj2);
}
}
}
return (UnityEngine.Object[]) list.ToArray(typeof(UnityEngine.Object));
}
private static List<MemoryElement> GenerateObjectTypeGroups(UnityEditor.ObjectInfo[] memory, ObjectTypeFilter filter)
{
List<MemoryElement> list = new List<MemoryElement>();
MemoryElement item = null;
foreach (UnityEditor.ObjectInfo info in memory)
{
if (GetObjectTypeFilter(info) == filter)
{
if ((item == null) || (info.className != item.name))
{
item = new MemoryElement(info.className);
list.Add(item);
}
item.AddChild(new MemoryElement(info, true));
}
}
list.Sort(new Comparison<MemoryElement>(MemoryElementDataManager.SortByMemorySize));
foreach (MemoryElement element2 in list)
{
element2.children.Sort(new Comparison<MemoryElement>(MemoryElementDataManager.SortByMemorySize));
if ((filter == ObjectTypeFilter.Other) && !HasValidNames(element2.children))
{
element2.children.Clear();
}
}
return list;
}
public override void Connect(UnityEditor.Graphs.AnimationStateMachine.Node toNode, UnityEditor.Graphs.Edge edge)
{
if (toNode is StateNode)
{
base.graphGUI.stateMachineGraph.activeStateMachine.AddStateMachineTransition(this.stateMachine, (toNode as StateNode).state);
base.graphGUI.stateMachineGraph.RebuildGraph();
}
else if (toNode is StateMachineNode)
{
UnityEditor.Graphs.AnimationStateMachine.Node.GenericMenuForStateMachineNode(toNode as StateMachineNode, true, delegate (object data) {
if (data is AnimatorState)
{
base.graphGUI.stateMachineGraph.activeStateMachine.AddStateMachineTransition(this.stateMachine, data as AnimatorState);
}
else
{
base.graphGUI.stateMachineGraph.activeStateMachine.AddStateMachineTransition(this.stateMachine, data as AnimatorStateMachine);
}
base.graphGUI.stateMachineGraph.RebuildGraph();
});
}
else if (toNode is ExitNode)
{
base.graphGUI.stateMachineGraph.activeStateMachine.AddStateMachineExitTransition(this.stateMachine);
base.graphGUI.stateMachineGraph.RebuildGraph();
}
}
private static void SaveToIndex(UnityEditor.MenuCommand mc, int index) {
PositionSwapper ps = mc.context as PositionSwapper;
while (ps.Positions.Length <= index) {
UnityEditor.ArrayUtility.Add<Vector3>(ref ps.Positions, Vector3.zero);
}
ps.Positions[index] = ps.transform.localPosition;
}
public static void SetAttribute( UnityEditor.PropertyDrawer drawer, PropertyAttribute attribute )
{
FieldInfo fi = TargetType.GetField( "m_Attribute", BindingFlags.NonPublic | BindingFlags.Instance );
if( fi == null ){
Debug.Log( "Error, FieldInfo not found" );
return;
}
fi.SetValue( drawer, attribute );
}
public override void OnGUI(Rect position, UnityEditor.SerializedProperty property, GUIContent label)
{
string fieldName;
bool notifyPropertyChanged;
{
var attr = this.attribute as InspectorDisplayAttribute;
fieldName = (attr == null) ? "value" : attr.FieldName;
notifyPropertyChanged = (attr == null) ? true : attr.NotifyPropertyChanged;
}
if (notifyPropertyChanged)
{
EditorGUI.BeginChangeCheck();
}
var targetSerializedProperty = property.FindPropertyRelative(fieldName);
if (targetSerializedProperty == null)
{
UnityEditor.EditorGUI.LabelField(position, label, new GUIContent() { text = "InspectorDisplay can't find target:" + fieldName });
if (notifyPropertyChanged)
{
EditorGUI.EndChangeCheck();
}
return;
}
else
{
EmitPropertyField(position, targetSerializedProperty, label);
}
if (notifyPropertyChanged)
{
if (EditorGUI.EndChangeCheck())
{
var propInfo = fieldInfo.FieldType.GetProperty(fieldName, BindingFlags.IgnoreCase | BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
property.serializedObject.ApplyModifiedProperties(); // deserialize to field
var paths = property.propertyPath.Split('.'); // X.Y.Z...
var attachedComponent = property.serializedObject.targetObject;
var targetProp = (paths.Length == 1)
? fieldInfo.GetValue(attachedComponent)
: GetValueRecursive(attachedComponent, 0, paths);
var modifiedValue = propInfo.GetValue(targetProp, null); // retrieve new value
var methodInfo = fieldInfo.FieldType.GetMethod("SetValueAndForceNotify", BindingFlags.IgnoreCase | BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (methodInfo != null)
{
methodInfo.Invoke(targetProp, new object[] { modifiedValue });
}
}
else
{
property.serializedObject.ApplyModifiedProperties();
}
}
}
public static Type GetInspectedType( UnityEditor.CustomEditor editor )
{
if( m_InspectedType == null )
m_InspectedType = TargetType.GetField( "m_InspectedType", BindingFlags.NonPublic | BindingFlags.Instance );
if( m_InspectedType == null ){
Debug.Log( "FieldInfo Not Found" );
return null;
}
return m_InspectedType.GetValue( editor ) as Type;
}
////////////////////////////////////////
///////////GUI AND EDITOR STUFF/////////
////////////////////////////////////////
#if UNITY_EDITOR
protected override UnityEditor.GenericMenu OnContextMenu(UnityEditor.GenericMenu menu){
menu.AddItem( new GUIContent("Breakpoint"), isBreakpoint, ()=> { isBreakpoint = !isBreakpoint; } );
menu.AddItem (new GUIContent ("Convert to SubTree"), false, ()=> { MakeNestedSubTree(this); });
if (outConnections.Count > 0){
menu.AddItem (new GUIContent ("Delete Branch"), false, ()=> { DeleteBranch(this); } );
menu.AddItem(new GUIContent("Duplicate Branch"), false, ()=> { DuplicateBranch(this, graph); });
}
return menu;
}
public static void SetSerializedObject( UnityEditor.Editor editor, UnityEditor.SerializedObject obj )
{
if( m_SerializedObjectFieldInfo == null )
m_SerializedObjectFieldInfo = TargetType.GetField( "m_SerializedObject",
BindingFlags.NonPublic | BindingFlags.Instance );
if( m_SerializedObjectFieldInfo == null ){
Debug.Log( "FieldInfo Not Found" );
return;
}
m_SerializedObjectFieldInfo.SetValue( editor, obj );
}
// AnimatorController内のステートを取得する
private List<UnityEditor.Animations.AnimatorState> FindAnimationClips(
UnityEditor.Animations.AnimatorController animatorController)
{
var stateList = new List<UnityEditor.Animations.AnimatorState> ();
foreach (var layer in animatorController.layers) {
foreach (var state in layer.stateMachine.states) {
stateList.Add (state.state);
}
}
return stateList;
}
////////////////////////////////////////
///////////GUI AND EDITOR STUFF/////////
////////////////////////////////////////
protected override UnityEditor.GenericMenu OnContextMenu(UnityEditor.GenericMenu menu)
{
menu.AddItem( new GUIContent("Breakpoint"), isBreakpoint, ()=> { isBreakpoint = !isBreakpoint; } );
menu.AddItem (new GUIContent ("Convert to SubTree"), false, ()=> { MakeNestedSubTree(this); });
if (outConnections.Count > 0){
menu.AddItem (new GUIContent ("Delete Branch"), false, ()=> { DeleteBranch(this); } );
menu.AddItem(new GUIContent("Duplicate Branch"), false, ()=> { DuplicateBranch(this, graph); });
}
menu = EditorUtils.GetTypeSelectionMenu(typeof(BTComposite), (t)=>{ ReplaceWith(t); }, menu, "Replace");
return menu;
}
override public void OnGUI(Rect position, MaterialProperty prop, string label,
UnityEditor.MaterialEditor editor) {
EditorGUI.BeginChangeCheck();
prop.textureValue = editor.TextureProperty(prop, label);
if (EditorGUI.EndChangeCheck()) {
if (prop.textureValue == null) {
(editor.target as Material).DisableKeyword(keywordName + "_ON");
} else {
(editor.target as Material).EnableKeyword(keywordName + "_ON");
}
}
}
public static void OnPostProcessBuild(UnityEditor.BuildTarget buildTarget, string buildPath) {
string libpdcsharpTargetPath = Path.GetDirectoryName(buildPath) + Path.AltDirectorySeparatorChar + "libpdcsharp.dll";
string pthreadGC2TargetPath = Path.GetDirectoryName(buildPath) + Path.AltDirectorySeparatorChar + "pthreadGC2.dll";
if (!File.Exists(libpdcsharpTargetPath)) {
File.Copy(LibpdcsharpPath, libpdcsharpTargetPath);
}
if (!File.Exists(pthreadGC2TargetPath)) {
File.Copy(PthreadGC2Path, pthreadGC2TargetPath);
}
}
public override void NodeUI(UnityEditor.Graphs.GraphGUI host)
{
base.graphGUI = host as UnityEditor.Graphs.AnimationStateMachine.GraphGUI;
Assert.NotNull(base.graphGUI);
Event current = Event.current;
if (UnityEditor.Graphs.AnimationStateMachine.Node.IsRightClick())
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Make Transition"), false, new GenericMenu.MenuFunction(this.MakeTransitionCallback));
menu.ShowAsContext();
current.Use();
}
}
public static string GetPatchableResourcesPath(int iIdx, UnityEditor.BuildTarget eBuildTarget)
{
string sPath = GetRootResourcesPath();
Star.Foundation.CPath.AddRightSlash(ref sPath);
sPath += "patchable_resources_";
sPath += iIdx;
if (eBuildTarget == UnityEditor.BuildTarget.iOS) sPath += "/ios/";
else if (eBuildTarget == UnityEditor.BuildTarget.Android) sPath += "/android/";
else sPath += "/windows/";
return sPath;
}
void RefleshClipList (UnityEditor.Animations.AnimatorController controller)
{
if (controller == null)
return;
clipList.Clear ();
var allAsset = AssetDatabase.LoadAllAssetsAtPath (AssetDatabase.GetAssetPath (controller));
foreach (var asset in allAsset) {
if (asset is AnimationClip) {
var removeClip = asset as AnimationClip;
if (!clipList.Contains (removeClip)) {
clipList.Add (removeClip);
}
}
}
}
private static void OnUpdateComponents(UnityEditor.MenuCommand aCommand)
{
UIToggle context = aCommand.context as UIToggle;
UIImage image = context.GetComponentInChildren<UIImage>();
if(image != null)
{
image.GenerateMaterial();
image.GenerateMesh();
image.SetTexture();
image.SetColor();
}
UILabel label = context.GetComponentInChildren<UILabel>();
if(label != null)
{
label.UpdateComponents();
}
}
public static void PostProcessBuild(UnityEditor.BuildTarget target, string pathToBuiltProject)
{
const string DATA_FOLDER = "{0}_Data";
Debug.Log(string.Format("Post-processing build '{0}' at '{1}'.", target, pathToBuiltProject));
// The file name is integrated in some folder/file names of the built game. It may be needed to create references to these dynamic folders/files.
string fileName = Path.GetFileNameWithoutExtension(pathToBuiltProject);
// The build directory is the build path, without file name and extension and appended with the custom path.
string buildDirectory = Path.Combine(Path.Combine(Path.GetDirectoryName(pathToBuiltProject) ?? string.Empty,
string.Format(DATA_FOLDER, fileName)),
BUILD_LEVELS_FILE_DIRECTORY);
Debug.Log(string.Format("Detected levels file directory '{0}'.", buildDirectory));
WriteLevelsFile(buildDirectory);
Debug.Log("Post-processed build.");
}
public static void main(string[] args)
{
GameObject x=GameObject.Find("Cube");
Vector3[] newVertices = new[] { new Vector3(0f, 0f, 0f), new Vector3(1f, 1f, 1f), new Vector3(0f, 1f, 0f) };//changed initialization, it should work with colons but wasn't for me so will solve later.
//var newVertices : Vector3[];
Vector2[] newUV = new[] { new Vector2(0f, 0f), new Vector2(1f, 1f),new Vector2(0f,1f) };
//var newUV : Vector2;
int[] newTriangles={0,1,2};
//var newTriangles : int[];
// Mesh mesh = new Mesh();
//var mesh : Mesh = new Mesh ();
Mesh mesh;
MeshFilter objectmesh = x.GetComponent<MeshFilter>();// (MeshFilter.mesh.get);
mesh = objectmesh.sharedMesh;
//GetComponent.<MeshFilter>().mesh = mesh;
mesh.vertices = newVertices;
mesh.uv = newUV;
mesh.triangles = newTriangles;
}
private static ObjectTypeFilter GetObjectTypeFilter(UnityEditor.ObjectInfo info)
{
switch (info.reason)
{
case 1:
return ObjectTypeFilter.BuiltinResource;
case 2:
return ObjectTypeFilter.DontSave;
case 3:
case 8:
case 9:
return ObjectTypeFilter.Asset;
case 10:
return ObjectTypeFilter.Other;
}
return ObjectTypeFilter.Scene;
}
private static void UpdateSceneTable(UnityEditor.MenuCommand command)
{
GameEngine context = (GameEngine)command.context;
List<string> scenes = new List<string>();
string path;
foreach (UnityEditor.EditorBuildSettingsScene s in UnityEditor.EditorBuildSettings.scenes)
{
if (s.enabled)
{
int sep = s.path.IndexOf("Assets/Resources/");
if (sep == 0)
path = s.path.Substring(17, s.path.IndexOf('/', 17) - 17) + ":";
else
path = "";
sep = s.path.LastIndexOf('/');
scenes.Add(path + s.path.Substring(sep + 1, s.path.LastIndexOf('.') - sep - 1));
}
}
context.sceneTable = scenes.ToArray();
}
/**
* from build target group to human friendly string for display purpose.
*/
public static string GroupToHumaneString(UnityEditor.BuildTargetGroup g)
{
switch(g) {
case BuildTargetGroup.Android:
return "Android";
case BuildTargetGroup.iOS:
return "iOS";
case BuildTargetGroup.Nintendo3DS:
return "Nintendo 3DS";
case BuildTargetGroup.PS3:
return "PlayStation 3";
case BuildTargetGroup.PS4:
return "PlayStation 4";
case BuildTargetGroup.PSM:
return "PlayStation Mobile";
case BuildTargetGroup.PSP2:
return "PlayStation Vita";
case BuildTargetGroup.SamsungTV:
return "Samsung TV";
case BuildTargetGroup.Standalone:
return "PC/Mac/Linux Standalone";
case BuildTargetGroup.Tizen:
return "Tizen";
case BuildTargetGroup.tvOS:
return "tvOS";
case BuildTargetGroup.WebGL:
return "WebGL";
case BuildTargetGroup.WiiU:
return "Wii U";
case BuildTargetGroup.WSA:
return "Windows Store Apps";
case BuildTargetGroup.XBOX360:
return "Xbox 360";
case BuildTargetGroup.XboxOne:
return "Xbox One";
case BuildTargetGroup.Unknown:
return "Unknown";
default:
return g.ToString() + "(deprecated)";
}
}
public static BuildTarget GroupToTarget(UnityEditor.BuildTargetGroup g)
{
switch(g) {
case BuildTargetGroup.Android:
return BuildTarget.Android;
case BuildTargetGroup.iOS:
return BuildTarget.iOS;
case BuildTargetGroup.Nintendo3DS:
return BuildTarget.Nintendo3DS;
case BuildTargetGroup.PS3:
return BuildTarget.PS3;
case BuildTargetGroup.PS4:
return BuildTarget.PS4;
case BuildTargetGroup.PSM:
return BuildTarget.PSM;
case BuildTargetGroup.PSP2:
return BuildTarget.PSP2;
case BuildTargetGroup.SamsungTV:
return BuildTarget.SamsungTV;
case BuildTargetGroup.Standalone:
return BuildTarget.StandaloneWindows;
case BuildTargetGroup.Tizen:
return BuildTarget.Tizen;
case BuildTargetGroup.tvOS:
return BuildTarget.tvOS;
case BuildTargetGroup.WebGL:
return BuildTarget.WebGL;
case BuildTargetGroup.WiiU:
return BuildTarget.WiiU;
case BuildTargetGroup.WSA:
return BuildTarget.WSAPlayer;
case BuildTargetGroup.XBOX360:
return BuildTarget.XBOX360;
case BuildTargetGroup.XboxOne:
return BuildTarget.XboxOne;
default:
// temporarily assigned for default value (BuildTargetGroup.Unknown)
return (BuildTarget)int.MaxValue;
}
}
static void DrawSphere(float radius, Vector3 position, Quaternion rotation)
{
var vectorArray = new[] { rotation * Vector3.right, rotation * Vector3.up, rotation * Vector3.forward, rotation * -Vector3.right, rotation * -Vector3.up, rotation * -Vector3.forward };
float num4 = radius * radius;
Vector3 forward = position - Camera.current.transform.position;
float sqrMagnitude = forward.sqrMagnitude;
float f = (num4 * num4) / sqrMagnitude;
float y = Mathf.Sqrt(num4 - f);
Handles.DrawWireDisc(position - (((num4 * forward) / sqrMagnitude)), forward, y);
float num6 = f / num4;
for (int k = 0; k < 3; k++)
{
if (num6 < 1f)
{
float b = Vector3.Angle(forward, vectorArray[k]);
b = 90f - Mathf.Min(b, 180f - b);
float num10 = Mathf.Tan(b * 0.01745329f);
float num11 = Mathf.Sqrt(f + ((num10 * num10) * f)) / radius;
if (num11 < 1f)
{
float angle = Mathf.Asin(num11) * 57.29578f;
Vector3 from = Vector3.Cross(vectorArray[k], forward).normalized;
from = Quaternion.AngleAxis(angle, vectorArray[k]) * @from;
DrawTwoShadedWireDisc(position, vectorArray[k], from, (90f - angle) * 2f, radius);
}
else
{
DrawTwoShadedWireDisc(position, vectorArray[k], radius);
}
}
else
{
DrawTwoShadedWireDisc(position, vectorArray[k], radius);
}
}
}
public static void SetAudioImporterTreeD(UnityEditor.AudioImporter importer, bool p)
{
#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6
//3Dサウンドをオフに
importer.threeD = false;
#else
#endif
}
public static bool HasModifiedProperties( UnityEditor.SerializedObject obj )
{
PropertyInfo pi = TargetType.GetProperty( "hasModifiedProperties",
BindingFlags.NonPublic | BindingFlags.Instance );
return (bool)pi.GetValue( obj, null );
}
internal static void StartListen()
{
try
{
Console.WriteLine("Starting TCP listener...");
var listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 6111);
listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
listener.Start();
while (true)
{
IEditorHandler editor = null;
Socket client = listener.AcceptSocket();
Console.WriteLine("Connection accepted.");
var session = Guid.NewGuid().ToString();
var childSocketThread =
new Thread(() =>
{
try
{
var response = SocketHelper.SendMessage(client, new Dictionary <string, string> {
{ Parameters.Method, Methods.RegisterEditor }, { Parameters.Session, session }
});
if (response.ContainsKey(Parameters.Method) && response[Parameters.Method] == Methods.RegisterEditor)
{
if (response[Parameters.Result] == EditorTypes.Unity)
{
if (response.ContainsKey(Parameters.Session) && response[Parameters.Session] != session)
{
try
{
ConnectionManager.ReconnectEditor(client, response[Parameters.Session]);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e);
editor = new UnityEditor(client, response[Parameters.Session]);
ConnectionManager.AddEditor(editor);
}
}
else
{
editor = new UnityEditor(client, session);
ConnectionManager.AddEditor(editor);
}
}
else
{
Console.WriteLine($"Unsupported editor type: {response["editortype"]}. Socket is being closed");
client.Close();
}
}
var ping = new Dictionary <string, string> {
{ Parameters.Method, Methods.Ping }
};
while (SocketHelper.IsSocketConnected(client))
{
var pong = SocketHelper.SendMessage(client, ping);
if (!pong.ContainsKey(Parameters.Method) || pong[Parameters.Method] != Methods.Ping || pong[Parameters.Result] != Methods.Pong)
{
throw new Exception("Unexpected response from socket");
}
Thread.Sleep(3000);
}
//ConnectionManager.RemoveEditor(editor);
client.Close();
Console.WriteLine("Socket connection closed.");
}
catch (SocketException e)
{
Console.WriteLine(e);
//ConnectionManager.RemoveEditor(editor);
client.Close();
Console.WriteLine("Socket connection closed.");
}
catch (IOException e)
{
Console.WriteLine(e);
//ConnectionManager.RemoveEditor(editor);
client.Close();
Console.WriteLine("Socket connection closed.");
}
catch (NullReferenceException e)
{
Console.WriteLine(e);
//ConnectionManager.RemoveEditor(editor);
client.Close();
Console.WriteLine("Socket connection closed.");
}
});
childSocketThread.Start();
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.StackTrace);
Console.WriteLine("Error: " + e.Message);
}
}
