elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


Tema destacado: Arreglado, de nuevo, el registro del warzone (wargame) de EHN


Páginas: [1] 2 3 4 5 6 7 8 9 10
 1 
 en: Hoy a las 03:47 
Iniciado por Kahi - Último mensaje por .xAk.
por eso fiera, está/ba por defecto

 2 
 en: Hoy a las 02:52 
Iniciado por Tachikomaia - Último mensaje por Tachikomaia
Me acerqué a esto y sigo sin saber cómo resolverlo.

Mi idea es:
// Frame 1: La IA recibe una carta, el humano también.
// F2: Un objeto repite TurnoDeHumano hasta que se presione A.
// F3: Un objeto repite CartaOpcional hasta que se elija una opción.
// F4: Pequeña pausa.
// F5: Turno de la IA.
// F6: Nada, sólo para mostrar victoria o derrota.

El problema es CartaOpcional.

Variables relevantes:
MarioDKAt = 2;
MarioDKDescription = "Mario de Donkey Kong. Poder: "+MarioDKAt+"\nElige:\n<- Mario ataca con su poder normal.\n-> Pierdes 1HP, Mario ataca con su poder +1.";

Función normal, hay una para cada carta:
Código
  1. function MarioDK (ataque, objetivo) {
  2. if (objetivo == "IA") {
  3. // Esta carta tiene opciones:
  4. // Option1 = "Normal";
  5. Ataque1 = ataque;
  6. Mensaje1 = "¡Rival dañado!";
  7. // Option2 = "Hammer";
  8. Ataque2 = ataque+1;
  9. Mensaje2 = "¡Rival dañado y perdiste 1HP!";
  10. // Va a un frame hasta que se elige una:
  11. gotoAndStop (3);
  12. } else {
  13. // ESTO NECESITA IA
  14. Mensaje = Mensaje+"\n¡DKMario rival te dañó!";
  15. TipicoAtaqueDeIA(ataque);
  16. }
  17. }
  18.  
Que necesita IA no es el problema, eso lo debo hacer luego.

Función problemática:
Código
  1. function CartaOpcional () {
  2. // Si se presiona izquierda:
  3. if (Key.isDown(37)) {
  4. // Usa la carta elegida aplicando la opción 1:
  5. Mensaje = Mensaje1;
  6. TipicoAtaqueHumano (Ataque1);
  7. play();
  8. // sino si se presiona derecha:
  9. } else if (Key.isDown(39)) {
  10. Mensaje = Mensaje2;
  11. // ACÁ DEBE PERDER 1HP, NO ES TÍPICO
  12. TipicoAtaqueHumano (Ataque2);
  13. play();
  14. }
  15. }

El problema es que esa función debe ejecutarse repetidamente en el frame 3, hasta que el humano elija una opción. Sea cual sea la carta que usó. Pero las opciones y efectos dependen de la carta. En la función que ejecuta los efectos de DKMario intenté crear lo que servirían de parámetros. Pero no parece suficiente. Paso el mensaje que debe dar y el daño que debe causar al rival, pero no los efectos atípicos como daño al usuario, paralizar al rival, etc. ¿Debería crear una función para cada efecto y pasar el parámetro de qué efectos se deben llamar en cada opción?
Otra opción sería crear una función extra para este tipo de cartas, y con una variable indicar cual de ellas debe ejecutarse cuando se elija una opción.
Supongo que lo de función para cada efecto es mejor, aunque al principio parezca una tarea más pesada.
¿Está bien? ¿alternativas mejores?

 3 
 en: Hoy a las 02:25 
Iniciado por Tachikomaia - Último mensaje por Tachikomaia
Se pueden borrar sí, las globales y las declaradas en objetos (si borras el objeto, pero la forma normal también sirve supongo). Ejemplo, es parte del código que puse, en este caso de antes de que probara usar var:
Código
  1. function ChangePosibleColor () {
  2. delete EvaluedParte;
  3. NuevoColor = Rojo+Verde+Azul;
  4. delete Rojo;
  5. delete Verde;
  6. delete Azul;
  7. set (ShoweraModificar, NuevoColor);
  8. delete ShoweraModificar;
  9. PosiblesColores[NroDeColorPosible] = ConvertirHexEnDec(NuevoColor);
  10. trace ("NroDeColorPosible: "+NroDeColorPosible);
  11. delete NroDeColorPosible;
  12. delete NuevoColor;
  13. InsertarCuadros();
  14. }

