Unity Spain

Mesa de ayuda => Unity3D => Scripting => Mensaje iniciado por: nomoregames en Enero 14, 2020, 06:50:54 PM

Título: incremento con while
Publicado por: nomoregames en Enero 14, 2020, 06:50:54 PM
Hola a todos
 

 
Estoy intentando,que cuando mantienes el botón derecho de el ratón  , mediante while, que una variable float, incremente de manera "pausada", pero no se por que no estoy consiguiendo absolutamente nada....
 

 while (ArrowAddForce != 30)
        {
            ArrowAddForce += 1;
            print(ArrowAddForce);
           // yield return new WaitForSeconds(0.4f); e probado con esto pero sigo sin conseguir nada
           
        }

 
estoy seguro de que tiene una respuesta muy sencilla, pero no llego a mas y es desesperante
 
 
 
Editado: en el código, donde pongo while(ArrowAddForce....) ponía originalmente  while(Input.GetMouseButtonDown(1)).
 


  
 
 
Título: incremento con while
Publicado por: lightbug en Enero 14, 2020, 07:34:49 PM
Estás usando el Input.GetMouseButton( 1 ) no??
Título: incremento con while
Publicado por: nomoregames en Enero 14, 2020, 08:58:13 PM



   
      Estás usando el Input.GetMouseButton( 1 ) no??
   

[/quote]
 
Sip
 
(joder me ha dado un huelco el corazón, siempre que apareces en alguno de mis posts me arreglas la vida)
Título: incremento con while
Publicado por: lightbug en Enero 15, 2020, 12:52:30 AM
Cita de: nomoregames date=1579031893Sip
   
   
      (joder me ha dado un huelco el corazón, siempre que apareces en alguno de mis posts me arreglas la vida)
   


Jajaja, bueno me imagino que estás haciendo esto dentro de una corrutina. Quizás podrías subir el código entero así se ve mejor la cosa.
 
 
Título: incremento con while
Publicado por: J Montes en Enero 15, 2020, 01:33:55 AM
Yo recomiendo usar tiempo siempre que puedas, en lugar de contadores arbitrarios que luego nunca nos acordamos de qué unidades contaban, y además nos arriesgamos a que funcionen diferente en diferentes ordenadores.
 
Yo en el Update() o FixedUpdate() simplemente usaría:
 

if (Input.GetMouseButton(1)) {
    buttonActionPressedTime = buttonActionPressedTime + Time.fixedDeltaTime;  // o deltaTime, pero esto yo lo pondría en FixedUpdate así que fixedDeltaTime
    this.UpdateBowTension();  // supongamos que este método existe por ahora
} else {
    pressedTime = 0.0f;
}

 
Y luego cuando necesites interpretar eso ya dividirás pressedTime por lo que toque, o le aplicas la función que quieras (lineal, cuadrática, una spline a tu gusto...). Igual necesitas caparla (clampearla) para que no crezca demasiado pero eso también puedes hacerlo al interpretarla, eso ya a tu gusto.
 
En otra parte (desde Update o FixedUpdate depende de lo que vayas a hacer), la usaría:
 

public void UpdateBowTension() {
    float bowTensionTime = 2.0f;  // esto bien podría ser una constante o ponerlo como parámetro de tu controller o tus globals
    float bowTension = Mathf.Clamp(buttonActionPressedTime / bowTensionTime, 0.0f, 1.0f);  // la tensión normalizada entre 0 y 1 (siempre mejor! :))
    // Y aquí lo usas para lo que quieras, por ejemplo actualizar la imagen o una barra, o si vas a disparar, usarlo como multiplicador de la fuerza.
}

 
De esta forma sabes exactamente que tu acción toma 2 segundos, y puedes cambiarlo fácilmente.
 
Es verdad que seguram1ente necesitarás un boolean para expresar también que estás de hecho disparando el arco, y lidiar con el sonido, y demás, pero espero que te inspire un poco lo de arriba.
 
Fíjate también que así es fácil cambiar la "respuesta" del arco, si quisieras. No te preocupes ahora pero estamos usando "buttonActionPressedTime / bowTensionTime" que es lineal, pero si quisieras que la tensión fuese acelerando podrías usar por ejemplo una cuadrática (elevando eso al cuadrado para que llegue antes al tope) o, tratándose de un arco, una función que decaiga como 1 - (x - 1)^2, aunque realmente no sé qué hace la gente.  También puedes crear una spline en el editor y llamo a su método para interpolar el tiempo, así tienes un control de las curvas, si necesitas algo tan fino.
 
Un saludo,
Título: incremento con while
Publicado por: nomoregames en Enero 15, 2020, 05:53:33 PM



   
       Quizás podrías subir el código entero así se ve mejor la cosa.
   

[/quote]


    float ArrowAddForce;
    private void Update()
    {
    if (Input.GetMouseButtonDown(1))
        {
            StartCoroutine(tensiontime());
        }
    }
    IEnumerator tensiontime()
    {
        while (Input.GetMouseButtonDown(1))  
        {
            ArrowAddForce += 1;
            print(ArrowAddForce);
            yield return new WaitForSeconds(0.4f);
 
        }
    }

 
 
 
J Montes ...
 
es triste... pero es la unica parte que e logrado entender....
 
Cita de: J Montes date=1579048435if (Input.GetMouseButton(1)) {     buttonActionPressedTime = buttonActionPressedTime + Time.fixedDeltaTime;
   


 
 
 
 
Cita de: J Montes date=1579048435Y luego cuando necesites interpretar eso ya dividirás pressedTime por lo que toque, o le aplicas la función que quieras (lineal, cuadrática, una spline a tu gusto...).
   


con que lo tengo que dividir
 
 
 
Cita de: J Montes date=1579048435// la tensión normalizada entre 0 y 1 (siempre mejor! :))
   


normalizar no era hacer que un numero fuera -1, 0 o 1, por que lo clampeas....
 
 
 
Como puedes ver, hablo desde una ignorancia... casi absoluta
Título: incremento con while
Publicado por: francoe1 en Enero 15, 2020, 10:48:19 PM
Para esta práctica necesitas 2 "eventos", MouseUp y MouseDown.
 

private void Update()
{
if (Input.GetMouseButton(0)) // Si fuera DOWN se ejecutaria 1 vez. De esta menera detecta si el mouse esta siendo presionado.
{
}
if (Input.GetMouseButtonUp(0))
{
}
}

 
Teniendo esto ahora necesitarás un factor, número del 0 al 1 que será utilizado para multiplicar el valor máximo que desees.

Para esto la forma más simple y de alguna manera "segura" es utilizando Time.deltaTime para incrementar una variable.
 
Dentro de el bloque IF del mouse "DOWN".
 

time_amount += Time.deltaTime;

 
Dentro de el bloque IF del mouse UP
 

OnFinishEvent(time_amount);
time_amount = 0;

 
La función OnFinishEvent es donde ejecutaras la mecanica necesario, multiplicando time_amount normalizado * el maximo valor permitido.
Título: incremento con while
Publicado por: nomoregames en Enero 17, 2020, 04:46:29 PM
Wow, no se como no se me había ocurrido antes... Gracias francoe1
 
Pero... como se aria usando corruinas? (es que no las acabo de entender )
Título: incremento con while
Publicado por: J Montes en Enero 17, 2020, 11:46:42 PM
No usarías corrutinas para esto, porque Unity está orientado a que este tipo de lógica no necesite corrutinas: en cada frame, tienes un evento Update() para ocuparte de la lógica que necesites ejecutar. 
 
Podríamos hacerlo en una corrutina, claro, pero sería más lioso que como te ha dicho @francoe1.
 
Una corrutina la usas cuando precisamente quieres ejecutar instrucciones a lo largo de varios frames. Por ejemplo, las uso mucho para demorar algo o secuenciar cosas (ejemplo: termina una partida, emito un sonido, paro reloj y controles, espero 2 segundos, y muestro un mensaje de Final. Para esperar esos dos segundos, podríamos usar una variable y en el Update comprobar si han pasado esos 2 segundos, pero sería engorroso hacer eso para cada secuencia, y rompe la linealidad del código. En ese caso, yo suelo hacer algo como:
 

void Update() {
  if (finished) {
    gameStopped = true;  // ejemplo: marcamos el juego como parado
    StartCoroutine(EndGameCoroutine);  // arrancamos nuestra secuencia de fin de juego
  }
}
private IEnumerator EndGameCoroutine(float waitTime) 
{
            endSound.Play();  // ejemplo: sonido de fin de juego
            timer.Stop();  // ejemplo: en este ejemplo, paro el reloj del juego ya mismo ya que ha acabado la partida
            yield return new WaitForSeconds(2.0f);  // esperamos un rato, me gusta que el jugador contemple su éxito o fracaso
            endGameBanner.SetActive(true);  // ejemplo: mostramos un mensaje de fin de partida
            yield return new WaitForSeconds(3.0f); // esperamos un rato, para que el jugador pueda ver el mensaje anterior
            restartRound();  // ejemplo: y reiniciamos
}

 
Ves que en este ejemplo sería engorroso tener condiciones el Update() para cada una de esas esperas de 2 segundos, en cambio con una corrutina se expresa de forma secuencial.
 
En todo momento, puede haber una o más corutinas ejecutándose. Éstas se ejecutan durante el Update(), de forma que puedes ir arrancándolas y se ejecutarán concurrentemente (en "paralelo") al resto de tus updates. Ojo a no dejar corrutinas perdidas. Fíjate también que en realidad las corutinas pendientes se ejecutan en realidad, en orden, al final del Update de la escena (no corren en hilos, sino que utilizan un modelo de programación asíncrona y de ahí que se llamen corrutinas). En resumen si lanzas una corutina en Update(), ésta se ejecutará al final del Update de ese frame para todos los objetos. Si una corrutina está esperando 2 segundos, se ejecutará la línea siguiente al final del Update cuando terminen esos 2 segundos.
 
La manera que tiene una corrutina de "parar y esperar a algún evento" es declarándose como IEnumerator y usando ese "yield return". Esto es una peculiaridad del lenguaje y no vamos a entrar en detalles por ahora.
 
Las corrutinas son útiles para muchas más cosas que temporizar algo. Por ejemplo, para díalogos de tipo "Aceptar / Cancelar". El código que espera la respuesta usa:
 

bool confirmed = yield return new ShowConfirmationDialog("Are you sure?");  // esta función no es estándar, es un ejemplo

 
Y se queda por tanto esperando a que el usuario responda a ese mensaje (es posible decirle a una corutina que "ya ha llegado su evento"). También se usan para peticiones de red o cargas de recursos (que se ejecutan por detrás, de forma asíncronas).
 
Mi consejo es que pienses por ahora en corrutinas para secuencias de acciones programadas. Por ejemplo, al soltar tu arco, podrías querer una corrutina para:
 


  1.    Bloquear el movimiento del jugador


  2.    Sonido de disparo


  3.    Preparar la flecha y lanzarla


  4.    (ESPERAR) al impacto de la flecha y/o timeout  <- este sería el motivo de usar una corrutina para esto


  5.    comprobar el impacto (terreno válido, etc) y salir si es inválido


  6.    sonido de "enganchar la flecha"


  7.    crear el puente


  8.    reestablecer el movimiento del jugador


Igualmente, podrías hacer esto usando varios scripts en la flecha. Usar una corrutina para este tipo de secuencias depende del contexto, y de tus preferencias y estilo personal. Pero de todas formas, esto sería una vez se decide soltar la flecha... en general para gestionar los controles yo te recomiendo que no pienses en corrutinas. Igual alguien tiene otra opinión, pero yo no veo su utilidad aquí, ya que el mecanismo de Update() está pensado exactamente para esa parte de la lógica -controles, movimientos de objetos, lógica que se ejecuta en cada frame...-).
 
 
 
En otro orden de cosas:
 
Normalizar no es hacer que algo valga "-1, 0, o 1". Normalizar significa "regularizar" algo y normalmente a lo que nos referimos depende del contexto.
 
Pero para empezar, es habitual referirse a valores entre  -1.0 y 1.0 (con todos los números reales intermedios). Quizá en algún contexto normalizar se refiera a "-1, 0 o 1" (valores enteros discretos) pero no en este caso. 
 
En otros casos nos referimos a valores positivos entre 0 y 1 , como en este caso, donde el tiempo de tensión puede ser "0" o "máximo" pero no puede ser negativo evidentemente. Si lo normalizamos, en general, la mayoría entendemos ponerlo entre 0 y 1 (es decir, dividir por el máximo).
 
En mi ejemplo, además lo clampeo porque si el usuario deja el ratón pulsado más tiempo entiendo que consideramos que está en el "máximo", por eso lo clampeo entre 0 y 1 (una vez dividido por el máximo: es decir, "normalizado").
 
Por supuesto, podrías clampear entre [0, maxTime] y luego dividir, o dividir primero y clampear entre [0, 1]... esto ya tienes que tener tú claro qué unidades y qué representa cada una de tus variables.
 
Y yo por eso sugiero contar tiempo, y hacer las cuentas al final: así tienes siempre el dato inequívoco (tiempo pulsado) y luego con un par de cuentas (como una división y un clamp) ya lo tienes entre 0 y 1 (disparar flojísimo - máxima tensión). Al estar normalizado, lo puedes usar para multiplicar por tu fuerza, para tu animación... entre 0 y 1. Por eso todo el mundo te aconseja que intentes trabajar así y no con valores absolutos, porque luego cualquier cambio te obligará a cambiar varias cosas. Pero... ¡todos metemos constantes en el código durante las pruebas!.
 
...en estadística, normalizar se refiere a normalizar los valores de una serie respecto a unos parámetros estadísticos. En álgebra lineal, normalizar un vector significa hacer que su magnitud sea 1 conservando su dirección (en Unity: Vector3.normalize() (https://docs.unity3d.com/ScriptReference/Vector3-normalized.html) y muchas otras funciones), normalizar una matriz es hacer que la transformación que representa no escale el espacio, y etc etc...
 
 
Título: incremento con while
Publicado por: nomoregames en Enero 18, 2020, 06:30:57 PM
Por lo que explicas, tenia una idea totalmente equivocado sobre las corrutinas ... como bes aun me queda mucho por aprender (aun tengo miedo a los while ), a partir de lo que me as contado intentare llegar a entenderlas completamente
 
 
 
Gracias a todos por la ayuda, y en especial a la explicación de J Montes 
Título: incremento con while
Publicado por: Jhonatan00_00 en Enero 30, 2020, 02:00:44 PM
Buenas tardes, estoy leyendo por encima todos los comentarios y como siempre termino abrumado con todo lo que saben en este foro, pero creo que lo que intentas hacer es mucho mas sencillo que todo lo que te están explicando y se soluciona sin usar while (que está para otros casos).
 
Según como yo lo he entendido, tu problema es que Unity no tiene nada que detecte mientras la tecla está pulsada, tan solo cuando la pulsas una vez o cuando dejas de pulsarla y lo que pretendes hacer es que cuando está la tecla pulsada una variable sume para hacer algo que tengas en mente con esa variable y es muy facil de resolver:
 
- Creas una variable booleana que te devolverá true o false y la puedes llamar por ejemplo Tecla_Pulsada.
 
- Cuando oprimas la tecla que tu quieras, por medio de un If (. . .) indicas que la booleana que has creado antes sea true y con else que sea false.
 
- De nuevo en otro If (. . .) indicas que cuando la booleana sea true, la variable a sumar empiece a hacerlo, si la booleana es false, no sumará nada a la variable. Por tanto mientras la tecla esté pulsada esa variable que habias creado va a sumar y en cuanto sueltes la tecla dejará de hacerlo.
 
No se si he entendido bien cual era tu problema...
 
Un saludo.
Título: incremento con while
Publicado por: nomoregames en Enero 30, 2020, 04:51:45 PM
Buenas tardes Jhonatan
 
Lo mismo que estas explicando tu, se puede lograr mediante el script de el compañero francoe 
 

private void Update()
{
if (Input.GetMouseButton(0)) // Si fuera DOWN se ejecutaria 1 vez. De esta menera detecta si el mouse esta siendo presionado.
{
}
if (Input.GetMouseButtonUp(0))
{
}
}

 
en el que cuando presiono el ratón (sin poner "down", por que entonces solo se ejecuta un frame) pues se empieza a sumar 1 a el flotante, y cuando se suelta (
 

Input.GetMouseButtonUp(0)

 
)
 
pues se aplica ese flotante a la cantidad de fuerza que tendrá el rigidbody... no se si me explico muy bien 
 
 
Título: incremento con while
Publicado por: francoe1 en Enero 30, 2020, 08:47:54 PM
Cita de: Jhonatan00_00 date=1580389244Buenas tardes, estoy leyendo por encima todos los comentarios y como siempre termino abrumado con todo lo que saben en este foro, pero creo que lo que intentas hacer es mucho mas sencillo que todo lo que te están explicando y se soluciona sin usar while (que está para otros casos).
   
   
      Según como yo lo he entendido, tu problema es que Unity no tiene nada que detecte mientras la tecla está pulsada, tan solo cuando la pulsas una vez o cuando dejas de pulsarla y lo que pretendes hacer es que cuando está la tecla pulsada una variable sume para hacer algo que tengas en mente con esa variable y es muy facil de resolver:
   
   
      - Creas una variable booleana que te devolverá true o false y la puedes llamar por ejemplo Tecla_Pulsada.
   
   
      - Cuando oprimas la tecla que tu quieras, por medio de un If (. . .) indicas que la booleana que has creado antes sea true y con else que sea false.
   
   
      - De nuevo en otro If (. . .) indicas que cuando la booleana sea true, la variable a sumar empiece a hacerlo, si la booleana es false, no sumará nada a la variable. Por tanto mientras la tecla esté pulsada esa variable que habias creado va a sumar y en cuanto sueltes la tecla dejará de hacerlo.
   
   
      No se si he entendido bien cual era tu problema...
   
   
      Un saludo.
   


Cuando todos empezamos a programar creamos este tipo de lógicas, esto crea algo que llamamos código espagueti.

No hay una forma 100% correcta para realizarlo con el sistema actual de inputs de UNITY,  es lamentable que se requiera un IF que sea comprobado constantemente para detectar un evento de teclado.
 
Los BOOL-FLAG no siempre son buena idea, es decir, de alguna manera el FLAG se asigna con un valor, esto quiere decir que el evento que esperamos se está realizando pero desconocemos de qué manera tratarlo.
 
¿Es necesario incrementar una variable?

No, claramente este es el error de inicio al intentar solucionar el problema.
 
¿Entonces cómo lo hago?

Simple, al detectar el evento KeyDown guardamos una referencia de tiempo de ejecución, esto puede ser DataTime.Now, o Time.time de unity, luego al detectar el evento KeyUp restamos el valor del tiempo actual con el tiempo guardado, esto nos va a dar un valor que no dependerá del FrameRate actual.
 
CODIGO
 

public class DetectKeyTime : MonoBehaviour
{
    public Action<float> EventFinish;
    public KeyCode Key = KeyCode.F;
    private float m_lastTime { get; set;}    
   
    private void Update()
    {
        if (Input.GetKeyDown(Key))
            m_lastTime = Time.time;
        if (Input.GetKeyUp(Key))
            EventFinish?.Invoke(Time.time - m_lastTime);
    }
}

 
Esto estaría correcto, pero aún eliminar la función Update y tener un Sistema de eventos para los inputs evitando así que cada instancia del componente realice la misma comprobación. 
Título: incremento con while
Publicado por: Jhonatan00_00 en Enero 30, 2020, 09:27:57 PM
Buenas tardes, yo desde lo poco que se de programación puedo decir que hagamos lo que hagamos el PC siempre va a estar constantemente haciendo comprobaciones, es mas, todas las funciones que nos proporciona un engine o un lenguaje de programación son operaciones como la que yo he dicho antes pero simplificadas, para hacerlo mas sencillo, pero comprobaciones al fin de al cabo con sus If detrás solo que no los ves. De hecho, yo he programado muchísimas cosas (primero en Div Game Studio 2, después en Blitz3D y por último en Unity) sin saber muchos comandos del lenguaje y usando instrucciones básicas porque todo empieza con 0 y 1 y todo empieza con If, Else y poco mas... Las instrucciones son esas cosas simplificadas en un comando, pero están ahí detrás igualmente y no van a consumir mas recursos a no ser que uses la misma comprobación mas veces de las que sean necesarias.
 
En este último código que ha puesto Francoe1 ya hay montones de comprobaciones por cada frame lo quiera o no y tampoco entiendo por que a los programadores mas avanzados les gusta tanto crear variables para llamar a las cosas como quieren y no por su nombre, por ejemplo, en lugar de poner Input.GetKeyDown(KeyCode.F) y ya está, primero crea una variable para llamar a KeyCode.F como Key (lo que es mas trabajo tanto para el programador como para el PC y es mas complicado) y después usa esa variable para un If que no es una operación matemática ni nada complejo.
 
Yo pienso que la solución mas sencilla y práctica, si funciona, es la mejor, aunque es bueno saber comandos para facilitar muchas operaciones matemáticas (sobre todo), pero para esto tan simple creo que no es necesario tanto jaleo.
 
Un saludo.
 
 
Título: incremento con while
Publicado por: francoe1 en Enero 31, 2020, 01:06:52 AM
Cita de: Jhonatan00_00 date=1580416077Buenas tardes, yo desde lo poco que se de programación puedo decir que hagamos lo que hagamos el PC siempre va a estar constantemente haciendo comprobaciones, es mas, todas las funciones que nos proporciona un engine o un lenguaje de programación son operaciones como la que yo he dicho antes pero simplificadas, para hacerlo mas sencillo, pero comprobaciones al fin de al cabo con sus If detrás solo que no los ves. De hecho, yo he programado muchísimas cosas (primero en Div Game Studio 2, después en Blitz3D y por último en Unity) sin saber muchos comandos del lenguaje y usando instrucciones básicas porque todo empieza con 0 y 1 y todo empieza con If, Else y poco mas... Las instrucciones son esas cosas simplificadas en un comando, pero están ahí detrás igualmente y no van a consumir mas recursos a no ser que uses la misma comprobación mas veces de las que sean necesarias.
   
   
      En este último código que ha puesto Francoe1 ya hay montones de comprobaciones por cada frame lo quiera o no y tampoco entiendo por que a los programadores mas avanzados les gusta tanto crear variables para llamar a las cosas como quieren y no por su nombre, por ejemplo, en lugar de poner Input.GetKeyDown(KeyCode.F) y ya está, primero crea una variable para llamar a KeyCode.F como Key (lo que es mas trabajo tanto para el programador como para el PC y es mas complicado) y después usa esa variable para un If que no es una operación matemática ni nada complejo.
   
   
      Yo pienso que la solución mas sencilla y práctica, si funciona, es la mejor, aunque es bueno saber comandos para facilitar muchas operaciones matemáticas (sobre todo), pero para esto tan simple creo que no es necesario tanto jaleo.
   
   
      Un saludo.
   
   
       
   


No esperaba que conteste semejante brutalidad.
 
1 - Es muy raro ver lógicas basadas en bloques de IF, la programación no solo se basa en comparaciones lógicas.
 
2 - Crear variables para ser utilizada es una costumbre "buena" para ahorrar memoria. Esto es algo que con los años vas aprendiendo, es común ver string dentro de un bloque Update sin estar conscientes de que se está creando un nuevo objeto por cada iteración.
 
3 - La idea no es discutir, si no, darte información para que armes tu propio camino a una solución. 

La programación no es algo "simple" aunque lo parezca, cuando comienzas crees que se trata únicamente de operaciones lógicas simples, luego empiezas a estudiar múltiples casos y soluciones te das cuenta el ¿por qué? de dichas implementaciones.
 
"hagamos lo que hagamos el PC siempre va a estar constantemente haciendo comprobaciones"

Esta frase deja mucho que decir sobre tu conocimiento, para entender qué tipos de comprobaciones, formas y orden se deben seguir tendrás que estudiar varios años, como muchos de los que estamos acá, C# es un lenguaje compilado intermedio, esto quiere decir que todo lo que programes se pasa a MSIL para ser interpretado. MSIL tiene muchas pautas para lograr un funcionamiento óptimo, las vas aprendiendo con el tiempo, con los errores y los fracasos.

Tu frase es recíproca, la magia o el conocimiento te lleva a saber distinguir qué maneras son las óptimas para trabajar.
 
 
 
 
Título: incremento con while
Publicado por: nomoregames en Enero 31, 2020, 10:57:48 AM
Por favor, procurad que el tono de esta conversación no suba a más. El objetivo de este foro no es la discusión sobre lo que esta bien o mal, sino, a partir de los conocimientos de el resto poder adquirir los tuyos propios. Sin ay quien esta más o menos informado, y todo el mundo tiene derecho a equivocarse. No queremos convertir esto en un campo de guerra, sino en una oportunidad, para abrirse de mente y aprender sobre nuestros errores.
 
Buenos días .
 


 

Título: incremento con while
Publicado por: Jhonatan00_00 en Enero 31, 2020, 11:34:41 AM
Buenos días, está claro que yo no se de esto ni la mitad que usted y no pretendo dármelas de listo, tan solo soy un aprendiz autodidacta de la programación con el sueño de poder realizar un juego aunque sea parecido a los triple A (porque todos los juegos que he hecho han sido proyectos sin acabar que dejan mucho que desear). 
 
Pero a veces nos complicamos mas de la cuenta para hacer cosas sencillas y desde lo poco que conozco, se que por ejemplo cuando usamos time.Deltatime tras ese comando que Unity nos facilita hay una variable que va sumando al igual que si la creamos nosotros y que si usamos time.Deltatime 40 veces, cada vez es un contador nuevo que ha creado Unity, por tanto una variable invisible que nos consume recursos. Muchas veces hacemos las cosas mas complicadas de lo que son por querer hacerlas perfectas.
 
Mi lema es: si funciona, hazlo.
 
Un saludo.
Título: incremento con while
Publicado por: francoe1 en Enero 31, 2020, 08:55:30 PM
Cita de: nomoregames date=1580464668Por favor, procurad que el tono de esta conversación no suba a más. El objetivo de este foro no es la discusión sobre lo que esta bien o mal, sino, a partir de los conocimientos de el resto poder adquirir los tuyos propios. Sin ay quien esta más o menos informado, y todo el mundo tiene derecho a equivocarse. No queremos convertir esto en un campo de guerra, sino en una oportunidad, para abrirse de mente y aprender sobre nuestros errores.
   
   
      Buenos días .
   
   


       
   




Es normal, me estresa un poco algunas cosas. Pero siempre intentaré tener respeto.
Título: incremento con while
Publicado por: lightbug en Febrero 02, 2020, 05:23:50 PM
Jaja arranco leyendo la página y decía "Por favor, procurad que el tono de esta conversación no suba a más ..." ...  here we go again
 
 
 
Cita de: Jhonatan00_00 date=1580416077En este último código que ha puesto Francoe1 ya hay montones de comprobaciones por cada frame lo quiera o no y tampoco entiendo por que a los programadores mas avanzados les gusta tanto crear variables para llamar a las cosas como quieren y no por su nombre, por ejemplo, en lugar de poner Input.GetKeyDown(KeyCode.F) y ya está, primero crea una variable para llamar a KeyCode.F como Key (lo que es mas trabajo tanto para el programador como para el PC y es mas complicado) y después usa esa variable para un If que no es una operación matemática ni nada complejo.
   


Eso es buena práctica de programación, y probablemente no lo veas ahora, pero tiene todo el sentido del mundo. No es simple capricho.
 
Keycode: Este me parece el más obvio de todos. El script no se llama "DetectTheFKeyTime", osea que asume una "Key" genérica. Que pasa si le pasás el código a alguién que no tenga la tecla F de su teclado? (no se, se le cayo pegamento justo en el contacto). Claramente esta persona se queda sin poder hacer sus propias mediciones porque el programador responsable no supo proyectar, algo clave en este rubro. Como se arregla, posibilitando la selección de otras inputs, es tu problema actual? No, puede ser el de mañana? quién sabe...
 
Evento: Si tuvieras que detectar esta tecla en 15 monobehaviours distintos, tendrías que copiar y pegar todo el código en cada uno. Bueno, ya no es necesario, porque suscribiéndote al evento deseado simplemente le indicás el método a llamar y el proceso ocurre "under the hood".
 

// Action<float> Pepe --> void Pepe( float arg )
 
public class UnMonoB : MonoBehaviour
{
[SerializeField]
     DetectKeyTime detectKey = null;
 
     void OnEnable()
     {
        detectKey.EventFinish += EventFinish;
     }
 
     void OnDisable()
     {
        detectKey.EventFinish -= EventFinish;
     }
 
     void EventFinish( float duration )
     {
        // tu código...
     }
}

 
Condicionales: Los if esto o if aquello no representan el problema, muchos de estos procesos corresponden a decisiones lógicas irrelevantes. La papa está la tareas específicas, es decir una vez que ya ingresaste en alguna función o método, quizás el manejo de memoria, la creación de basura, multi threading, etc.
 
Dicho esto, la programación no está en hacer que algo simplemente funcione (eso lo hace cualquiera leyendo las referencias) si esto fuera así muchos investigadores, matemáticos y científicos que usan python o matlab para programar serían tremendos programadores (y claramente no lo son, uno se da cuenta). Para ellos, que quieren ser 100% funcionales va perfecto, que hagan todo el spaghetti que quieran (ya que simplemente necesitan apretar un botón y que la com***dora haga un cálculo una vez y listo). Un buen programador ve más allá de lo obvio, está proyectando soluciones a problemas (no errores) que quizás no existen en el momento, pero que seguramente van a aparecer. Cosas que pueden solucionarse con  modularidad, abstracción, dependencia, extensibilidad, etc.
 
En mi caso personal esto lo viví de una manera muy graciosa, un profesor de una materia de redes nos pidió hacer un trabajo práctico. Lo hice, todo perfecto, el programa a desarrollar debía leer un archivo txt con unas IP, después clasificarlas y demás. La cosa es que se lo entregué, el abrió el programa y a la hora de poner el argumento (Debía de ser "ip.txt") puso ""#$$"#ADF!!!!!¡¡¡?-----a1" ... y claro todo falló. Desaprobado. Cual fue el error? que yo como programador pensé que todo iban a ser buenos chicos, chicos de bien y poner "ip.txt"...grave error.
 
 
 
---> Lo del "?." lo hizo para cancherear, total y absolutamente, no es la primera vez .
 
 
 
Cita de: Jhonatan00_00 date=1580466881Pero a veces nos complicamos mas de la cuenta para hacer cosas sencillas y desde lo poco que conozco, se que por ejemplo cuando usamos time.Deltatime tras ese comando que Unity nos facilita hay una variable que va sumando al igual que si la creamos nosotros y que si usamos time.Deltatime 40 veces, cada vez es un contador nuevo que ha creado Unity, por tanto una variable invisible que nos consume recursos
   


La memoria ocupada por un float no es el "problema" aquí. La cosa está en llamar a esa variable múltiples veces desde una clase externa, siendo esto absolutamente innecesario. Sé que suena raro, desde ya que arrancar poniendo el foco en el DeltaTime no es algo que va a ser relevante frente al resto de las complicaciones que conlleva la creación de un juego (gráficos, lógica, networking, audio, manejo de memoria, etc). Ahora, si aislas todo y te ponés a pensar en lo que implica esto, estas llamando X veces (Ojo al piojo, X puede ser 40 como 40000000) a un valor que no cambia durante el frame, y que lo creas o no tiene un costo (no es gratis). Muchas veces está bien si estás en modo funcional y necesitas terminar algo de la noche a la mañana. Ahora si vas a hacerlo de forma seria sí hay un problema. Todo dependerá del contexto y de cuán adentrado estés.
 
Por ej si pruebas este simple script (usando stopWatch) que incrementa un valor a (a1 y a2):
 

using UnityEngine;
using System.Diagnostics;
public class test : MonoBehaviour
{
    public int count = 4000;
    void Update()
    {
        long resultTimeDT = 0;
        long resultDT = 0;
        float a1 = 0f;
        float a2 = 0f;
        float dt = Time.deltaTime;
        Stopwatch watch = new Stopwatch();
        watch.Start();
        for( int i = 0 ; i < count ; i++ )
            for( int j = 0 ; j < count ; j++ )
                a1 += Time.deltaTime;
        watch.Stop();
        resultTimeDT = watch.ElapsedMilliseconds;
        watch.Restart();
        for( int i = 0 ; i < count ; i++ )
            for( int j = 0 ; j < count ; j++ )
                a2 += dt;
        watch.Stop();
        resultDT = watch.ElapsedMilliseconds;
        print(string.Format("Time.deltaTime (ms) = {0} con a = {2} --- dt (ms) = {1} con a = {3}", resultTimeDT , resultDT , a1 , a2 ) );
       
    }
}

 
Mis resultados para count = 4000 (osea x2 de 4000^2 = 32 millones de incrementos):
 

 
Vas a notar la diferencia. Otra vez, ¿es super relevante ver el tema del Dt? no, pero si minimizar el efecto no cuesta nada mejor. ¿Vas a necesitar llamar 32 millones de veces un Time.deltaTime? nunca en la vida, si es así claramente estás haciendo algo mal. Esos casi 300 ms de más claramente justifican el definir un simple float.
 
 
 
Saludos
Título: incremento con while
Publicado por: francoe1 en Febrero 02, 2020, 10:07:38 PM
@Jocyf que compartía un material bastante llevadero, no se trataba de hacer una réplica del tutorial, si no, de la observación y la implementación de otras personas, luego, me di cuenta de la importancia del Open Source y lo gratificante que es empezar a apoyar proyectos en GIT.
 
En todo mi camino desarrolle para grandes y chicas empresas , proyectos fáciles, complicados hasta fracase un par de veces pero nunca nadie me explico absolutamente nada, nunca me dijeron el "Por qué" se realizaba algo de cierta manera, siempre tuve que buscar la explicación por mi parte, esto no quiere decir que no exista gente sin ganas de compartir, de hecho en el foro oficial de Unity hay personajes que me han ayudado bastante con problemas que en ese entonces creía complejos. 
 
Me termine dando cuenta de algo, los programadores nuevos (no quiero generalizar) simplemente aprender a repetir. La programación es un ARTE y PASIÓN quienes lo comprenden son las personas que pasan horas y horas escribiendo código, intentando entender, aprender y optimizar todo al máximo, no importa que sepas como funciona, lo que importa es la experiencia que tenes para implementar el conocimiento en diferentes contextos. 
 
Dando la explicación anterior se puede deducir porque decidi no perder tiempo en contestar a esta persona y aprovecharlo en algo mejor. (Aca invertí mi tiempo (//<___base_url___>/index.php?/topic/40828-estancamiento/&amp;tab=comments#comment-153120))
 
@Jhonatan00_00 No te lo tomes a mal, pero cuando no sabes de qué hablas, no tenes idea, es mejor no argumentar y menos aún intentar retrucar. Si quieres y realmente te gusta el desarrollo de juegos empieza por aprender y entender. En el topic hice 2 respuestas con soluciones, en la primera intente no invadir en la solución que el usuario encontró, esto es muy importante, cuando alguien te consulta algo tienes que responder siempre contextualizando el contenido según su conocimiento. La segunda respuesta es para ejemplificar que la problemática tiene una solución alternativa, más eficiente y la que se utiliza generalmente para resolver este problema, el incremento de una variable para este tipo de cosas es totalmente impracticable, inestable, inseguro, etc. Sin embargo, existen más formas aún, que se implementan en contextos diferentes, en conjunto con otros componentes que forman un sistema modular.
 
En resumen, no quiero que se mal entienda, me gusta ayudar y compartir mi conocimiento, me gusta leer a otros usuarios, pero me rompe mucho lo huevos que se intente discutir sin argumentos y/o conocimientos.
 
Saludos-