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

 

 


Tema destacado: Tutorial básico de Quickjs


  Mostrar Mensajes
Páginas: 1 ... 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 [40] 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 ... 192
391  Programación / Programación General / Re: Proyecto de Motor de Juegos (Interrupción de Teclado) en: 24 Mayo 2023, 12:02 pm
Cita de: ~ en 17 Abril 2023, 17:36 pm
Sí, sería de explicar todo lo que has desarrollado del tutorial, desarrollar y explicar paso a paso como para que alguien más pueda seguir e implementar su propia versión a partir de eso.
El código te lo di en un link, te lo dejo acá:
Código
  1. fscommand ("fullscreen", "true");
  2. Player.Facing = 1;
  3. Player.Attacking = 0;
  4. Player.Action = 1;
  5. // 0 crouching, 0.5 startingjump, 1 nothing, 2 walking, 3 falling, 3.5 minjump, 4 jumping.
  6. // /////////////////////////////////////////////
  7. // //////////////////  Bond  ///////////////////
  8. // /////////////////////////////////////////////
  9. function PersControl () {
  10. 		if (Player.Action == 2) {
  11. 			// Si el personaje está caminando.
  12. 			if (Key.isDown(65)) {
  13. 				// Si se presiona A.
  14. 				StartingJump();
  15. 			} else if (Key.isDown(83)) {
  16. 				// Si se presiona S.
  17. 				Attack();
  18. 			} else if (Key.isDown(40)) {
  19. 				// Si se presiona abajo.
  20. 				Crouch();
  21. 			} else if (Key.isDown(39)) {
  22. 				// Si se presiona derecha.
  23. 				FaceRight();
  24. 				Player._x = Player._x+0.9;
  25. 			} else if (Key.isDown(37)) {
  26. 				// Si se presiona izquierda.
  27. 				FaceLeft();
  28. 				Player._x = Player._x-0.9;
  29. 			} else {
  30. 				Quiet();
  31. 			}
  32. //FALTA THROW
  33. 	} else if (Player.Attacking == 0) {
  34. 		// Si el personaje no está atacando.
  35. 		if (Player.Action == 1) {
  36. 			// Si el personaje está en reposo.
  37. 			if (Key.isDown(65)) {
  38. 				// Si se presiona A.
  39. 				StartingJump();
  40. 			} else if (Key.isDown(83)) {
  41. 				// Si se presiona S.
  42. 				Attack();
  43. 			} else if (Key.isDown(40)) {
  44. 				// Si se presiona abajo.
  45. 				Crouch();
  46. 			} else if (Key.isDown(39)) {
  47. 				// Si se presiona derecha.
  48. 				FaceRight();
  49. 				Player._x = Player._x+0.9;
  50. 				Walk();
  51. 			} else if (Key.isDown(37)) {
  52. 				// Si se presiona izquierda.
  53. 				FaceLeft();
  54. 				Player._x = Player._x-0.9;
  55. 				Walk();
  56. 			}
  57. //FALTA THROW
  58. 		} else if (Player.Action == 3) {
  59. 			// Si el personaje está cayendo.
  60. 			Player.SpeedY = Player.SpeedY+0.1;
  61. 			MovingJump();
  62. 			if (Player._y>=554) {
  63. 				// Si el personaje toca el suelo.
  64. 				Player._y = 554;
  65. // Acá no debería haber Quiet sino FallEnd o...
  66. // depende de la velocidad de la caída???
  67. 				Quiet();
  68. 			}
  69. //FALTA: AT, THROW
  70. 		} else if (Player.Action == 4) {
  71. 			// Si el personaje está saltando.
  72. 			Jump();
  73. //FALTA: AT, THROW
  74. 		} else if (Player.Action == 0.5) {
  75. 			// Si el personaje está empezando a saltar.
  76. 			if (Key.isDown(39)) {
  77. 				// Si se presiona derecha.
  78. 				if (Player.Facing == -1) {
  79. 					Player.Facing = 1;
  80. 				}
  81. 				Player.SpeedX = 0.9;
  82. 			} else if (Key.isDown(37)) {
  83. 				// Si se presiona izquierda.
  84. 				if (Player.Facing == 1) {
  85. 					Player.Facing = -1;
  86. 				}
  87. 				Player.SpeedX = -0.9;
  88. 			} else {
  89. 				Player.SpeedX = 0;
  90. 			}
  91. //FALTA: AT, THROW, Down?
  92. 		} else if (Player.Action == 0) {
  93. 			// Si el personaje está agachado.
  94. 			if (Key.isDown(40)) {
  95. 				// Si se presiona abajo.
  96. 				if (Key.isDown(65)) {
  97. 					// Si se presiona A.
  98. 					StartingJump();
  99. 				} else if (Key.isDown(83)) {
  100. 					// Si se presiona S.
  101. 					Player.Attacking = 1;
  102. 					Player.gotoAndPlay(124);
  103. 				}
  104. 			} else {
  105. 				Quiet ();
  106. 			}
  107. 		} else if (Player.Action == 3.5) {
  108. 			// Si el personaje está saltando pero aún no llegó a cierta altura.
  109. 			Player.SpeedY = Player.SpeedY+0.1;
  110. 			if (Player.SpeedY<-3) {
  111. 				MovingJump();
  112. 			} else {
  113. 				// Si el personaje llegó a cierta altura (y perdió cierta velocidad).
  114. 				Player.Action = 4;
  115. 				Jump();
  116. 			}
  117. //FALTA: AT, THROW???
  118. 		}
  119. //¿FALTA: AT, THROW, AG?
  120. 	}
  121. }
  122. //JUMP, AG WHILE STARTING AT? AFTER?
  123. //AG
  124. // Otras funciones.
  125. function StartingJump () {
  126. 	Player.gotoAndPlay(96);
  127. 	Player.Action = 0.5;
  128. }
  129. function MovingJump () {
  130. 	Player._x = Player._x+Player.SpeedX;
  131. 	Player._y = Player._y+Player.SpeedY;
  132. }
  133. function MinJump () {
  134. 	Player.Action = 3.5;
  135. 	Player.SpeedY = -4;
  136. 	MovingJump();
  137. }
  138. function Jump () {
  139. 	if (Key.isDown(65)) {
  140. 		// Si se presiona A.
  141. 		Player.SpeedY = Player.SpeedY+0.1;
  142. 		if (Player.SpeedY>=0) {
  143. 			// Si el personaje comienza a caer.
  144. 			Fall();
  145. 		}
  146. 	} else {
  147. 		// Si se suelta A.
  148. 		Player.SpeedY = 0.1;
  149. 		Fall();
  150. 	}
  151. 	MovingJump();
  152. }
  153. function Fall () {
  154. 	Player.Action = 3;
  155. 	Player.play();
  156. }
  157. function Walk () {
  158. 	Player.gotoAndPlay(35);
  159. 	Player.Action = 2;
  160. }
  161. function Attack () {
  162. 	Player.gotoAndPlay(2);
  163. 	Player.Attacking = 1;
  164. 	Player.Action = 1;
  165. }
  166. function FaceRight () {
  167. 	if (Player.Facing == -1) {
  168. 		Player.Facing = 1;
  169. 		Player._xscale = 100;
  170. 	}
  171. }
  172. function FaceLeft () {
  173. 	if (Player.Facing == 1) {
  174. 		Player.Facing = -1;
  175. 		Player._xscale = -100;
  176. 	}
  177. }
  178. function Crouch () {
  179. 	Player.gotoAndStop(96);
  180. 	Player.Action = 0;
  181. }
  182. function Quiet () {
  183. 	Player.gotoAndStop(1);
  184. 	Player.Action = 1;
  185. }
  186. //Player.SpeedX = 0.9*Player.Facing;
  187. //Jump();
