public void reset()
{
Debug2.LogDebug("reset callback id=" + id);
type = CallbackType.UNKNOWN;
mailruEventId = UNSET_HTML_EVENT_ID;
action = null;
}
public void callMailruByCallbackAndParams(string functionName, Action <object, Callback> action, params object[] parameters)
{
Callback callback = callbackPool.getCallback(CallbackType.DISPOSABLE);
callback.action = action;
string initialization = "";
string functionParams = "";
for (int i = 0; i < parameters.Length; i++)
{
initialization += @"
paramNUM=PARAMETER_JSON;
" .Replace("NUM", "" + i)
.Replace("PARAMETER_JSON", Json.Serialize(parameters[i]));
functionParams += ", paramNUM".Replace("NUM", "" + i);
}
string eval = @"
INITIALIZATION
function _callbackCALLBACK_ID(result){
callback(CALLBACK_ID, result);
}
FUNCTION_NAME(_callbackCALLBACK_ID ADDITIONAL_PARAMETERS);
" .Replace("INITIALIZATION", initialization)
.Replace("CALLBACK_ID", "" + callback.id)
.Replace("FUNCTION_NAME", functionName)
.Replace("ADDITIONAL_PARAMETERS", functionParams);
Debug2.LogDebug("callMailruByCallbackAndParams external evaluation: \n" + eval);
Application.ExternalEval(eval);
}
public void uploadTexture(Texture2D tex, Action <object, Callback> action)
{
string b64string = System.Convert.ToBase64String(tex.EncodeToPNG());
Callback callback = callbackPool.getCallback(CallbackType.DISPOSABLE);
callback.action = action;
string eval = @"
var data = new FormData();
data.append('imgdata','BASE64_STRING')
$.ajax({
url : 'saveimage.php',
data : data,
cache : false,
contentType : false,
processData : false,
type : 'POST',
success : function(data){
var url = window.location.href;
var fullPath=url.substring(0, url.lastIndexOf('/') + 1)+data;
callback(CALLBACK_ID, fullPath);
}
});
" .Replace("BASE64_STRING", b64string)
.Replace("CALLBACK_ID", "" + callback.id);
Debug2.LogDebug("uploadTexture external evaluation: \n" + eval);
Application.ExternalEval(eval);
}
public void onPictureSave(Texture2D texture, string pictureName)
{
vkc.api("photos.getAlbums", new Dictionary <string, object>(), delegate(object arg1, Callback arg2) {
Debug2.LogDebug("im at takeScreenshot=====\n" + Json.Serialize(arg1));
Dictionary <string, object> resultDict = arg1 as Dictionary <string, object>;
if (!resultDict.ContainsKey("response"))
{
Debug2.LogError("vk api error \n" + Json.Serialize(arg1));
return;
}
Dictionary <string, object> response = resultDict["response"] as Dictionary <string, object>;
List <object> items = response["items"] as List <object>;
long albumId = -1;
for (int i = 0; i < items.Count; i++)
{
Dictionary <string, object> album = items[i] as Dictionary <string, object>;
if (((string)album["title"]).Equals(albumName))
{
albumId = (long)album["id"];
break;
}
}
string wallText = wallMessage.Replace("PICTURE_NAME", pictureName);
if (albumId == -1)
{
createAlbumAndPostScreenShot(texture, wallText);
}
else
{
postScreenShot(texture, wallText, albumId);
}
});
}
public static void EraseCircale(RaycastHit hit, int radius)
{
var anilMaterial = hit.collider.GetComponent <AnilMaterial>();
if (!anilMaterial)
{
return;
}
renderer = anilMaterial.renderer;
texture2D = anilMaterial.texture2D;
if (!texture2D.isReadable)
{
Debug2.Log("texture is not readable");
return;
}
pCoord = hit.textureCoord;
pCoord.x *= texture2D.width;
pCoord.y *= texture2D.height;
int x = Mathf.RoundToInt(pCoord.x * renderer.material.mainTextureScale.x);
int y = Mathf.RoundToInt(pCoord.y * renderer.material.mainTextureScale.y);
anilMaterial.Erase(x, y, radius);
}
void setResolutionToActualSizeAndSendEvent()
{
Debug2.LogDebug("setResolutionToActualSizeAndSendEvent current resolution "+ Screen.currentResolution);
lastWidth = Screen.width;
lastHeight = Screen.height;
lastFullScreen = Screen.fullScreen;
if (Screen.width < PropertiesSingleton.instance.screen.minWidth || Screen.height < PropertiesSingleton.instance.screen.minHeight)
{
scaleScreenAndSendEvent();
}
else
{
IntVector2 resolution;
if (Screen.fullScreen)
{
Resolution maxRes = Screen.resolutions[Screen.resolutions.Length - 1];
Screen.SetResolution(maxRes.width, maxRes.height, true);
Debug2.LogDebug("trying to change to full screen");
resolution = new IntVector2(maxRes.width, maxRes.height);
}
else
{
Screen.SetResolution(Screen.width, Screen.height, false);
resolution = new IntVector2(Screen.width, Screen.height);
}
sendEventOnResolutionChange(resolution, new Vector2(1.0f, 1.0f));
}
}
void createAlbumAndSavePictureOnSucess(string pictureName, Texture2D texture)
{
Dictionary <string, object> paramsObject = new Dictionary <string, object>();
paramsObject.Add("name", albumName);
MRUController.instance.callMailruByObjectMailruListenerAndCallback(
"mailru.common.photos.createAlbum",
paramsObject,
"mailru.common.events.createAlbum",
delegate(object obj, Callback callback){
Dictionary <string, object> result = obj as Dictionary <string, object>;
string status = (string)result["status"];
if (status.Equals("closed"))
{
Debug2.LogDebug("album window has closed without creation");
CallbackPool.instance.releasePermanentCallback(callback);
}
else if (status.Equals("createSuccess"))
{
string aid = (string)result["aid"];
Debug2.LogDebug("album created id = " + aid);
CallbackPool.instance.releasePermanentCallback(callback);
savePicture(aid, pictureName, texture);
}
});
}
/// <summary>
/// objeyi yüklemeye yarar
/// </summary>
/// <typeparam name="T">Objenin türünü giriniz</typeparam>
/// <param name="path">objenin Load edileceği yer örn: meshler</param>
/// <param name="name">örn: /objeler.json ve .json zorunlu</param>
public async static UniTask <T[]> LoadArrayAsync <T>(string path, string name)
{
CheckPath(path);
DirectoryInfo directoryInfo = new DirectoryInfo(SavesFolder + path);
int count = directoryInfo.GetFiles().Length;
T[] objectToLoad = new T[count];
var tasks = new List <UniTask>();
for (int i = 0; i < count; i++)
{
tasks.Add(UniTask.Create(async() =>
{
await UniTask.Yield();
string konum = Path.Combine(SavesFolder + path + i.ToString() + name);
if (File.Exists(konum))
{
string loadText = File.ReadAllText(konum);
objectToLoad[i] = JsonUtility.FromJson <T>(loadText);
Debug2.Log(loadText);
}
}));
}
await UniTask.WhenAll(tasks);
return(objectToLoad);
}
public void callbackHandler(string resultString)
{
Debug2.LogDebug("callbackHandler fired with resutlString: \n" + resultString);
Dictionary <string, object> resultObj = Json.Deserialize(resultString) as Dictionary <string, object>;
long callbackId = (long)resultObj["id"];
Debug2.LogDebug("callbackId=" + callbackId);
object result = resultObj.ContainsKey("object") ? resultObj["object"] : null;
Callback callback = callbackDict[callbackId];
if (callback.action != null)
{
callback.action(result, callback);
}
else
{
Debug2.LogError("callback " + callbackId + " is empty");
}
if (callback.type == CallbackType.DISPOSABLE)
{
disposableCallbacks.Remove(callback);
enqueCallback(callback);
}
}
bool Invoke <T>(AADCommand command, ISerializable parameters, [NotNullWhen(true)] out T?result) where T : class, ISerializable
{
result = null;
if (!IsConnected)
{
return(false);
}
var r = InvokeOne(command, parameters, out var result2);
Debug2.Assert(r != ExecutionResult.UnknownCommand);
// internal error, we should fix it
switch (r)
{
case ExecutionResult.IOError:
case ExecutionResult.Disconnect:
Disconnect();
return(false);
case ExecutionResult.Success:
result = result2 as T;
return(result is not null);
default:
return(false);
}
}
public static string[] OnWillSaveAssets(string[] paths)
{
// Get the name of the scene to save.
string scenePath = string.Empty;
string sceneName = string.Empty;
Debug2.Log("SAVING");
foreach (string path in paths)
{
Debug2.Log(" NEXT: ");
if (path.Contains(".unity"))
{
scenePath = Path.GetDirectoryName(path);
sceneName = Path.GetFileNameWithoutExtension(path);
}
}
if (sceneName.Length == 0)
{
return(paths);
}
// DO WHAT YOU NEED TO DO HERE.
// FOR EXAMPLE, CALL A STATIC FUNCTION FROM ANOTHER CLASS
Debug2.Log(" \nscenePath: "+ scenePath);
Debug2.Log(" sceneName: "+ sceneName);
return(paths);
}
public static void Register(ITickable task, UpdateType updateType = UpdateType.normal)
{
// be assure instance exist
Checkinstance();
var ableTask = Tasks.Find(x => x.InstanceId() == task.InstanceId() && x.InstanceId() != 0);
if (ableTask != null)
{
switch (ableTask)
{
case MoveTask move:
move.Join(((MoveTask)task).CurrentData); break;
case DirectionTask drecTask:
drecTask.Join(((DirectionTask)task).CurrentData); break;
case UpdateTask updateTask:
Debug2.Log("update task exist it will add in queue");
updateTask.Join(((UpdateTask)task).currentData); break;
}
}
else
{
if (updateType == UpdateType.normal)
{
Tasks.Add(task);
}
else if (updateType == UpdateType.fixedTime)
{
FixedTasks.Add(task);
}
}
}
public string Test3()
{
StringBuilder Sb = new StringBuilder();
List <Rule> L = RuleHelper.GetAllRules(true);
{
Type R = typeof(Rule);
Type[] Types = GetTypes();
int count = 0;
foreach (Type T in Types)
{
if (T.BaseType == R)
{
Rule R2 = (Rule)Activator.CreateInstance(T);
if (R2.Identifier.ToLower() == "genricvruttam")
{
continue;
}
//Debug2.AppendLine ( R2.Name + "," + R2.PadyamType + "," + R2.PadyamSubType + "," + R2.CharLength );
count++;
if (T.Namespace == "Library.Chandam.Sans")
{
if (R2.Yati.Length >= 1)
{
Debug2.AppendLine(R2.Name);
continue;
}
//Sb.AppendLine ( "case "+R2.Identifier+": return new " + R2.Identifier + "();" );
Sb.AppendLine("new " + R2.Identifier + "(),");
}
}
}
return(Sb.ToString());
}
}
private static void createCharPointsGameObjectElement(GameObject gameObject, XmlElement parentElement, XmlDocument xml)
{
CharPoints[] charPointList = gameObject.GetComponents <CharPoints>();
Debug2.Log(charPointList, charPointList.Length);
if (charPointList.Length <= 0)
{
return;
}
XmlElement gameObjElement = xml.CreateElement("GameObject");
gameObjElement.SetAttribute("name", gameObject.name);
//gameObjElement.SetAttribute("tag",gameObject.tag);
gameObjElement.SetAttribute("activeSelf", gameObject.activeSelf.ToString());
//gameObjElement.SetAttribute("instanceID",gameObject.GetInstanceID().ToString());
//解析组件
for (int i = 0; i < charPointList.Length; i++)
{
parseCharPoints(charPointList[i], gameObjElement, xml);
parentElement.AppendChild(gameObjElement);
}
//解析子对象
Transform transform = gameObject.GetComponent <Transform>();
int childCount = transform.childCount;
for (int i = 0; i < childCount; i++)
{
GameObject subGameObj = transform.GetChild(i).gameObject;
createCharPointsGameObjectElement(subGameObj, parentElement, xml);
}
}
public void initializeVKApi(string key = "")
{
if (!String.IsNullOrEmpty(key))
{
privateKey = key;
}
if (initialized)
{
Debug2.LogWarning("vk api already initialized, init method will be ignored");
}
else
{
initialized = true;
callbackPool = CallbackPool.instance;
callbackPool.initialize();
initVKApi(privateKey,
delegate(object obj, Callback callback){
inputData = HTTPUtility.ParseQueryString((string)obj);
Debug2.LogDebug("viewer id =" + inputData["viewer_id"]);
callbackPool.releaseDisposableCallback(callbackOnInitError);
if (onApiReady != null)
{
onApiReady(true);
}
Debug2.LogDebug("VK api is ready");
},
delegate(object obj, Callback callback){
onApiReady(false);
callbackPool.releaseDisposableCallback(callBackOnInitDone);
Debug2.LogError("problem with vk initialization\n" + Json.Serialize(obj));
});
}
}
private static void OnPlayerModeStateChanged(PlayModeStateChange playModeState)
{
Debug.LogFormat("state:{0} will:{1} isPlaying:{2}", playModeState, EditorApplication.isPlayingOrWillChangePlaymode, EditorApplication.isPlaying);
switch (playModeState)
{
case PlayModeStateChange.EnteredEditMode:
break;
case PlayModeStateChange.ExitingEditMode:
Scene editorActiveScene = EditorSceneManager.GetActiveScene();
int instanceID = editorActiveScene.GetRootGameObjects()[0].GetInstanceID();
Debug2.Log(instanceID, HierarchyUtil.IsExpanded(editorActiveScene.GetRootGameObjects()[0]));
RecordSceneToLocal(editorActiveScene);
break;
case PlayModeStateChange.EnteredPlayMode:
//EditorApplication.playModeStateChanged -= OnPlayerModeStateChanged;
break;
case PlayModeStateChange.ExitingPlayMode:
//EditorSceneManager.sceneLoaded -= OnSceneLoaded;
EditorSceneManager.activeSceneChanged -= OnActiveSceneChanged;
break;
}
}
public Callback getCallback(CallbackType callbackType)
{
Callback callback;
if (callbackQueue.Count > 0)
{
callback = callbackQueue.Dequeue();
callback.reset();
}
else
{
callback = createNewCallback();
}
callback.type = callbackType;
switch (callbackType)
{
case CallbackType.DISPOSABLE:
disposableCallbacks.Add(callback);
break;
case CallbackType.PERMANENT:
permanentCallback.Add(callback);
break;
default:
Debug2.LogError("Wrong callbackType" + callbackType.ToString());
break;
}
return(callback);
}
void takeScreenshot()
{
vkc.api("photos.getAlbums", new Dictionary <string, object>(), delegate(object arg1, Callback arg2) {
Debug2.LogDebug("im at takeScreenshot=====\n" + Json.Serialize(arg1));
Dictionary <string, object> resultDict = arg1 as Dictionary <string, object>;
if (!resultDict.ContainsKey("response"))
{
Debug2.LogError("vk api error \n" + Json.Serialize(arg1));
return;
}
Dictionary <string, object> response = resultDict["response"] as Dictionary <string, object>;
List <object> items = response["items"] as List <object>;
long albumId = -1;
for (int i = 0; i < items.Count; i++)
{
Dictionary <string, object> album = items[i] as Dictionary <string, object>;
if (((string)album["title"]).Equals(albumName))
{
albumId = (long)album["id"];
break;
}
}
if (albumId == -1)
{
createAlbumAndPostScreenShot();
}
else
{
postScreenShot(albumId);
}
});
}
public static void debug2Action(Debug2 fm, string mystring, string hex)
{
try
{
if (hex == "true")
{
if (mystring.Length != 0)
{
Debug2SendCommand.action(mystring.Substring(mystring.LastIndexOf("x") + 1), fm);
}
else
{
MessageBox.Show("No to-be-sent data!");
}
}
else if (hex == "false")
{
fm.serialPort1.Write(mystring);
}
}
catch (Exception)
{
//MessageBox.Show("Procedure Occurrence Mistake:" + ex.Message, "Anomalous", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
void onWebContextReadyListener(object obj, Callback cb)
{
Debug2.Log("im here from callback");
string pageName = (string)obj;
initData = "";
if (pageName.StartsWith("mru"))
{
webType = WebType.MAIL_RU;
initData = mailRuKey;
}
else if (pageName.StartsWith("vk"))
{
webType = WebType.VK;
initData = vkKey;
}
else if (pageName.StartsWith("fb"))
{
webType = WebType.FB;
}
else if (pageName.StartsWith("online"))
{
webType = WebType.ONLINE;
}
else
{
Debug2.LogError("unknown page");
}
ready = true;
activeStrategy = supportedWeb[webType];
activeStrategy.onStart(initData);
}
public void callMethod(string methodName, params object[] parameters)
{
string jsParams = "";
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] is string)
{
jsParams += ", \"" + (string)parameters[i] + "\"";
}
else if (parameters[i] is bool)
{
jsParams += ", " + ((bool)parameters[i]).ToString().ToLower();
}
else if (parameters[i] is int)
{
jsParams += ", " + parameters[i];
}
}
string eval = @"
VK.callMethod('METHOD_NAME'PARAMETERS);
" .Replace("METHOD_NAME", methodName)
.Replace("PARAMETERS", jsParams);
Debug2.LogDebug("callMethod external evaluation \n" + eval);
Application.ExternalEval(eval);
}
public static void Test(string aName, Action a, string bName, Action b, long iteration)
{
Stopwatch stopwatch = new Stopwatch();
Debug2.Log(aName);
stopwatch.Start();
for (long i = 0; i < iteration; i++)
{
a.Invoke();
}
stopwatch.Stop();
Debug2.Log($" {stopwatch.ElapsedMilliseconds: 0.000}");
stopwatch.Reset();
Debug2.Log(bName);
for (long i = 0; i < iteration; i++)
{
b.Invoke();
}
stopwatch.Stop();
Debug2.Log($" {stopwatch.ElapsedMilliseconds: 0.000}");
}
public void onNewPictureOpen(SheetObject sheetObject)
{
string text = "Colorus | " + sheetObject.nameKey.Localized();
string eval = "document.title=\"TEXT\";".Replace("TEXT", text);
Debug2.LogDebug(" onNewPictureOpen evaluation eval=\n" + eval);
Application.ExternalEval(eval);
}
void sendEventOnResolutionChange(IntVector2 resolution, Vector2 scale)
{
Debug2.LogDebug("sendEventOnResolutionChange resolution = " + resolution.ToString() + " scale =" + scale);
if (onResolutionChange != null)
{
onResolutionChange(resolution, scale);
}
}
/// <summary>
/// Connects to a waiting server within the specified time-out period.
/// </summary>
/// <param name="timeout">The number of milliseconds to wait for the client to connect before the connection times out.</param>
/// <returns></returns>
bool WaitForConnection(int timeout)
{
// TODO: timeout
Debug2.Assert(!IsConnected);
var stream = (NamedPipeServerStream)base.stream;
stream.WaitForConnection();
return(IsConnected);
}
//--------------------------------------------------------------------------------
public virtual void OutputDebugStructure()
{
Debug2.Push(this.ToString());
foreach (TreeNode treeNode in this._treeNodes)
{
treeNode.OutputDebugStructure();
}
Debug2.Pop();
}
public void setMailruEventId(string parameters)
{
Debug2.LogDebug("setMailruEventId params=" + parameters);
Dictionary <string, object> result = Json.Deserialize(parameters) as Dictionary <string, object>;
long callbackId = (long)result["callbackId"];
long mailruEventId = (long)result["mailruEventId"];
callbackDict[callbackId].mailruEventId = mailruEventId;
}
/// <summary>
/// Get the image bytes asynchronously. Must be called from the main thread,
/// as the <see cref="DataPath"/> is accessed and Realm can only be used from the main
/// thread. If you need to access the data from another thread, call
/// <see cref="PrepareImageLoad"/> on the main thread and then call
/// <see cref="PreparedImageLoad.GetDataAsync"/> on it.
/// </summary>
/// <returns></returns>
public virtual async Task <byte[]> GetDataAsync()
{
var dataPath = DataPath; // DO NOT INLINE! See method documentation.
Debug2.Assert(dataPath != null, $"dataPath is null for media with REST ID {IdForRestApi}");
return(await MediaCache.GetBytesAsync(
IdForRestApi,
async() => await fileManager.ReadFromDiskAsync(dataPath)
));
}
public override void Init()
{
Debug2.Log("init MRUController");
base.Init();
if (initOnStart)
{
initializeVKApi();
}
}
/// <summary>
/// Execute one command and return execution result
/// </summary>
/// <returns></returns>
/// <remarks>See invoker: <seealso cref="AADClient.InvokeOne(AADCommand, ISerializable, out ISerializable?)"/></remarks>
ExecutionResult ExecuteOne()
{
try {
ReadCommand(out var command);
if (command == AADCommand.Disconnect)
{
return(ExecutionResult.Disconnect);
}
if (!CommandHandlerManager.Handlers.TryGetValue(command, out var handler))
{
Debug2.Assert(false);
return(ExecutionResult.UnknownCommand);
}
// phase 1: get the handler corresponding to the command
if (Activator.CreateInstance(handler.ParametersType, true) is not ISerializable parameters)
{
throw new InvalidOperationException("Can't create parameters object");
}
// phase 2: create parameters instance
Read(parameters);
// phase 3: read parameters from stream
bool b;
ISerializable?result;
try {
b = handler.Execute(parameters, out result);
}
catch (Exception ex) {
WriteCommand(AADCommand.UnhandledException);
Write(new AADServerInvocationException(ex.ToFullString()));
return(ExecutionResult.UnhandledException);
}
if (!b)
{
WriteCommand(AADCommand.Failure);
return(ExecutionResult.Failure);
}
// phase 4: execute command with parameters
WriteCommand(AADCommand.Success);
Write(result !);
// phase 5: write result to stream
return(ExecutionResult.Success);
}
catch (Exception ex) {
Debug2.Assert(ex is IOException);
// regard all unhandable exceptions as IO error
return(ExecutionResult.IOError);
}
}