¿Por qué empieza borrando una? Probablemente porque la función se usa desde 2 otras distintas que crean esa variable, entonces en vez de borrarla en cada una la borra acá. ¿Pero qué pasa si esta función se usa desde un lado donde esa variable no fue declarada? Por ahora no me ha dado problema.

Entiendo que si se usan mismos nombres en distintos lados puede haber problema, es cuestión de recordar qué nombres se ponen, no es necesario que sean iguales. Yo no uso nombres a, b, eso fue un ejemplo. De hecho abandoné intentar entender un código de GPT que tiene pila de nombres así, además era muy complicado para mí ese código. Y cuando los matemáticos ponen muchos nombres así cortos también me cuesta entender xD

 4 
 en: Hoy a las 01:58 
Iniciado por Kahi - Último mensaje por Danielㅤ
hace mucho que se guardan en remoto y se pueden recuperar sin conocimiento del usuario

Eso no es tan así compañero, porque para que eso funcione el usuario tiene que tener activada la sincronizacion en tiempo real o en todo caso hacer copias constantes de sus archivos.

 5 
 en: Hoy a las 01:24 
Iniciado por Kahi - Último mensaje por .xAk.
... cómo recuperar archivos multimedia y no archivos remotos

hace mucho que se guardan en remoto y se pueden recuperar sin conocimiento del usuario

 6 
 en: Hoy a las 01:14 
Iniciado por Tachikomaia - Último mensaje por EdePC
En Flash5 (ActionScript 1.0) las variables declaradas (var) son locales, lo que implica que solo son accesibles en el bloque donde fueron declarados y se destruyen al finalizar dicho bloque, llámese bloque a lo que está entre las llaves, por ejemplo una FUNCTION, un IF, FOR, etc y por supuesto a las variables que son parte de la definición de esos bloques como los parámetros por valor y el famoso var i = 0 del FOR, lo mismo si declaras variables fuera de los bloques.

Las variables sin declarar (sin var) son globales, por lo que son accesibles desde cualquier parte, y se destruyen al finalizar la película.

Código
  1. function GenerarTipo1ySumar () {
  2.   var a = random(10);
  3.   var b = random(10);
  4.   Sumar();
  5.   trace("Generados: "+a+", "+b);
  6. }
  7. // Supongamos que tengo generar tipo 2, 3, etc, distintas fomas de generar.
  8. function Sumar () {
  9.   Resultado = a+b;
  10.   trace("Suma: "+Resultado);
  11. }

Estás declarando las variables locales a y b, así que solo son accesibles en ese bloque, cuando llamas a Sumar() es otro bloque y no sabe de la existencia de a y b. En Sumar() has asignado a una variable sin declarar: Resultado, está será global y accesible desde cualquier otra parte

Citar
No le veo sentido a pasar parámetros que voy a borrar, prefiero que las variables estén en el lv0 y las borro, así no tengo que andar pasando cosas, que supongo es un gasto extra.

Borrarlas? no puedes borrarlas, las variables globales solo se destruyen cuando la película finalice, es buena práctica usar parámetros y variables locales para que no te llenes de variables globales acumulando memoria, las variables globales deberían ser contaditas con los dedos para que no entren en conflicto con las variables locales, más cuando usas nombres muy genéricos como a, b, i, etc

Lo bueno de las versiones viejas de javascript es que puedes usar var para redeclarar variables o no simplemente no usarlas, no te dará problemas, es muy permisivo el lenguaje, pero en las versiones modernas ya se tiene la opción de forzar la declaración de variables y evitar la redeclaración de estas para parecerse, más a los leguajes de programación más estrictos

 7 
 en: Ayer a las 22:39 
Iniciado por Tachikomaia - Último mensaje por Danielㅤ
Por curiosidad y quizá para otro caso (pues este ya se resolvió): ¿Cuales son los pasos a seguir? O sea, yo uso GPT en Poe y Deepseek ¿sirven? ¿les doy el link y lo hacen?

Además del link tenés que darle a la IA el patrón de búsqueda, es decir la regex que debería utilizar para obtener solamente los nombres de los juegos.

 8 
 en: Ayer a las 21:13 