Algunas cosas están sin hacer o confusas, estoy aprendiendo.

Las imágenes es un poco más complicado explicar cómo hacer que aparezcan, pero me parece que depende mucho del programa que uses. Usando Quickbasic o Clipper, no tengo idea cómo hacer lo que puedo hacer con Flash. También he probado algún que otro programa muy poquito y no me parecieron tan visuales y fáciles como él.

De nuevo no te entiendo, en el leguaje que uso simplemente pones que si se presiona una tecla se hace X cosa u otra dependiendo de ciertas condiciones, tú hablas de crear una tabla y cosas que ¿son de lenguaje de bajo nivel? Creo que mi Flash no permite jugar en modo multijugador, pero probablemente te convenga usar un lenguaje de más alto nivel.
392  Programación / Programación General / Re: Ayuda con cálculos para que la trayectoria de una pelota cumpla ciertas condiciones. en: 24 Mayo 2023, 08:43 am
He estado pensando en otras cosas o cansado, pero aquí vuelvo ;D

Cita de: RayR en 17 Mayo 2023, 03:01 am
Fíjate bien lo que te puse, y de ser necesario, ve las  explicaciones de mensajes anteriores, porque además te estás saltando algún paso.
Vale, luego de leer tu post.

Citar
Por ejemplo, aquí:

Código:
DistanciahastaRed = DistanciahastaDestinoXY*Math.abs(RedZ-BallZ)/Math.abs(DistanciahastaDestinoY);

En vez de RedZ-BallZ va RedY - BallY.
Ok, asumí que RedY era la altura así que lo llamé RedZ, y cuando vi -BallY me confundí y lo cambié por BallZ, supongo que fue por eso. Me confunde que Y sea Z...

Citar
Luego, como te comenté (y expliqué con más detalle en mi segundo mensaje), si Disc es negativo, no puedes hacer el tiro, no tienes la fuerza necesaria, así que ya ni siquiera tiene sentido calcular los ángulos y todo lo demás.
¿Qué sucede si se calcula? Pensé que el tiro saldría corto ¿no ocurre eso? Si no se tiene suficiente fuerza igual debe haber un tiro, como si el personaje hubiera querido hacer un buen tiro. No tiene sentido que no se haga un tiro.

Citar
En todo caso, podrías escoger un nuevo destino más cercano, como lo mencionaste en relación al punto 5, y repetir el procedimiento a ver si este sí lo puedes hacer.
Sí ¿y si el más cercano tampoco sirve?

Citar
Además, fíjate que después de calcular AlturaEnRedTheta y AlturaEnRedPhi puse:
"Si ambos pasan por encima, elige el más alto o bajo, según prefieras"
Pero tú ya directamente supones que ambos lo hacen y pasas a elegir el ángulo más bajo. Primero debes comprobar si alguno de los ángulos pasa por arriba de la red. Si sólo uno de los ángulos lo hace, obviamente lo tienes que usar, no hay otra opción. Únicamente si ambos pasan sobre la red, toca elegir el más bajo o alto. Y naturalmente, si ninguno lo consigue, toca aquí también elegir nuevo destino o lo que quieras.
Pensé que tu método indicaba si pasaban o no.
...
Se me hizo líoso hacerlo, pero creo que está. También corregí, creo, que en vez de usar los ángulos usaba las alturas. ¿Disc qué abrevia o qué significa?

Citar
este cálculo no es correcto:
Código:
    BallZSpeed = BallZ-BallZAnterior;
porque simplemente te daría la velocidad promedio a lo largo del último intervalo de tiempo, en este caso, el último segundo (porque creo que incrementas el tiempo un segundo a la vez, ¿no?), pero tú lo que buscas es el valor de la velocidad en el instante actual, que es distinto. La forma de hacerlo sería esta:
Código:
    BallZSpeed =  VelocidadZ - Gravedad * Tiempotranscurridodeltiro;
Creo que eso me quedó sin borrar del método anterior, creo que no influye salvo en el pique, que aún no lo arreglé. Gracias igual, si llego a eso y no lo puedo resolver te consulto. Lo borro por ahora a ver.

Citar
Una última cosa: supongo que estás usando escalas adecuadas, ¿no?
Probablemente no, el personaje es muy bajo por ejemplo. En el juego original los saques se hacen por encima del alcance de la raqueta y no se nota, pero en mi caso son acordes al alcance y me parece un poco bajo. El juego original:
https://www.youtube.com/watch?v=fc0_P2IGgJ4
¿Crees que habrá mucha diferencia en las escalas con el mío? Que yo sepa lo único que hice fue que la cancha entrara toda en la pantalla y también parte del fondo y los laterales, ya que en el juego original hay como paredes invisibles que si la bola toca es punto :-\ (no se nota salvo casos muy poco probables). También achiqué un poco al personaje porque ahí pareciera que ocuparan demasiado de la cancha.

En mi juego la cancha mide 239.9 de ancho (sin contar el corredor de dobles) y 480 de largo. Ese .9 es por motivos que no comprendo ni sé arreglar (ni volveré a dedicar tiempo a intentarlo), pero es mínimo, debería ser 240. La altura de la red es de unos 17.4 (pero la bola debe pasar a 18.6 mínimo). En fin, puse la gravedad que me pareció agradable a mi vista, no creo que sea ni tan poca ni tanta, pero ahora que lo dices, si con tu método es menos intensa aunque se use el mismo número, puede que deba aumentarla.
En el juego la fuerza de los tiros depende del tiempo de preparación, la fuerza de brazos, piernas, calidad de la raqueta y cuánto se usó en darle efecto a la bola, no sé si algo más... No he pensado o consultado tanto sobre eso. No tiene sentido que te de más detalles de eso tampoco ¿no? Te digo porque me llama la atención el 25 que pusiste ¿a qué se debe?

No tengo mucho interés en que sea tan realista en cuanto a velocidades o tamaños (especialmente la bola, sino no la veo mucho), tengo pensado que haya gran variedad de campeonatos variando el tamaño de algunas cosas por ejemplo. En otros aspectos sí quiero que sea realista, como he explicado.

Bueno, reviso el código de principio a fin, lo comparo con lo que has puesto.

Pusiste:
Disc = v0 * v0 * v0 * v0 - (g * (g * DistanciahastaDestinoXY * DistanciahastaDestinoXY - 2 * v0 * v0 * h))

Puse:
Código
  1. Parte = AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros;
  2. Disc = Parte-(Gravedad*(Gravedad*DistanciahastaDestinoXY*DistanciahastaDestinoXY-2*AlexFuerzadetiros*AlexFuerzadetiros*BallZ));

Luego debido a los ifs es complicado poner parte por parte, lo haré más adelante; este es el código con las partes más relevantes de este contexto supongo:
Código
  1. Gravedad = 0.01;
  2. RedZ = 18.6;
  3. // Datos para determinar velocidades del tiro.
  4. DistanciahastaDestinoX = BallX-280.1;
  5. DistanciahastaDestinoY = BallY-180;
  6. // DistanciahastaRed = BallY-300;
  7. // DistanciahastaMinsafeBallZ = BallZ-18.6;
  8. DistanciahastaDestinoXY = Math.sqrt(DistanciahastaDestinoX*DistanciahastaDestinoX+DistanciahastaDestinoY*DistanciahastaDestinoY);
  9. // Se calcula el ángulo o ángulos.
  10. Parte = AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros;
  11. Disc = Parte-(Gravedad*(Gravedad*DistanciahastaDestinoXY*DistanciahastaDestinoXY-2*AlexFuerzadetiros*AlexFuerzadetiros*BallZ));
  12. if (Disc<0) {
  13.     // Fuerza insuficiente, si es posible habrá que acercar el destino.
  14.     TiroRealizable = "Fuerza insuficiente";
  15. } else {
  16.     DistanciahastaRed = DistanciahastaDestinoXY*Math.abs(RedZ-BallY)/Math.abs(DistanciahastaDestinoY);
  17.     // Le he llamado RedZ a lo que has llamado RedY.
  18.     // Se calcula el ángulo Z;
  19.     theta = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros+Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
  20.     // Se calcula el tiempo que se tarda en llegar a la red.
  21.     TiempoHastaRedTheta = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(theta));
  22.     // Se calcula la altura a la que pasa la bola al llegar a la red.
  23.     AlturaEnRedTheta = BallZ+AlexFuerzadetiros*Math.sin(theta)*TiempoHastaRedTheta-(Gravedad*TiempoHastaRedTheta*TiempoHastaRedTheta)/2;
  24.     if (Disc == 0) {
  25.         // Sólo hay 1 ángulo Z posible.
  26.         if (AlturaEnRedTheta>=18.6) {
  27.             // Si la bola pasa la red con ese ángulo, usarlo.
  28.             TiroRealizable = "1 ángulo, ok";
  29.             Angulo = theta;
  30.         } else {
  31.             TiroRealizable = "1 ángulo, imposible";
  32.             // Probar acercar destino supongo.
  33.             Angulo = "Ninguno";
  34.         }
  35.     } else {
  36.         // Disc>0, hay 2 angulos posibles, calcular el faltante.
  37.         phi = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros-Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
  38.         TiempoHastaRedPhi = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(phi));
  39.         AlturaEnRedPhi = BallZ+AlexFuerzadetiros*Math.sin(phi)*TiempoHastaRedPhi-(Gravedad*TiempoHastaRedPhi*TiempoHastaRedPhi)/2;
  40.         if (AlturaEnRedTheta>=18.6) {
  41.             if (AlturaEnRedPhi>=18.6) {
  42.                 // Con ambos ángulos la bola pasa la red, usar el más bajo.
  43.                 if (AlturaEnRedTheta<AlturaEnRedPhi) {
  44.                     Angulo = theta;
  45.                 } else {
  46.                     Angulo = phi;
  47.                 }
  48.             } else {
  49.                 // Sólo sirve el 1er ángulo.
  50.                 Angulo = theta;
  51.             }
  52.         } else if (AlturaEnRedPhi>=18.6) {
  53.             // Sólo sirve el 2ndo ángulo.
  54.             Angulo = phi;
  55.         } else {
  56.             // Ningún ángulo sirve.
  57.             Angulo = "Ninguno";
  58.             // Probar acercar destino supongo.
  59.         }
  60.     }
  61.     if (Angulo != "Ninguno") {
  62.         // Cálculo de las velocidades.
  63.         VelocidadAdelante = AlexFuerzadetiros*Math.cos(Angulo);
  64.         VelocidadArriba = AlexFuerzadetiros*Math.sin(Angulo);
  65.         // Esta variable es redundante, pero clarifica lo que se esta haciendo.
  66.         VelocidadZ = VelocidadArriba;
  67.         if (DistanciahastaDestinoX == 0) {
  68.             BallXSpeed = 0;
  69.             BallYSpeed = VelocidadAdelante*-1;
  70.         } else {
  71.             AnguloPendiente = Math.atan(DistanciahastaDestinoY/DistanciahastaDestinoX);
  72.             BallXSpeed = VelocidadAdelante*Math.cos(AnguloPendiente)*-1;
  73.             BallYSpeed = VelocidadAdelante*Math.sin(AnguloPendiente)*-1;
  74.         }
  75.         // Datos para determinar posiciones de la pelota.
  76.         Tiempotranscurridodeltiro = 0;
  77.         BallXwhenstriked = BallX;
  78.         BallYwhenstriked = BallY;
  79.         BallZwhenstriked = BallZ;
  80.     }
  81. }

Dijiste:
Si Disc < 0, no puedes hacer el tiro

Puse:
Código:
if (Disc<0) {
	// Fuerza insuficiente, si es posible habrá que acercar el destino.
	TiroRealizable = "Fuerza insuficiente";
} else {
Y que yo sepa nada ocurrirá ahí, en el caso de true. Lo de cambiar destino lo haré más adelante.

Dijiste:
Si Disc == 0, hay un solo angulo posible
Si Disc > 0, hay dos angulos
Esos casos son mi else, calculo 1 ángulo y luego si Disc>0 calculo el otro. Alteré un poco el orden de tu código pero creo que no hay problema.

Haces:
theta = arctan((v0 * v0 + raiz(Disc)) / (g * DistanciahastaDestinoXY))
DistanciahastaRed = DistanciahastaDestinoXY * abs(RedY - BallY) / abs(DistanciahastaDestinoY)
TiempoHastaRedTheta = (DistanciahastaRed) / (v0 * cos(theta))

Hice:
Código
  1. DistanciahastaRed = DistanciahastaDestinoXY*Math.abs(RedZ-BallY)/Math.abs(DistanciahastaDestinoY);
  2. // Le he llamado RedZ a lo que has llamado RedY.
  3. theta = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros+Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
  4. TiempoHastaRedTheta = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(theta));
  5. AlturaEnRedTheta = BallZ+AlexFuerzadetiros*Math.sin(theta)*TiempoHastaRedTheta-(Gravedad*TiempoHastaRedTheta*TiempoHastaRedTheta)/2;

Lo último te lo copié de esto:
AlturaEnRedTheta = h + v0 * sen(theta) * TiempoHastaRedTheta - (g * TiempoHastaRedTheta * TiempoHastaRedTheta) / 2

Luego lo que hago depende del caso como habías dicho:

Código
  1. if (Disc == 0) {
  2. 	// Sólo hay 1 ángulo Z posible.
  3. 	if (AlturaEnRedTheta>=18.6) {
  4. 		// Si la bola pasa la red con ese ángulo, usarlo.
  5. 		TiroRealizable = "1 ángulo, ok";
  6. 		Angulo = theta;
  7. 	} else {
  8. 		TiroRealizable = "1 ángulo, imposible";
  9. 		// Probar acercar destino supongo.
  10. 		Angulo = "Ninguno";
  11. 	}
  12. } else {
  13. 	// Disc>0, hay 2 angulos posibles, calcular el faltante.
  14. 	phi = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros-Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
  15. 	TiempoHastaRedPhi = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(phi));
  16. 	AlturaEnRedPhi = BallZ+AlexFuerzadetiros*Math.sin(phi)*TiempoHastaRedPhi-(Gravedad*TiempoHastaRedPhi*TiempoHastaRedPhi)/2;
  17. 	if (AlturaEnRedTheta>=18.6) {
  18. 		if (AlturaEnRedPhi>=18.6) {
  19. 			// Con ambos ángulos la bola pasa la red, usar el más bajo.
  20. 			if (AlturaEnRedTheta<AlturaEnRedPhi) {
  21. 				Angulo = theta;
  22. 			} else {
  23. 				Angulo = phi;
  24. 			}
  25. 		} else {
  26. 			// Sólo sirve el 1er ángulo.
  27. 			Angulo = theta;
  28. 		}
  29. 	} else if (AlturaEnRedPhi>=18.6) {
  30. 		// Sólo sirve el 2ndo ángulo.
  31. 		Angulo = phi;
  32. 	} else {
  33. 		// Ningún ángulo sirve.
  34. 		Angulo = "Ninguno";
  35. 		// Probar acercar destino supongo.
  36. 	}
  37. }
¿Todo bien?

Habías dicho:
Código:
phi = arctan((v0 * v0 - raiz(Disc)) / (g * DistanciahastaDestinoXY))
TiempoHastaRedPhi = (DistanciahastaRed) / (v0 * cos(phi))
AlturaEnRedPhi = h + v0 * sen(phi) * TiempoHastaRedPhi - (g * TiempoHastaRedPhi * TiempoHastaRedPhi) / 2

Yo ahí puse:
Código
  1. phi = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros-Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
  2. TiempoHastaRedPhi = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(phi));
  3. AlturaEnRedPhi = BallZ+AlexFuerzadetiros*Math.sin(phi)*TiempoHastaRedPhi-(Gravedad*TiempoHastaRedPhi*TiempoHastaRedPhi)/2;

Luego dices:
Código:
VelocidadAdelante = v0 * cos(angulo)
VelocidadArriba = v0 * sen(angulo)

// Esta variable es redundante, pero clarifica lo que se esta haciendo
VelocidadZ = VelocidadArriba

Puse:
Código:
if (Angulo != "Ninguno") {
	// Cálculo de las velocidades.
	VelocidadAdelante = AlexFuerzadetiros*Math.cos(Angulo);
	VelocidadArriba = AlexFuerzadetiros*Math.sin(Angulo);
	// Esta variable es redundante, pero clarifica lo que se esta haciendo.
	VelocidadZ = VelocidadArriba;

Dices:
Código:
si (DistanciahastaDestinoX == 0)
   BallYSpeed = VelocidadAdelante
   BallXSpeed = 0
sino
   AnguloPendiente = arctan(DistanciahastaDestinoY / DistanciahastaDestinoX)
   BallXSpeed = VelocidadAdelante * cos(AnguloPendiente)
   BallYSpeed = VelocidadAdelante * sen(AnguloPendiente)

Puse:
Código:
if (DistanciahastaDestinoX == 0) {
	BallXSpeed = 0;
	BallYSpeed = VelocidadAdelante*-1;
} else {
	AnguloPendiente = Math.atan(DistanciahastaDestinoY/DistanciahastaDestinoX);
	BallXSpeed = VelocidadAdelante*Math.cos(AnguloPendiente)*-1;
	BallYSpeed = VelocidadAdelante*Math.sin(AnguloPendiente)*-1;
}
Los *-1 los quito si veo que los tiros van para atrás o algo.

Los cambios en la pantalla por el movimiento los hago así:
Código:
Tiempotranscurridodeltiro = Tiempotranscurridodeltiro+1;
BallX = BallXwhenstriked+BallXSpeed*Tiempotranscurridodeltiro;
BallY = BallYwhenstriked+BallYSpeed*Tiempotranscurridodeltiro;
BallZ = BallZwhenstriked+VelocidadZ*Tiempotranscurridodeltiro-(Gravedad*Tiempotranscurridodeltiro*Tiempotranscurridodeltiro)/2;

Veo que habías dicho:
x = v0 * cos(θ) * t
y = v0 * sen(θ) * t - (g * t2)/2

Y más recientemente:
BallZ = h + VelocidadZ * t - (g * t * t)/2

Ahí me maree. BallZ lo tengo igual parece, lo otro no y como es la perspectiva 2d me confundo.

Bueno, pruebo el código, grabo video y demás y te muestro el resultado.
...
De momento me da errores gráficos no sé bien por qué (la pantalla se agranda o se achica, me ha pasado otras veces cuando se ordena modificar el tamaño de un objeto inexistente). He probado con distintas fuerzas y obtuve casos de fuerza insuficiente y de 2 ángulos pero que ninguno sirve. Agregué más estados de la variable TiroRealizable para ver eso. No sé, voy a probar quitar el código e irlo poniendo de a poco a ver cual es el problema. O pruebo desde la versión anterior mejor.
...
Ya arreglé el tema de los gráficos pero sólo obtengo casos de fuerza insuficiente si le pongo muy poca o casos de "2 ángulos pero ninguno sirve".
Por ejemplo:
Gravedad = 0.01
RedZ = 18.6
AlexFuerzadetiros = 2.975
AlexX = 488
AlexY = 548
DistanciahastaDestinoX = 240.9
DistanciahastaDestinoY = 368
DistanciahastaDestinoXY = 439.837253992883
Parte = 78.333562890625
Disc = 66.960524890625
DistanciahastaRed = 632.744136586501
theta = 1.31809820149062
TiempoHastaRedTheta = 850.689542137363
AlturaEnRedTheta = -1122.89688542468
phi = 0.150652307511496
TiempoHastaRedPhi = 215.123727738993
AlturaEnRedPhi = -90.2989548532666
TiroRealizable = "2 ángulos, pero ninguno sirve"
Angulo = "Ninguno"
BallXwhenstriked = 521
BallYwhenstriked = 548
BallZwhenstriked = 45.04

Medio supongo que tiene que ver con esas alturas negativas en la red, voy a revisar si hice algo mal ahí y si es el caso edito el post medio pronto, sino es que no sé.
393  Programación / Programación General / Re: ¿Qué tipo de diagrama os parece más útil en el diseño de software? en: 23 Mayo 2023, 15:36 pm
Sólo uso diagramas si me resulta muy complicado entender el código.

¿No depende del tipo de programa que uno haga o el lenguaje que se use?

Hay programas en que no hay realmente un flujo sino muchas posibilidades, o estados, entonces parece que conviene escribir los estados y si en ciertos casos pueden cambiar, o cuando y en qué sentido, o al menos en personajes de videojuegos lo veo un poco así.
Del estado Quieto puede pasar a Caminando (<- o ->), Saltando (A), Atacando (S), aGachándose (flecha abajo) o Lanzando (D).
Del estado C puede pasar a Q, S, A, G o L.
De S: Q, SA o SL.
De A: Q o AG.
De G: Q, AG o LG.
De L: Q o LG.

Un ejemplo nada más, y en realidad suele ser más complicado, por ejemplo porque una cosa es el estado saltando y otra cayendo.

¿Puedes ayudarme con esto
https://foro.elhacker.net/foro_libre/iquestcomo_hacer_un_diagrama_de_flujo_de_elegir_desafios_en_juegos-t517881.0.html
?
394  Foros Generales / Dudas Generales / Re: Hola, creéis en el Bitcoin y en la app Inmediate Edge y todo eso y en un Borker o brocker? en: 22 Mayo 2023, 21:43 pm
¿Por qué tu tío quiere que se lo rellenes? ¿es manco, ciego o en eso eres más hábil que él?
395  Foros Generales / Dudas Generales / Re: Me hackearon el facebook en: 20 Mayo 2023, 16:57 pm
Cita de: Fototeta en 20 Mayo 2023, 01:11 am
Alguien me ayuda a recuperar mi cuenta de facebook?,y que me enseñe a hackear o a inyectar archivos con virus que reseteen el cell
¿No quieres que te enseñen a ser millonario haciendo poco esfuerzo también? Puestos a pedir cosas que no tienen nada que ver una con la otra, digo, o sino quisiera que me expliques qué tiene que ver querer recuperar tu cuenta con lo otro que dijiste, porque si me roban y fuese a la policía pediría que me ayuden a recuperar lo que me robaron, no también que me enseñen a robar, en todo caso que me enseñen a que no me roben o a robarle al que me robó ¿pero tú conoces al que te hackeó? También entiendo que esto no es la policía, pero en fin, como que no le vi mucho sentido o conexión al 2ndo y 3er pedido, más bien parece "quiero aprender a hacer maldades pero no me van a enseñar si lo pido a menos que diga una buena excusa".

Disculpa si es indebido que no confíe en ti, pero tampoco he dicho que realmente quieras hacer maldades, sólo que me parece.
396  Foros Generales / Dudas Generales / ¿Es posible mezclar música, cómo? en: 20 Mayo 2023, 10:46 am
Mezclar deportes, juegos, historias, personajes, habilidades, cartas tipo Magic the Gathering y alguna que otra cosa, al menos en la imaginación o en texto o haciendo dibujos, no parece tan complicado, se me ocurren muchos modos de hacerlo ::) (en algunos casos no). Pero en cuanto a mezclar música no tengo idea :o No me refiero a letras, eso tampoco parece tan difícil (al menos el hecho de sustituir unas letras por las de otra música cambiando las palabras si es necesario pero conservando el mensaje si es que tiene, nunca escuché que hicieran eso, pero si pueden cambiar letras como aquí
https://www.youtube.com/watch?v=3Tb6kWYpT1Q
El original: https://www.youtube.com/watch?v=sfXPGuZ68HM
...entonces también parece posible hacer lo otro).

Por ejemplo, según mi "método", Tenis -> Fútbol sería llevar lo 1ero, al Tenis, a lo 2ndo, a una cancha de Fútbol (supongo que al revés es más comprensible: Tomando como base el Fútbol, se le intenta poner cosas de Tenis). Evidentemente no sería que los jugadores tengan raqueta y se use una pelota de tenis, sino se golpearían mucho (aún no entiendo cómo hacen en el Polo, pero ni quiero saberlo, malditos maltratadores de caballos >:( ), salvo que cada jugador no pueda salir de cierta área, separada con tejidos:

...suficientemente altos como para que los jugadores no puedan golpearse, y con agujeros suficientemente pequeños para que la bola no pueda quedar "enterrada" en uno, y entonces los jugadores se pasarían la bola, los rivales intentarían bloquearla (se establecería un máximo de altura de los pases, para que no sean todos globitos muy altos inbloqueables), y habría una zona fuera del área del golero, que no tendría tejido hacia él (pero sí una red que no podrían pasar), desde la cual los rivales podrían lanzar la bola hacia el arco, intentando hacer goles así (el arco quizá deba cambiar de tamaño, y si el golero debería poder usar raqueta no sé). Si la bola bota 2 veces antes de que un jugador la golpee es gol del equipo contrario. Las áreas había pensado que sean como cuadros de Ajedrez (excepto la o las que estén pegadas al área del golero), pero podrían ser similares a las pelotas de Fútbol:

Las áreas negras serían ocupadas por rivales, las otras por defensas, pero también tendrían separaciones (pero cada área de esas implicaría varios pentágonos, o podrían ser hexágonos si queda mejor). Otra alternativa es que sólo los goleros estén en el área propia, en cuyo caso debería poder usar raqueta supongo.

Fútbol -> Tenis sería al revés y ya se ha hecho, o al menos no se me ocurre otro modo (iba a poner un video pero según he visto no es como me parece que deberían, lo que hacen parece más Voleyball o Padel, en el Tenis no pasas la bola a tu compañero ni hay paredes alrededor).

Fútbol + Tenis sería intentar poner todo en un mismo sitio, no sé bien aplicar este "método", sería poner una cancha de tenis pegada a una de fútbol, lateralmente o detrás, y puede ser más de una de tamaño reducido, y entonces... dije que no sé, pero a ver...
Modo A: Una cancha de Tenis está detrás de un arco (que está en una cancha de Fútbol), separada por un tejido o no importa bien qué, y cuando se le hace un punto al que esté cerca del arco, se lanzaría una pelota de Fútbol a la cancha de eso, es decir, el tenista que juegue cerca del arco sería como un jugador extra de ese equipo, y el otro sería del contrario. No habría cambios de lado en canchas de Tenis. Al 2ndo tiempo, en Tenis jugarían jugadores distintos (o pueden ser los mismos si les parece), esta vez el del equipo que defendía atacaría y viceversa. Esto se podría hacer atrás de cada lado, pero en tal caso es como si se estuviera usando la cancha de Fútbol como base o inicio. Si en Fútbol hay más de 1 bola en juego, no se detendría cuando haya un gol o cuando una bola salga del campo.
Modo B- Más o menos lo inverso que admite 2 variaciones también. Aquí, cuando se hace un gol, un jugador extra entraría al equipo correspondiente de Tenis.
Modo C- Más o menos lo inverso que lo anterior, también. Cada vez que un tenista haga un punto, de su equipo rival de Fútbol deberá salir 1 jugador. La victoria la marcan los jugadores de Fútbol, pero si un tenista hace 11 puntos seguidos al otro, gana su equipo porque sus rivales no tendrían golero siquiera.
Metiendo canchas en medio de la otra no se me ocurre qué se pueda hacer y metiéndolas lateralmente tampoco...

(Fútbol + Tenis)/2 sería hacer un promedio y modificaciones que se consideren necesarias, tampoco sé mucho sobre eso (la pelota quedaría en un tamaño intermedio, pero lo demás es complicado).

En fin, esos fueron sólo ejemplos, no digo que sean los mejores.

Entonces, supongamos que quisieras mezclas esta música:
https://www.youtube.com/watch?v=ViXlIfhrvFY
0:07
con esta
https://www.youtube.com/watch?v=evRsyIBGaco
0:20
¿Cómo sería más o menos tu método? Si es que es posible.

Gracias.
397  Foros Generales / Dudas Generales / ¿Por qué las máquinas casi nunca fallan? en: 17 Mayo 2023, 01:20 am
Me refiero a que uno puede pasar un archivo a otra carpeta y, que yo sepa, nunca se deforma, por ejemplo en una imagen no se cambian de color los píxeles.

Si se lo pasa a un DVD, etc, en general tampoco hay deformaciones.

Las radios, TVs y celulares también, por arte de magia parece, caprtan o envían datos casi sin que se deformen.

¿Cómo es posible, por qué ocurre así?  :huh:
398  Foros Generales / Foro Libre / Sobre hacer un minirío casi perpetuo. en: 16 Mayo 2023, 23:24 pm
Imaginen que esto:

- No tiene tanta bajada.
- Forma un circulo, hay un escalón en la parte en que se conecta la parte más alta con la más baja.
- En los costados de la pista hay paredes, el agua no cae hacia los costados.
- Podría ser que la pista, en lugar de tener suelo recto, lo tenga ahuecado, cilíndrico, como un caño.

Si ponemos agua en la parte de más arriba, que está en bajada, irá recorriendo la pista hasta terminar en el escalón.

Lo que debemos hacer es subirla de nuevo a la parte de arriba.

¿Cómo se hace eso?

Doy algunas ideas:
- Usar la poca, pero fuerza al fin, fuerza del minirío.
- Usar el calor del Sol o lo que se pueda de sus rayos.
- Usar la fuerza del viento.
- Usar un pájaro bebedor o varios (si le ponen un imán o algo se podría generar otro movimiento o electricidad de alguna manera ¿o no? También genera algo de viento al subir y bajar ¿no?).
Si se pudieran usar todas esas fuerzas para el mismo objetivo, entonces se podría lograr un movimiento prácticamente perpetuo, aunque habría que reponer agua a medida que se evapore. Yo lo quiero como adorno y para pájaros, pero se podría usar un líquido que no se evapore normalmente, o en vez de ser una pista al aire libre podría ser un caño.

Denme conocimiento:
¿Cómo usar la fuerza del minirío para subir agua de nuevo al escalón?
¿Y del calor o rayos del Sol?
¿Y del viento?
¿Y del pájaro bebedor?

Gracias.
399  Programación / Scripting / Re: Ideas scripts en: 15 Mayo 2023, 09:21 am
El juego que dices no sé si tiene un nombre específico pero en NES hay uno llamado Arcanoid que es como dices. También en SNES creo, y probablemente otras consolas.
Yo hice uno más básico (no hay cajas) en el que no calculaba cosas, te lo pasaría pero no sé dónde lo tengo. Se llamaba Raqueta Troll, cuando la bola rebotaba agarraba velocidades al azar hacia arriba y costados, y podía ser que cayera muy rápido o muy lento. Entre más veces rebotaras la bola, más altas podían ser las velocidades. Cuando tocaba una pared, la velocidad de caída se invertía (o algo así, ya no recuerdo bien eso).

En cuanto a cosas que puedes hacer, es algo que pensé varias veces (qué posibles caminos o desafíos se pueden cumplir, aunque lo mío era sobre programas que resuelvan dudas), pero no lo tengo claro.
Te dejo esto que te puede servir pero no está masticado:
Citar
Ayuda para percibir de a una las posibles "formas" de los desafíos.


"formas":
O estructuras, me refiero a que no todo importa, por ejemplo en el ajedrez es irrelavante si hay fichas blancas y negras o blancas y marrones, a menos que haya poca luz pero ya no sería simple ajedrez, en fin...

Desafío:
Al menos 1 variable y al menos 1 desafiante que mediante realizar al menos 1 acción intenta cumplir al menos 1 condición.

Variable:
Valor que puede cambiar.

Valor:
Número o letra o color, etc, que representa algo o que es parte de algo.

No es la idea decir en esas descripciones todo lo que un desafío puede tener, sólo lo esencial.


La forma de desafío virtual más simple:

V1- Crear o modificar una variable.
V1 es un nombre que servirá más adelante; V significa virtual.
Es algo como "Mueve el mouse, luego ganas" o "Habla, luego ganas"; el desafío exige realizar una acción simple que el programa pueda captar y se gana simplemente por realizarla.
No sé si eso implica crear o modificar una variable, pero es causar un cambio en la situación y si hay un cambio en ella debe de crearse o modificarse una variable me parece.
Lo que puede entenderse como:
Código:
Repetir
   Si se mueve el mouse
      Desafío cumplido
      Break
siempre
Fin
Me parece demasiado simplificado. En realidad cuando el mouse se mueve eso implica que el puntero cambió la posición X y/o Y en que se encontraba, son 2 variables, pero yo lo vería así:
Código:
SeMovio = "No"
Repetir
   Si se mueve el mouse
      SeMovio = "Sí"
mientras SeMovio == "No"
Desafío cumplido
Fin
Considero que ahí hay 2 valores: La variable y la constante que se usa en la condición. Todo eso es debatible, pero bue.
También creo que podría ser algo así:
Repetir
   Si se mueve el mouse
      SeMovio = "Sí"
mientras SeMovio != Inexsistente
Desafío cumplido
Fin

Obviamente puede que me equivoque, quizá haya otro más simple u otros de su mismo nivel, opinen.

¿Por qué digo que es la forma más simple?
- La cantidad de colaboradores, aliados, etc, es 0, la mínima posible.
- La cantidad de información que se requiere dar es muy poca.
- La cantidad de opciones es 0, la mínima posible.
- La cantidad de acciones que sólo se pueden realizar en ciertas condiciones es 0, la mínima posible.
- La cantidad de efectos (cosas que ocurren involuntariamente, más allá de ganar o perder, etc) es 0, la mínima posible.
- Sólo tiene 2 valores, la mínima cantidad que pude lograr.
- Sólo tiene 1 variable, la mínima cantidad posible.
- La variable está definida del modo más simple posible, no es random ni cargada, etc.
- La variable sólo tiene 2 posibles valores, la mínima cantidad posible (del modo 2 sólo tiene 1 posible valor, sería una constante).
- Sólo tiene 1 posible resultado, la mínima cantidad posible.
- La condición es la más simple posible, creo: 1 variable, un símbolo comparador y 1 constante.
La idea es ver cual es el desafío más simple y cómo se puede ir complicando.
https://i.ibb.co/xDPZJk2/Desaf-os.png
Eso es de Excel, demasiado largo como para ponerlo en modo imagen. En cada columna hay una posible complicación, pero no todas son aplicables siempre. El Sol significa que el desafío deja de ser virtual, cuando por ejemplo dos personas deben mover el mismo mouse. La idea es que tomes las modificaciones que hayas podido hacer en cada columna, las pegues cada una en una distinta fila, y repetir el proceso, es un método para percibir posibles variaciones, en este caso variaciones de desafíos.

Recientemente escribí esto que también te puede servir:
Citar
¿Cual es la duda más sencilla de resolver? Podría ser, dado un número, cual es ese número. Esto equivale a adivinar el número, o a colocar una ficha encima de cierto casillero especial, etc, el programa simplemente prueba un número, si falla prueba otro y así sucesivamente hasta cumplir la condición que le hayamos puesto (que el número dado sea igual al número elegido por el programa). ¿Muy fácil no? ¿cómo podemos complicar esa duda, poco a poco, para ir practicando y entendiendo cómo resolver una duda tan compleja como la planteada en el título de este tema?
- Que la cosa a adivinar pueda tener texto (para una persona es casi lo mismo pero programarlo es considerablemente más difícil).
- Aumentando el nro de variables a adivinar (parecido al juego de batalla naval).
- Que, sobretodo, deba evitarse elegir ciertos números (yo esto lo había pensado medio basado en el Pacman: El objetivo es comer fantasmas débiles, pero sobretodo evadir a los fuertes; si el fuerte está en el mismo casillero que el débil se debe evitar a ambos).
- Limitando las posibles acciones (la idea de esto es transformar la duda de cómo adivinar en una duda de cómo llegar a cierta cantidad, ya no se puede elegir el númerio 10 o 9, etc, sino sólo +1 o +2, es como tener que llegar a un sitio, con qué acciones se llega más rápido; para nosotros la respuesta es obvia pero programarlo no es tan fácil como lo anterior).

No se me ocurren más, a partir de las nuevas sí. Probablemente eso te parezca inútil o que no tiene relación con el tema, pero es parecido a IA, en teoría si se avanza sirve para resolver dudas, aprenden a lograr cosas, así como han aprendido a jugar al ajedrez mejor que nosotros.
400  Programación / Programación General / Re: Ayuda con cálculos para que la trayectoria de una pelota cumpla ciertas condiciones. en: 15 Mayo 2023, 08:04 am
Miro el foro todos los días o casi, no entiendo cómo no vi tu mensaje antes :rolleyes:

Cita de: RayR en 11 Mayo 2023, 03:29 am
Cuando el lanzamiento es muy bajo, hay mayor velocidad hacia adelante (horizontal), y se avanza más rápido, pero como la pelota está cerca del suelo, también cae rápido, así que no tiene tiempo de viajar mucho. Si el tiro es elevado, avanza hacia adelante más lentamente, pero tarda más en caer, lo que le da más tiempo para avanzar. Por lo tanto, si se quisiera que la pelota llegara lo más lejos posible, no debería ir ni muy elevada ni muy baja.
Pienso lo mismo pero en mis ejemplos no parece ocurrir. ¿No?

Citar
si lo que se busca es recorrer una distancia específica, este es el ángulo que te permite lograrlo usando menos fuerza
Debes que imaginar que el jugador es perfecto en cuanto a inteligencia y puntería y quiere que la bola caiga en cierto punto, para lo cual usará toda la fuerza que pueda (según la que tenga, en ese sentido no es perfecto), no la mínima necesaria; no hará globitos si puede hacer que el tiro sea rápido y pase cerca de la red. No sé si has entendido eso. Si tiene la fuerza suficiente, el tiro debería pasar cerca de la red, sino sí haría un globito por lo que has explicado arriba, porque si golpea muy hacia abajo no llega. Mira el video
https://drive.google.com/file/d/1jyrIyycu_joxlfIblj5IDEwZ_Y3giSPR/view
Entre más fuerza tenga más bajo pasa la bola, excepto cuando ni siquiera tiene suficiente fuerza como para hacerla pasar. O piensa que, si hará un smash, apuntará a un punto usando toda la fuerza que pueda , no la mínima necesaria.
https://www.youtube.com/watch?v=BLaHot9vIKo
2:44, pudo haber golpeado más suave ¡pero no es la idea!

...

¡Vaya ecuaciones! :o :rolleyes:

Me quedó así:
Código
  1. // Datos para determinar velocidades del tiro.
  2. DistanciahastaDestinoX = BallX-280.1;
  3. DistanciahastaDestinoY = BallY-180;
  4. DistanciahastaDestinoXY = Math.sqrt(DistanciahastaDestinoX*DistanciahastaDestinoX+DistanciahastaDestinoY*DistanciahastaDestinoY);
  5. // Se calcula el ángulo o ángulos.
  6. Parte = AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros*AlexFuerzadetiros;
  7. Disc = Parte-(Gravedad*(Gravedad*DistanciahastaDestinoXY*DistanciahastaDestinoXY-2*AlexFuerzadetiros*AlexFuerzadetiros*BallZ));
  8. // Si Disc < 0, no puedes hacer el tiro.
  9. // Si Disc == 0, hay un solo angulo posible.
  10. // Si Disc > 0, hay dos angulos.
  11. theta = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros+Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
  12. phi = Math.atan((AlexFuerzadetiros*AlexFuerzadetiros-Math.sqrt(Disc))/(Gravedad*DistanciahastaDestinoXY));
  13. // Se calcula el tiempo que se tarda en llegar a la red.
  14. DistanciahastaRed = DistanciahastaDestinoXY*Math.abs(RedZ-BallZ)/Math.abs(DistanciahastaDestinoY);
  15. TiempoHastaRedTheta = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(theta));
  16. if (Disc>0) {
  17.     // Si hay dos ángulos, se calcula el 2ndo.
  18.     TiempoHastaRedPhi = (DistanciahastaRed)/(AlexFuerzadetiros*Math.cos(phi));
  19.     // Se calcula la altura a la que pasa la bola al llegar a la red.
  20.     AlturaEnRedTheta = BallZ+AlexFuerzadetiros*Math.sin(theta)*TiempoHastaRedTheta-(Gravedad*TiempoHastaRedTheta*TiempoHastaRedTheta)/2;
  21.     AlturaEnRedPhi = BallZ+AlexFuerzadetiros*Math.sin(phi)*TiempoHastaRedPhi-(Gravedad*TiempoHastaRedPhi*TiempoHastaRedPhi)/2;
  22.     // Se elige el ángulo conque la bola pasa más bajo.
  23.     if (AlturaEnRedTheta<AlturaEnRedPhi) {
  24.         Angulo = AlturaEnRedTheta;
  25.     } else {
  26.         Angulo = AlturaEnRedPhi;
  27.     }
  28. } else {
  29.     Angulo = AlturaEnRedTheta;
  30. }
  31. // Cálculo de las velocidades.
  32. VelocidadAdelante = AlexFuerzadetiros*Math.cos(Angulo);
  33. VelocidadArriba = AlexFuerzadetiros*Math.sin(Angulo);
  34. // Esta variable es redundante, pero clarifica lo que se esta haciendo.
  35. VelocidadZ = VelocidadArriba;
  36. if (DistanciahastaDestinoX == 0) {
  37.     BallXSpeed = 0;
  38.     BallYSpeed = VelocidadAdelante*-1;
  39. } else {
  40.     AnguloPendiente = Math.atan(DistanciahastaDestinoY/DistanciahastaDestinoX);
  41.     BallXSpeed = VelocidadAdelante*Math.cos(AnguloPendiente)*-1;
  42.     BallYSpeed = VelocidadAdelante*Math.sin(AnguloPendiente)*-1;
  43. }
  44. // Datos para determinar posiciones de la pelota.
  45. Tiempotranscurridodeltiro = 0;
  46. BallXwhenstriked = BallX;
  47. BallYwhenstriked = BallY;
  48. BallZwhenstriked = BallZ;

El cálculo de las posiciones lo estoy haciendo en base al tiempo, así:
Código
  1. function Ballmoving () {
  2.     Tiempotranscurridodeltiro = Tiempotranscurridodeltiro+1;
  3.     BallX = BallXwhenstriked+BallXSpeed*Tiempotranscurridodeltiro;
  4.     BallY = BallYwhenstriked+BallYSpeed*Tiempotranscurridodeltiro;
  5.     BallZAnterior = BallZ;
  6.     BallZ = BallZwhenstriked+VelocidadZ*Tiempotranscurridodeltiro-(Gravedad*Tiempotranscurridodeltiro*Tiempotranscurridodeltiro)/2;
  7.     BallZSpeed = BallZ-BallZAnterior;
  8.     if (BallZ<=0) {
  9.         // Si la pelota llega al suelo, BallZSpeed se invierte con disminución según la cancha.
  10.         BallZ = 0;
  11.         BallZSpeed = BallZSpeed*Fuerzaderebotedepelota;
  12.         // Si BallZSpeed es menor que 0.01: Queda en 0.
  13.         if (BallZSpeed<0.01) {
  14.             BallZSpeed = 0;
  15.         }
  16.         // La pelots, al rozarse con el suelo, disminuye sus velocidades.
  17.         // BallXSpeed = BallXSpeed+Influenciadelrozamiento;
  18.         if (BallXSpeed>0) {
  19.             BallXSpeed = 0;
  20.         }
  21.         // BallYSpeed = BallYSpeed+Influenciadelrozamiento;
  22.         if (BallYSpeed>0) {
  23.             BallYSpeed = 0;
  24.         }
  25.     }
  26. }

No sé qué está mal.
https://drive.google.com/file/d/1vDabAavB-YZrNTW1s6YW7o7y-kSBzyj_/view?usp=share_link
¿Te digo algún dato que no haya dicho ahí, cual?

Ah, el tema del pique se me complica, mejor luego del pique vuelvo al método simple de sumar ¿no? Aunque la pelota bajará a distinta velocidad. Yo lo que hacía es que cuando tocaba el suelo la bola, a su velocidad Z se le hacía *-1 y se reducía un poco, pero ahora de momento no sé cómo hacerlo.
La bola que queda en la red o en pantalla no es un error, hago que aparezca para ver qué tan cerca de la red pasó.
Páginas: 1 ... 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 [40] 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 ... 192
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines