Mensajes

Denunció y que? Si está borrado el perfil  y no tengo la prueba de que sea ese numero.  No hay amenazas ni nada.  Sólo tonteo con otra.  Igual se ríen de mi

La privacidad de alguien es sagrada, y es perfectamente denunciable.

Lo que puedes hacer es instalar en tu dispositivo algo que te monitorice las conexiones (via IP) a tu movil (que no se si existirá, pero para Windows se llama netcut) y así podrás ver la IP del que te la está haciendo. Con la IP, si eres rápido, quizás una denuncia te valga de algo. Aunque si el otro utiliza una proxy poco vas a poder hacer. (Haz un lookup de la IP)

Ojo: No mandes mensajes con ese movil (ni conexiones) aquí ya que el polizón que te esté haciendo la jugarreta podrá saberlo.

No se si se podrá, pero tu movil está infectado, si tienes algún amigo técnico o algo, mira a ver que te puede recomendar, lo más seguro, es que piense en algo similar.

Solución: A parte de una denuncia obvia, restablece tu movil de fábrica y san sacabo.

Y bueno, a las malas podrías meterle al ordenador de tu novia algún tipo de grabadora de pantalla o algo para que se sepa el nombre de la persona que está haciendo eso.

Otra solución sería un enlace que registrase la IP de quien ha mandado el mensaje, pero sería muy arriesgado aún así con ingenería social ni lo intentaría.

No lo hagas, yo soy usuario desde 2002, y mi última conexión fue hace 4 años, aún así me paso de vez en cuando y vaya nostalgia, me alegra ver que nada (ni el diseño) ha cambiado.

Solo se borraron los usuarios con 0 mensajes. Si hubieses tenido 0 mensajes no hubieses corrido la misma suerte.

[Simplificar una lista de puntos para obtener las esquinas (dicho de otra forma, obtener la minima cantidad de puntos que puedan definir dicha forma)]

Simplificar una lista de puntos para obtener las esquinas (dicho de otra forma, obtener la minima cantidad de puntos que puedan definir dicha forma)

Esto ya lo respondí en Stackoverflow: https://stackoverflow.com/a/52952874/3286975 (Pero lo traduciré)

Después de horas de investigación he encontrado una librería Simplify.NET que internamente ejecuta el algoritmo de Ramer–Douglas–Peucker.

También, os puede interesar el algoritmo de Bresenham, con este algoritmo podéis dibujar una linea a partir de dos puntos.

Con este algoritmo, se podría comprobar si la tolerancia del primer algoritmo es muy alta (comprobando los puntos generados y los que ya tenías antes de simplificar, haciendo una función que te devuelva un porcentaje de similitud). Por suerte, la implementación de Simplify.NET es rápida (unos 25.000 ticks de Stopwatch), llamandose unas 10 veces solo llevaría unos ~30 ms.

Finalmente, es interesante mencionar el algoritmo Concave Hull y Convex Hull (y sus respectivas implementaciones en Unity3D).

Lo que he obtenido con esta implementación:





Nota:

• Los puntos azules son los puntos iterados.
• Los puntos verdes son los puntos simplificados.

Y mi implementación: https://dotnetfiddle.net/aPOhPi

Es muy importante decir que los puntos deben de estar ordenados de tal forma que estén conectados. Si la forma es concava (como se puede ver en la segunda foto) quizás necesites una implementación que itere pixel a pixel dentro de la pared de la figura.

Aquí podéis ver una implementación gracias a Bunny83.

Un saludo.

Ánimo simorg, improvistos de última hora tenemos todos.

Eso ocurre porque banco_palabras[numero_palabra] seguramente será MANUELITO y si haces un substring(0, 1), esto devuelve una "M"...

Lo que deberías hacer:

Código (csharp) [Seleccionar] Expandir

etiqueta = etiqueta.SubString(0, 1) + new string('-', etiqueta.Length - 2);

Debes poner un Console.Read();

Aquí más info: https://stackoverrun.com/es/q/2306334

[Un saludo.]

Ya que estamos en foro libre.

Me apuesto lo que quieras a que ni te has molestado en ver como se lee un XML (ya te lo digo yo: con serialización)

Si te sirve, esto lo implemente el otro día:

Código (csharp) [Seleccionar] Expandir

using System;
using System.IO;
using System.Xml.Serialization;
using UnityEngine;

namespace GTAMapper.Extensions
{
   public static class SerializerHelper
   {
       public static string Serialize<T>(this T data, SerializeFormat format = SerializeFormat.XML)
       {
           switch (format)
           {
               case SerializeFormat.XML:
                   return SerializeToXml(data);

               case SerializeFormat.JSON:
                   return SerializeToJson(data);

               default:
                   return string.Empty;
           }
       }

       public static T Deserialize<T>(this string data, SerializeFormat format = SerializeFormat.XML)
       {
           switch (format)
           {
               case SerializeFormat.XML:
                   return DeserializeToXml<T>(data);

               case SerializeFormat.JSON:
                   return DeserializeFromJson<T>(data);

               default:
                   return default(T);
           }
       }

       /*public static string SerializeToXml<T>(T data)
       {
           var serializer = new DataContractSerializer(data.GetType());
           var builder = new StringBuilder();
           var writer = XmlWriter.Create(builder);
           serializer.WriteObject(writer, data);
           writer.Flush();
           return builder.ToString();
       }*/

       private static string SerializeToXml<T>(T data)
       {
           var xmlSerializer = new XmlSerializer(typeof(T));
           // xmlSerializer.WriteProcessingInstruction("xml", "version='1.0'");

           using (var stringWriter = new StringWriter())
           {
               xmlSerializer.Serialize(stringWriter, data);
               return stringWriter.ToString();
           }
       }

       /*public static T DeserializeToXml<T>(string data)
       {
           var serializer = new DataContractSerializer(data.GetType());
           var writer = XmlReader.Create(GenerateStreamFromString(data));
           var result = serializer.ReadObject(writer);
           return (T)result;
       }*/

       private static T DeserializeToXml<T>(string data)
       {
           try
           {
               var xmlSerializer = new XmlSerializer(data.GetType());
               using (var stream = GenerateStreamFromString(data))
               {
                   var result = xmlSerializer.Deserialize(stream);
                   return (T)result;
               }
           }
           catch (Exception ex)
           {
               Debug.LogException(ex);
               Debug.Log(data);
               return default(T);
           }
       }

       private static Stream GenerateStreamFromString(string s)
       {
           // using
           var stream = new MemoryStream();
           var writer = new StreamWriter(stream, System.Text.Encoding.UTF8);

           writer.Write(s);
           writer.Flush();
           stream.Position = 0;

           return stream;
       }

       private static string SerializeToJson<T>(T data)
       {
           //return JsonConvert.SerializeObject(data);
           throw new NotImplementedException();
       }

       private static T DeserializeFromJson<T>(string data)
       {
           //return JsonConvert.DeserializeObject<T>(data);
           throw new NotImplementedException();
       }
   }

   public enum SerializeFormat
   {
       XML = 1,
       JSON = 2
   }
}

Pero voy a poner el mismo esfuerzo (para explicar el código) que has puesto tu en formular tu pregunta. 2 líneas.

Un saludo.

[SendMessageContext: Una implementación Thread-Safe de SendMessage]

SendMessageContext: Una implementación Thread-Safe de SendMessage

Básicamente, el puñetero de Unity no te deja llamar la función SendMessage desde otro hilo, así que gracias a esta implementación que estuve probando, resolví el problema, para luego darme cuenta de que usaba (blocking) instrucciones en el main thread (dentro de una coroutina gracias a esta utilidad (https://assetstore.unity.com/packages/tools/thread-ninja-multithread-coroutine-15717) es facil/visual cambiar de contexto) (Sí, así somos los programadores cuando tenemos sueño, implementamos cosas que luego ni usaremos)

La utilidad en cuestión: https://forum.unity.com/threads/sendmessage-argumentexception-error.73134/

Mi implementación:

Código (csharp) [Seleccionar] Expandir

using System.Collections.Concurrent;
using UnityEngine;

namespace GTAMapper.Extensions.Threading
{
   public class SendMessageHelper : MonoBehaviour
   {
       private static ConcurrentQueue<SendMessageContext> QueuedMessages = new ConcurrentQueue<SendMessageContext>();

       public static void RegisterSendMessage(SendMessageContext context)
       {
           QueuedMessages.Enqueue(context);
       }

       private void Update()
       {
           if (QueuedMessages.Count > 0)
           {
               SendMessageContext context = null;

               if (!QueuedMessages.TryDequeue(out context))
                   return;

               context.Target.SendMessage(context.MethodName, context.Value, context.Options);
           }
       }
   }
}

Nota: No olvidéis añadir esto al inspector de cualquier gameobject donde se quiera usar (con añadir uno solo bastaría)

Código (csharp) [Seleccionar] Expandir

using UnityEngine;

namespace GTAMapper.Extensions.Threading
{
   public class SendMessageContext
   {
       public MonoBehaviour Target;
       public string MethodName;
       public object Value;
       public SendMessageOptions Options = SendMessageOptions.RequireReceiver;

       public SendMessageContext(MonoBehaviour target, string methodName, object value, SendMessageOptions options)
       {
           this.Target = target;
           this.MethodName = methodName;
           this.Value = value;
           this.Options = options;
       }
   }
}

Algo que en el topic de arriba no está

Código (csharp) [Seleccionar] Expandir

using UnityEngine;

namespace GTAMapper.Extensions.Threading
{
   public static class SendMessageExtensions
   {
       public static SendMessageContext SendSafeMessage(this MonoBehaviour monoBehaviour, string methodName, object value = null, SendMessageOptions sendMessageOptions = default(SendMessageOptions))
       {
           return new SendMessageContext(monoBehaviour, methodName, value, sendMessageOptions);
       }
   }
}

Con esta extensión lo que se consigue es simplificar su uso, básicamente, desde un MonoBehaviour cualquiera dentro del metodo Start() (https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) haciendo esto:

Código (csharp) [Seleccionar] Expandir

this.SendSafeMessage("pepito")

Y luego (desde el mismo MonoBehaviour):

Código (csharp) [Seleccionar] Expandir

public void pepito() {
   // Moar code que seguirá ejecutándose en el mismo hilo desde el que se llamo "SendSafeMessage"
}

Un saludo.
PD: Aquí termina el flood de snippets, staff no preocuparse, llevo muchos días picando código, y he querido compartir post a post mis utilidades
PD2: Ale ya puedo borrar todo lo que no uso. Que no es poco.

[ThreadedDebug: Una utilidad que funciona junto NamedThread & ThreadMarker mostrándote información del Thread actual al debuggear en Unity3D]

ThreadedDebug: Una utilidad que funciona junto NamedThread & ThreadMarker mostrándote información del Thread actual al debuggear en Unity3D

Código (csharp) [Seleccionar] Expandir

using GTAMapper.Extensions.Threading;
using System;
using UnityEngine;

namespace GTAMapper.Utils.Debugging
{
   public static class ThreadedDebug
   {
       private static double TimeRunning
       {
           get
           {
               return (DateTime.Now - System.Diagnostics.Process.GetCurrentProcess().StartTime).TotalSeconds;
           }
       }

       public static void Log(object obj, bool jumpBack = true)
       {
           Debug.Log($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + obj.ToString());
       }

       public static void LogFormat(string str, params object[] objs)
       {
           LogFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, true, objs);
       }

       public static void LogFormat(string str, bool jumpBack = true, params object[] objs)
       {
           Debug.LogFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, objs);
       }

       public static void LogWarning(object obj, bool jumpBack = true)
       {
           Debug.LogWarning($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + obj.ToString());
       }

       public static void LogWarningFormat(string str, params object[] objs)
       {
           LogWarningFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, true, objs);
       }

       public static void LogWarningFormat(string str, bool jumpBack = true, params object[] objs)
       {
           Debug.LogWarningFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, objs);
       }

       public static void LogError(object obj, bool jumpBack = true)
       {
           Debug.LogError($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + obj.ToString());
       }

       public static void LogErrorFormat(string str, params object[] objs)
       {
           LogErrorFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, true, objs);
       }

       public static void LogErrorFormat(string str, bool jumpBack = true, params object[] objs)
       {
           Debug.LogErrorFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, objs);
       }

       public static void LogException(System.Exception ex, bool jumpBack = true)
       {
           Debug.LogException(ex);
       }
   }
}

Básicamente, se usa igual que Debug.LogXX de Unity (https://docs.unity3d.com/ScriptReference/Debug.html) pero este a diferencia, te muesta el momento en el que se ha llamado, y desde el Thread que lo ha hecho.

Ejemplo:



PD: En el ejemplo, vemos dos Count, simplemente, estaba probando que el ConcurrentQueuedCoroutines funcionaba bien, viendo como ConcurrentQueued almacena los datos en todos los contextos usando la instrucción lock(...) internamente.

[Named Thread & Thread Marked: Pon nombres a tus threads]

Named Thread & Thread Marked: Pon nombres a tus threads

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Threading;

namespace GTAMapper.Extensions.Threading
{
    public class ThreadMarker : IDisposable
    {
        //[ThreadStatic]
        //private static string __Name = $"Unity Thread #{Thread.CurrentThread.ManagedThreadId}";

        private static Dictionary<int, string> ThreadNames = new Dictionary<int, string>();

        public static string Name
        {
            get
            {
                lock (ThreadNames)
                {
                    try
                    {
                        return ThreadNames[Thread.CurrentThread.ManagedThreadId];
                    }
                    catch
                    {
                        return $"Unity Thread #{Thread.CurrentThread.ManagedThreadId}";
                    }
                }
            }
        }

        public ThreadMarker(string name)
        {
            lock (ThreadNames)
            {
                ThreadNames.AddOrSet(Thread.CurrentThread.ManagedThreadId, name);
            }

            // __Name = name;
        }

        public void Dispose()
        {
            ThreadNames.Remove(Thread.CurrentThread.ManagedThreadId);
            // __Name = "Un-Owned";
        }
    }
}

Código (csharp) [Seleccionar] Expandir

using System;

namespace GTAMapper.Extensions.Threading
{
    public class NamedHandler<TArg>
    {
        public readonly Func<string, TArg> Handler;

        public NamedHandler(Func<string, TArg> handler)
        {
            Handler = arg =>
            {
                using (new ThreadMarker(arg))
                {
                    return handler(arg);
                }
            };
        }
    }
}

Caso de uso:

Código (csharp) [Seleccionar] Expandir

int TaskId = new Random().Next();

ThreadPool.QueueUserWorkItem(new NamedHandler<WaitCallback>(name => new WaitCallback(BackgroundRunner)).Handler($"Ninja #{TaskId}"));