Iniciado por Tachikomaia - Último mensaje por Tachikomaia


Código
  1. NroDeYodaaColocar = 0;
  2. Y = 713.5;
  3. Direction = 1;
  4. Scale = 100;
  5. do {
  6. Nombre = "Yoda"+NroDeYodaaColocar;
  7. attachMovie("sYellow", Nombre, NroDeYodaaColocar);
  8. setProperty (Nombre, _x, 90.9);
  9. setProperty (Nombre, _y, Y);
  10. setProperty (Nombre, _xscale, Scale*Direction);
  11. setProperty (Nombre, _yscale, Scale);
  12. NroDeYodaaColocar++;
  13. Y = Y-getProperty(Nombre, _height)/1.5;
  14. Direction = Direction*-1;
  15. Scale = Scale/1.15;
  16. } while (NroDeYodaaColocar < 100);
  17. Y = 713.5;
  18. Direction = 1;
  19. Scale = 100;
  20. do {
  21. Nombre = "Yoda"+NroDeYodaaColocar;
  22. attachMovie("sRosa", Nombre, NroDeYodaaColocar);
  23. setProperty (Nombre, _x, 499.1);
  24. setProperty (Nombre, _y, Y);
  25. setProperty (Nombre, _xscale, Scale*Direction);
  26. setProperty (Nombre, _yscale, Scale);
  27. NroDeYodaaColocar++;
  28. Y = Y-getProperty(Nombre, _height);
  29. Direction = Direction*-1;
  30. Scale = Scale/1.4;
  31. } while (NroDeYodaaColocar < 150);
  32. attachMovie("sTexto", "Texto", NroDeYodaaColocar);

 9 
 en: Ayer a las 19:26 
Iniciado por Tachikomaia - Último mensaje por Tachikomaia
No me gustaba iniciarlas así, me parecía complicar en vano, hasta que recientemente me enteré de que iniciadas así en una función, se borran cuando termina. Es mejor que crearlas normal y luego borrarlas en una línea extra.

Así que me tomé la molestia de modificar un código para que funcione así. Pero falla en ciertos casos. Cuando cambio colores usando botones (el programa que estoy haciendo tiene esa opción), en este para incrementar un color (rojo, verde o azul):
Código
  1. // Usada en botones up de posibles colores de cuadraditos:
  2. function IncrementarColor (nroDeColorPosible, incremento, parte) {
  3. // nroDeColorPosible es qué elemento del array de...
  4. // colores posibles será modificado.
  5. // parte es qué parte del color: Rojo, verde o azul.
  6. var ShoweraModificar = "ShowerDePosibleColor"+nroDeColorPosible;
  7. trace ("ShoweraModificar: "+ShoweraModificar);
  8. var EvaluedShower = eval(ShoweraModificar);
  9. trace ("EvaluedShower: "+EvaluedShower);
  10. if (EvaluedShower != "Ninguno") {
  11. // Para modificar la parte indicada,
  12. // dividir el color en 3 partes:
  13. var Rojo = EvaluedShower.substr(0, 2);
  14. var Verde = EvaluedShower.substr(2, 2);
  15. var Azul = EvaluedShower.substr(4, 2);
  16. trace("Colores captados: "+Rojo+", "+Verde+", "+Azul);
  17. // Obtener la parte a incrementar:
  18. var EvaluedParte = eval(parte);
  19. trace ("EvaluedParte: "+EvaluedParte);
  20. // Convertirla en decimal:
  21. EvaluedParte = ConvertirHexEnDec(EvaluedParte);
  22. trace("Convertirla en decimal: "+EvaluedParte);
  23. // Incrementarla:
  24. EvaluedParte = Math.min(EvaluedParte+incremento, 255);
  25. trace("Incrementarla: "+EvaluedParte);
  26. // Convertirlo en hexadecimal:
  27. EvaluedParte = ConvertirDecEnHex(EvaluedParte);
  28. trace("Convertirla en hexadecimal: "+EvaluedParte);
  29. // Transferirla a la variable origen:
  30. set (parte, EvaluedParte);
  31. trace ("parte: "+parte+": "+EvaluedParte);
  32. // Para que la variable nroDeColorPosible pueda usarse...
  33. // en otras funciones:
  34. _level0.NroDeColorPosible = nroDeColorPosible;
  35. trace ("Variable copiada a lv0: NroDeColorPosible: "+nroDeColorPosible);
  36. trace("Rojo: "+Rojo);
  37. trace("Verde: "+Verde);
  38. trace("Azul: "+Azul);
  39. // Cambiar el color:
  40. ChangePosibleColor();
  41. }
  42. }
  43. function ChangePosibleColor () {
  44. trace("Ejecutando ChangePosibleColor");
  45. trace("Rojo: "+Rojo);
  46. trace("Verde: "+Verde);
  47. trace("Azul: "+Azul);
  48. // etc
  49. }

Ejemplo de salida siendo azul (si mal no recuerdo:
nroDeColorPosible es 0, podría ser otra cosa, no importa aquí mientras el valor se conserve
incremento es 1, idem
parte es "Azul" o 2, no me acuerdo, pero funcionaba):
Citar
ShoweraModificar: ShowerDePosibleColor0
EvaluedShower: 000000
Colores captados: 00, 00, 00
EvaluedParte: 00
Convertirla en decimal: 0
Incrementarla: 1
Convertirla en hexadecimal: 01
parte: Azul: 01
Variable copiada a lv0: NroDeColorPosible: 0
Rojo: 00
Verde: 00
Azul: 01
Ejecutando ChangePosibleColor
Rojo:
Verde:
Azul:
Vean que las variables Rojo, Verde y Azul ¡se pierden! Pero la función IncrementarColor aún no terminó ¿por ejecutar otra función dentro de ella, sus variables se pierden?

Ejemplo más sencillo:
Código
  1. function GenerarTipo1ySumar () {
  2.   var a = random(10);
  3.   var b = random(10);
  4.   Sumar();
  5.   trace("Generados: "+a+", "+b);
  6. }
  7. // Supongamos que tengo generar tipo 2, 3, etc, distintas fomas de generar.
  8. function Sumar () {
  9.   Resultado = a+b;
  10.   trace("Suma: "+Resultado);
  11. }

Iba a preguntar si al hacer Sumar las variables se pierden, pero se me ocurrió una posible explicación: Las variables aún no se borraron, pero están dentro de la función así que para usarlas fuera no se las puede nombrar como si estuvieran en el lv0, no sé cómo habría que llamarlas pero... quizá GenerarTipo1ySumar.a y .b

¿Es así?

¿Entonces me conviene usar var si conviene que la variable se borre luego de la función, pero sólo si no es usada por otra dentro de ella?
Porque hacer referencias como esa que puse GenerarTipo1ySumar.a está un poco raro ¡y no serviría! ahora que me doy cuenta, porque si hay más funciones que usan Sumar entonces a Sumar habría que indicarle desde dónde está siendo llamada para que sepa el nombre que debe usar ¡un lío!

¿Es así?

Respuesta de GPT:
Citar
En ActionScript 1/2 (como en Flash 5), el uso de var define variables con alcance local a la función. Eso significa:

- Las variables declaradas con var existen solo mientras se ejecuta esa función y solo son visibles dentro de esa función.
- Al salir de la función, las variables locales quedan fuera de alcance (son recolectadas más adelante).
- Llamar otra función desde dentro no “borra” las variables locales; simplemente no están en el ámbito de la otra función.

Qué está pasando en tus ejemplos:

1) Caso IncrementarColor / ChangePosibleColor
- Rojo, Verde y Azul se declaran con var dentro de IncrementarColor.
- ChangePosibleColor es otra función, con su propio ámbito. Dentro de ChangePosibleColor, las variables locales de IncrementarColor no son visibles, por eso aparecen vacías en los traces.
- Antes de llamar ChangePosibleColor, sigues viendo los valores correctos porque aún estás dentro de IncrementarColor.

Cómo pasar esos valores correctamente:
- Pásalos como parámetros:
  function ChangePosibleColor(rojo, verde, azul) { trace(rojo, verde, azul); ... }
  y llamas ChangePosibleColor(Rojo, Verde, Azul);

- O almacénalos en un objeto/propiedad accesible (por ejemplo en this o en _level0, aunque usar niveles globales es frágil):
  this.Rojo = Rojo; this.Verde = Verde; this.Azul = Azul;
  y en ChangePosibleColor leer this.Rojo, etc. Asegúrate de qué es this en ese contexto.

- O usa un objeto ColorState para agruparlos y pasarlo completo:
  var color = { r: Rojo, v: Verde, a: Azul };
  ChangePosibleColor(color);

2) Caso GenerarTipo1ySumar / Sumar
- a y b están declaradas con var dentro de GenerarTipo1ySumar, por lo que Sumar no puede verlas. En Sumar, a y b son indefinidas, y Resultado = a + b dará NaN.
- La forma correcta es pasar los operandos como argumentos:
  function Sumar(a, b) {
    var Resultado = a + b;
    trace("Suma: " + Resultado);
    return Resultado;
  }
  function GenerarTipo1ySumar() {
    var a = random(10);
    var b = random(10);
    var res = Sumar(a, b);
    trace("Generados: " + a + ", " + b);
  }

Respondiendo a tus preguntas directas:

- “¿Se pierden las variables locales al llamar otra función?” No. Siguen existiendo en su propio ámbito, pero la otra función no las ve a menos que se las pases (parámetros) o las pongas en un ámbito compartido (propiedad de objeto/global).

- “¿Puedo referirme como GenerarTipo1ySumar.a?” No en AS1/2. Las variables locales no son propiedades del objeto función. No puedes acceder a ellas desde fuera; no existe esa sintaxis para cerrar sobre el stack de la función.

- “¿Conviene usar var?” Sí. Úsalo siempre para variables locales temporales. Para compartir datos entre funciones:
  - Pasa parámetros y devuelve resultados (mejor práctica).
  - O usa propiedades de un objeto contenedor (this, un MovieClip, o un objeto “modelo”).
  - Evita depender de _level0 salvo que sea intencional y controlado.

Notas específicas de Flash 5/AS1:
- eval() y set() funcionan, pero son frágiles. Mejor usa objetos y arrays en lugar de construir nombres de variables como strings.
- Si estás armando nombres como "ShowerDePosibleColor0", considera guardar esos valores en un array: var ShowerDePosibleColor = ["000000", "ffcc00", ...]; y acceder por índice.
- Evita variables globales implícitas (asignar sin var). Pueden chocar nombres y dificultan el mantenimiento.

Refactor breve del primer caso sin eval/set:

- Supón un array de colores hex string:
  var coloresPosibles = ["000000","000000",...];

- Incremento:
  function IncrementarColor(idx, inc, parte) {
    var hex = coloresPosibles[idx]; // "rrggbb"
    var r = hex.substr(0,2);
    var g = hex.substr(2,2);
    var b = hex.substr(4,2);

    var map = { Rojo:"r", Verde:"g", Azul:"b" };
    var key = map[parte]; // "r"/"g"/"b"

    var val = ConvertirHexEnDec((key=="r")?r:(key=="g")?g:b);
    val = Math.min(val + inc, 255);
    var hexVal = ConvertirDecEnHex(val);

    if (key=="r") r = hexVal;
    else if (key=="g") g = hexVal;
    else b = hexVal;

    coloresPosibles[idx] = r+g+b;
    ChangePosibleColor(r, g, b, idx);
  }

  function ChangePosibleColor(r, g, b, idx) {
    trace("Rojo: " + r);
    trace("Verde: " + g);
    trace("Azul: " + b);
    // actualizar UI del índice idx...
  }

Conclusión:
- var no borra variables “antes de tiempo” por llamar otra función; simplemente respeta el alcance local.
- Para que otra función use esos valores, pásalos como parámetros o guárdalos en un lugar compartido conocido. Evita eval/set y variables globales implícitas.

No le veo sentido a pasar parámetros que voy a borrar, prefiero que las variables estén en el lv0 y las borro, así no tengo que andar pasando cosas, que supongo es un gasto extra.

Bue... duda resuelta supongo.

 10 
 en: Ayer a las 18:43 
Iniciado por Tachikomaia - Último mensaje por Tachikomaia
Hazlo por IA, yo he utilizado Copilot:
Por curiosidad y quizá para otro caso (pues este ya se resolvió): ¿Cuales son los pasos a seguir? O sea, yo uso GPT en Poe y Deepseek ¿sirven? ¿les doy el link y lo hacen?

Páginas: [1] 2 3 4 5 6 7 8 9 10
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines