Aprendiendo a programar Videjuegos en Basic

Más
7 meses 2 semanas antes - 7 meses 1 semana antes #6720 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Echemos un vistazo a las variables y expliquemos las más importantes:
COLOR = 1
Vidas = 3
DIM Puntos as UInteger
PosicionVausX = 50
PosicionVausY = 10
PelotaLibre = 0
Nivel = 1
NLadrillos = NLadrillosX * NLadrillosY

PosicionPelotaX = PosicionVausX + AnchoVaus / 2
PosicionPelotaY = PosicionVausY+2*RadioPelota+2
VelocidadPelotaX = 1
VelocidadPelotaY = 1
	
DIM Ladrillos(NLadrillosX, NLadrillosY) as BYTE

Como veis es fácil, se definen por defecto, es decir sin especificar el tipo, las variables que nos hacen falta. Veis la definición del color que vamos a usar para el juego (lo siento, solo uso un color, más adelante usamos más), el numero de vidas (3), la posición inicial de la paleta (Vaus) en horizontal (50) y en vertical (10).

Ponemos una variable llamada PelotaLibre a FALSO, el nivel en el que estamos (empezamos por 1), el número de ladrillos que va a haber (es una matriz cuadrada de NLadrillosX * NLadrillosY, es decir de 10*6).

Lo de PelotaLibre = 0 merece una pequeña explicación. En los lenguajes mayores como C o Pascal se define el TRUE y el FALSE como TRUE = 1 (o cualquier valor positivo) y FALSE = 0 pero los lenguajes tienen esas palabras y puedo hacer PelotaLibre = False, pero para simplificar y como Basic no tiene porqué tenerlos definidos usaremos 1 y 0.

También podíamos haber definido esto y el código habría quedado más claro:

#define True 1
#define False 0

Lo de PelotaLibre significa que se mueve sola (libremente) si es True o 1, si por el contrario es 0 (o False) está pegada a la raqueta (a Vaus) hasta que el usuario le dé a la tecla correspondiente y la libere, así que la siguiente variable, la de la posición de la Pelota verás que está ligada a la posición de Vaus (la raqueta)
PosicionPelotaX = PosicionVausX + AnchoVaus / 2
PosicionPelotaY = PosicionVausY+2*RadioPelota+2

A continuación definimos la velocidad de la pelota en los ejes X e Y.

He dejado para el final la variable donde se almacenan los puntos y el muro porque son variables especiales.

Como sabéis el Z80, el microprocesador del Spectrum, es de 8 bits lo que implica que las operaciones que puede llevar a cabo son de 8 bits como máximo, es decir de una sola vez puedo sumar 16 + 85 pero no 400 + 800 porque el valoe máximo que cabe en 8 bits es 256, es decir con 8 bits puedo representar desde 00000000 hasta 11111111 que es desde 0 hasta 255 (2^8 valores diferentes).

Por supuesto que el Spectrum puede sumar 400 + 800 pero no puede hacerlo "de golpe" debe hacerlo de varias veces y eso hace que sea más lento, por lo tanto las variables por defecto se les asigna un tipo Byte (8 bits, un valor máximo de 255) para no ralentizar las operaciones. Si queremos especificar que el número va a ser mayor (o va a tener decimales, por ejemplo) hay que definir de qué tipo va a ser. En este caso:

DIM Puntos as UInteger

Es decir va a definir a la variable Puntos como un entero (que si Boriel no me corrige debe estar entorno a los 16 bits), con 16 bits (2^16) ya puedo representar desde el valor 0 hasta el valor 65.535, de momento de sobra para la puntuación. Además la U que precede a Integer significa que es UNSIGNED o sin signo por lo tanto podemos representar este rango de 0 a 65.535

Si hubiera puesto

DIM Puntos as Integer

Sin la U significaría que es un entero con signo con lo que los posibles valores serían desde -32.768 hasta 32.767

Y ya por último la representación de muro:

DIM Ladrillos(NLadrillosX, NLadrillosY) as BYTE

Lo que hace esta línea es declarar una Matriz cuadrada (bueno rectangular de 10 * 6 elementos) que va a ser la representación del muro. Podemos hacer por ejemplo Ladrillos(1, 6) = 1, esto para nosotros representaría que la en la columna 1 de la fila 6 hay un ladrillo y poniendo Ladrillos(1, 7) = 0 significaría que en esa posición NO hay ladrillo (porque puse un cero).

Podemos jugar con 0 y 1 con hay o no hay ladrillo o directamente podemos poner un valor más alto, por ejemplo del 1 al 6 que sería el color del ladrillo (y si es cero, no hay ladrillo) o bien definir un valor que represente el número de golpes que necesitas para destruirlo, se puede jugar mucho con esta estructura.

Gracias, un saludo.
Última Edición: 7 meses 1 semana antes por pooky2.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Más
7 meses 2 semanas antes #6721 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Por cierto el juego lo he llamado Vaus así que el archivo que lo contiene lo he reado como Vaus.bas, podeis ir compilandolo (si hicisteis el cc.bat sería cc vaus.bas) y coger el vaus.tap y cargarlo en el FUSE o en cualquier otro compilador.

Veamos de nuevo el trozo de código principal:
REM -----------------------------------
REM Inicio del programa Principal
REM -----------------------------------

while inkey$ <> "0"
	
	NuevaPartida()

	while Vidas > 0
		
		ComprobarMuro()
		MoverPelota()
		MoverVaus()
		
		if PelotaPerdida() = 1 then
			VidaMenos()
			Reiniciar()
		end if
		
		if NLadrillos = 0 then
			SiguienteNivel()
		end if
	
	end while	

end while

Veis que la primera llamada es la subrutina NuevaPartida (se la llama incluyendo paréntesis anque no le pases ningun dato) así:
NuevaPartida()

Vamos a ver qué contiene NuevaPartida():
sub NuevaPartida()
	
	ink COLOR

	Vidas = 3
	Puntos = 0
	InicializarLadrillos()
	Reiniciar()

end sub

Veis que es relativamente sencillo, se inicializa el color con que el vamos a pintar (para simplificar el juego es monocromo, pero ya vendrá el color, no os preocupéis) con ink COLOR que pone el color de la tinta a lo que marque COLOR (que creo que vale 1, o sea azul), define que tenemos tres vidas, cero puntos, inicializa los ladrillos y manda a reiniciar el juego.

Veamos por tanto que contiene InicializarLadrillos()
sub InicializarLadrillos()
	
	NLadrillos = 0
	for x = 0 to NLadrillosX - 1
		for y = 0 to NLadrillosY - 1
			Ladrillos(x,y) = COLOR
			NLadrillos = NLadrillos + 1
		next y
	next x

end sub

Pone NLadrillos a cero, es decir no hay ladrillos y realiza un doble bucle FOR. El bucle FOR es superimportante y lo que hace es repetir un numero de veces un trozo de código. Pero claro, repetir una cosa exáctamente igual 5 veces puede no tener mucho sentido, pero eso cada vez que se repite hay un pequeño cambio, es decir hay un índice que cambia.

Si hacemos:
for Indice = 1 to 25
	print Indice
next Indice

Imprime 25 veces por pantalla, pero la primera vez imprime un 1 porque Indice vale 1, la segunda vez 2 porque Indice vale 2 y así hasta que Indice valga 25, o sea que este trozo de cogido imprime desde 1 hasta 25.

Hagamos algo parecido:
for Indice = 1 to 25
	print Indice *  2
next Indice

En este caso la primera vez imprimiría 2 porque es indice que vale 1 por 2 que es 2, la segunda vez 2 porque Indice vale 2 y por 2 es 4. así hasta 50, es decir imprime los 25 primeros números pares.

El doble bucle que estamos tratando de entender:
sub InicializarLadrillos()
	
	NLadrillos = 0
	for x = 0 to NLadrillosX - 1
		for y = 0 to NLadrillosY - 1
			Ladrillos(x,y) = COLOR
			NLadrillos = NLadrillos + 1
		next y
	next x

end sub

Lo que hace es recorrer desde 0 hasta 9 y desde 0 hasta 5 (porque NLadrillosX = 10 y NLadrillosY = 6) es decir rellenar toda la matriz de 10 * 6 o sea 60 elementos (ladrillos) poniendo como valor un 1 (bueno COLOR, pero COLOR = 1) de esa forma REPRESENTAMOS que hay un ladrillo en esa posición.

Además incrementamos la variable NLadrillos lo que nos sirve para luego descontar cada vez que quito un ladrillo y así "llevar la cuenta" y saber que puedo pasar de nivel cuando NLadrillos sea cero.

Y nos falta Reiniciar() pero eso lo explicaremos en el siguiente bloque.

Gracias, un saludo.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Más
7 meses 2 semanas antes #6722 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Veamos ahora Reiniciar() que trata de empezar una nueva fase.
sub Reiniciar()

	BorrarPantalla()
	CambiarBorde(BLANCO)
	
	PosicionVausX = 50
	PosicionVausY = 10
	PelotaLibre = 0

	PosicionPelotaX = PosicionVausX + AnchoVaus / 2
	PosicionPelotaY = PosicionVausY+2*RadioPelota+2
	VelocidadPelotaX = 1
	VelocidadPelotaY = 1
	
	EstablecerMarco()
	PintarMuro()

	PintarVaus()
	DibujarPelota(PosicionPelotaX, PosicionPelotaY)
	
	ImprimirPuntos()
	ImprimirVidas()

end sub

Como veis es sencillo, inicializa todas las variables de nuevo a sus valores de referencia, limpia la pantalla y pone los colores que se van a utilizar. Luego pone un marco en donde rebotará la pelota, pinta el muro (el conjunto de ladrillos), pinta la raqueta y la pelota en sus posiciones iniciales e imprime dos rotulos en la parte inferior de la pantalla, uno es el úmero de puntos que llevamos conseguidos y el otro es el numero de vidas que nos quedan.

Borrar pantalla es un alias de cls (Clear Screen) así que la rutina solo contiene esto:
sub BorrarPantalla()
	cls
end sub

Las dos que vienen a continuación son más interesantes, EstablecerMarco() y PintarMuro() y su código del primero es el siguiente:
sub EstablecerMarco()

	ink COLOR

	plot 0, 0
	draw 0, MaxY
	draw MaxX, 0
	draw 0, -MaxY
	
end sub

Lo que hace es pintar tres líneas, esto se hace con draw que determina el punto final de cada linea pero plot es el que define el punto inicial. En nuestra rutina nos situamos en 0, 0 es decir en la esquina inferior izquierda (con plot 0,0) y luego hacemos draw 0, MaxY con lo que trazamos una línea hasta 0, MaxY.
MaxY es el tamaño completo en pixels de la pantalla en vertical, por lo tanto se traza una línea vertical hasta el borde de arriba de la pantalla, ya tenemos el borde izquierdo de la pantalla teñido de azul.
Ahora como si de un lápiz se tratase, vamos a hacer otra línea con draw pero como no hemos hecho plot para cambiar el punto de partida, esta se traza desde la ultima posición es decir el punto final de nuestra línea anterior lo que en este caso es la esquina superior izquierda.
El draw se hace con MaxX, 0 es decir hasta el final de la pantalla en horizontal y sin moverse en la vertical, por lo que tenemos una linea recta que atraviesa la pantalla en la parte superior, es decir tenemos el borde superior de la pantalla en azul.
Y por último una línea vertical desde la parte superior de la pantalla hasta la parte inferior con draw 0, -MaxY o el borde izquierdo de la pantalla. Como habrás supuesto el signo menos significa ir de arriba a abajo o de derecha a izquierda en vez de lo normal que es de abajo a arriba y de izquierda a derecha.

Gracias, un saludo.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Más
7 meses 2 semanas antes #6723 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Vamos con algo que ya podemos probar:
sub PintarMuro()

	for x = 0 to NLadrillosX - 1
		for y = 0 to NLadrillosY - 1
			if Ladrillos(x, y) > 0 then
				PintarLadrillo(x, y)
			end if
		next  y
	next x

end sub

PintarMuro() es una simple rutina que ejecuta el doble bucle for (para llegar a cada uno de los elementos de una matriz de dos dimensiones, cada bucle recorre una dimensión) y que pregunta si Ladrillos(x,y) tiene un valor positivo.
Vamos a jugar con los valores y entenderemos que un valor positivo es que el ladrillo existe y uno negativo que ya lo hemos "tumbado" o simplemente que no hay.
Así que si Ladrillos(x,y) tiene un valor positivo, se llama a PintarLadrillo() y su código es un poco más complejo:
sub PintarLadrillo(x, y)

	TamX = 20
	TamY = 5
	
	LX = InicioMuroX + (AnchoLadrillo*x)
	LY = InicioMuroY + (AltoLadrillo*y)
	
	plot over 1; LX, LY
	draw over 1; TamX, 0
	draw over 1; 0, TamY
	draw over 1; -TamX, 0
	draw over 1; 0, -TamY
	
end sub

Si os fijáis lo único que se hace es calcular con una serie de operaciones "donde" debe estar cada ladrillo, es decir el Ladrillo(2, 3) debería estar Comenzar en el punto 55, 205.
Luego trazamos a partir de ahí un rectángulo de 20 pixels de ancho (LX) y 5 de alto (LY).
Si queris saber de donde saqué los valores 55, 205, recordad que las constantes que intervienen en los cálculos de LX y LY son:
#define AnchoLadrillo 25
#define AltoLadrillo 8
#define InicioMuroX 5  
#define InicioMuroY 130

Ya hora viene algo especial que requiere de una explicación exhaustiva, el atributo OVER 1.

Gracias, un saludo.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Más
7 meses 2 semanas antes - 7 meses 2 semanas antes #6724 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Atributo OVER 1
plot over 1; LX, LY
draw over 1; TamX, 0
draw over 1; 0, TamY
draw over 1; -TamX, 0
draw over 1; 0, -TamY

Si miráis este trozo de código os daréis cuenta de que ya conocéis el plot y el draw y que lo unico que hace es crear un rectángulo de 20 * 5 pixels a partir de la posición LX, LY (que tendrá un valor concreto dependiente de los parámetros x e y que le pasamos a la rutina.

Lo diferente es que tiene un OVER 1 detras del draw ¿que significa eso?

Estamos pintando en pantalla, pero si queremos simular movimiento debemos pintar los elementos, borrarlos y volverlos a pintar en su nueva posición.
Para borrar un elemento, podríamos borrar toda la pantalla y pintarlo de nuevo, sin embargo eso haría que la pantalla parpadeara porque tarda un tiempo (unas fracciones de segundo, que son perceptibles) y luego habría que redibujar todo.
Por eso se inventó un sistema que se llama Sprites que consisten en pintar el objeto que queremos mover pero antes COPIAR EL FONDO que tiene, entonces lo pintamos y antes de pintarlo de nuevo en su nueva posición PEGAR ESE FONDO que copiamos, de tal forma que es como si el objeto NUNCA hubiera estado ahí y luego lo pintas en su nueva ubicación.
Este sistema de Sprites suele venir implementado en las consolas de 8 a 32 bits pero no en el Spectrum.

¿Que hacemos entonces?, o programarlo o usar OVER 1.

OVER 1 lo que hace es pintar el objeto y si este objeto ya existía borrarlo, así que si imprimes dos veces el mismo objeto (la misma forma y el mismo color) lo que haces es BORRALO, lo cual nos viene genial, borramos el objeto, imprimiendolo de nuevo en el mismo sitio.

Para los que que quieran profundizar más solo decir que OVER 1 hace una [url=http://https://es.wikipedia.org/wiki/Disyunci%C3%B3n_exclusiva]O Exclusiva o XOR[/url] pero para el resto mejor que lo dejemos así.

Así que estoy pintando con OVER 1 porque la primera vez se pintará igual que sin el OVER 1, pero cuando quiera borrarlo, solo tengo que volver a llamar a PintarLarillo(x,y) en esas mismas coordenadas y se borrará.

Gracias, un saludo.
Última Edición: 7 meses 2 semanas antes por pooky2.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Más
7 meses 2 semanas antes - 7 meses 2 semanas antes #6725 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Ánimo que ya podemos ver algo:
#define NLadrillosX 10
#define NLadrillosY 6
#define BLANCO 7
#define MaxX 255
#define MaxY 191
#define AnchoLadrillo 25
#define AltoLadrillo 8
#define InicioMuroX 5  
#define InicioMuroY 130

COLOR = 1
NLadrillos = NLadrillosX * NLadrillosY
DIM Ladrillos(NLadrillosX, NLadrillosY) as BYTE

sub InicializarLadrillos()
	
	NLadrillos = 0
	for x = 0 to NLadrillosX - 1
		for y = 0 to NLadrillosY - 1
			Ladrillos(x,y) = COLOR
			NLadrillos = NLadrillos + 1
		next y
	next x

end sub

sub PintarLadrillo(x, y)

	TamX = 20
	TamY = 5
	
	LX = InicioMuroX + (AnchoLadrillo*x)
	LY = InicioMuroY + (AltoLadrillo*y)
	
	plot over 1; LX, LY
	draw over 1; TamX, 0
	draw over 1; 0, TamY
	draw over 1; -TamX, 0
	draw over 1; 0, -TamY
	
end sub

sub PintarMuro()

	for x = 0 to NLadrillosX - 1
		for y = 0 to NLadrillosY - 1
			if Ladrillos(x, y) > 0 then
				PintarLadrillo(x, y)
			end if
		next  y
	next x

end sub

sub BorrarPantalla()
	
	cls

end sub

sub EstablecerMarco()
	
	ink COLOR

	plot 0, 0
	draw 0, MaxY
	draw MaxX, 0
	draw 0, -MaxY
	
end sub

REM -----------------------------------
REM Inicio del programa Principal
REM -----------------------------------

BorrarPantalla()
EstablecerMarco()
InicializarLadrillos()
PintarMuro()

He recopilado lo necesario hasta lo que hemos visto en este código, simplemente copiadlo en un archivo llamado muro.bas y compiladlo (cc muro.bas) para obtened muro.tap que cargareis en el emulador.

Aquí tenéis el enlace al código en basic y el .TAP listo para ser cargado en un emulador o en el propio Spectrum.

Gracias, un saludo.
Última Edición: 7 meses 2 semanas antes por pooky2.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Más
7 meses 2 semanas antes #6726 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Bien, volvamos al código principal del juego:
REM -----------------------------------
REM Inicio del programa Principal
REM -----------------------------------

while inkey$ <> "0"
	
	NuevaPartida()

	while Vidas > 0
		
		ComprobarMuro()
		MoverPelota()
		MoverVaus()
		
		if PelotaPerdida() = 1 then
			VidaMenos()
			Reiniciar()
		end if
		
		if NLadrillos = 0 then
			SiguienteNivel()
		end if
	
	end while	

end while

Como vemos se trata de un doble while en el que se está jugando mientras no se pulse la tecla "0" y una partida dura mientras nos queden vidas.
Vamos a seguir con el flujo del programa y veamos ComprobarMuro() que es una rutina bastante completa.

Gracias, un saludo.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Más
7 meses 2 semanas antes - 7 meses 2 semanas antes #6727 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Esta rutina ComprobarMuro() comienza a se ya interesante. Lo que se hace es comprobar si la pelota ha golpeado algún ladrillo.
En caso afirmativo hacemos un efecto de color cambiando el color del borde de la pantalla de nuestro Spectrum, hacemos rebotar la pelota y por supuesto borramos el ladrillo y sumamos los puntos por haberle dado.
sub ComprobarMuro()

	for y = 0 to NLadrillosY -1 
		if PosicionPelotaY + RadioPelota > InicioMuroY+(y*AltoLadrillo) and PosicionPelotaY + RadioPelota < InicioMuroY+((y+1)*AltoLadrillo) then
			for x = 0 to NLadrillosX -1 
				if PosicionPelotaX + RadioPelota > InicioMuroX+(x*AnchoLadrillo) and PosicionPelotaX + RadioPelota < InicioMuroX+((x+1)*AnchoLadrillo) then
					if Ladrillos(x,y) > 0 then
						CambiarBorde(ColorAleatorio())
						RebotarPelota()
						BorrarLadrillo(x, y)
						SumarPuntos()
						return 
					end if
				end if
			next x
		end if
	next y
		
end sub

Es un código un poco complejo por lo engorrosopero lo que hace es tratar cada una de las filas de ladrillos que existen. Si la pelota está entre la primera y la ultima fila de ladrillos (for y = 0 to NLadrillosY -1)...
for y = 0 to NLadrillosY -1 
		if PosicionPelotaY + RadioPelota > InicioMuroY+(y*AltoLadrillo) and PosicionPelotaY + RadioPelota < InicioMuroY+((y+1)*AltoLadrillo) then

Lo que hacemos es preguntar que si la Pelota (la posición de la pelota está en su centro, si añadimos a la posición de la pelota su radio, tenemos el borde de la pelota que es con lo que tenemos que comparar, PosicionPelotaY + RadioPelota ).
Comparamos entonces si la pelota está entre dos ladrillos que estén uno encima del otro, es decir, si después de los cálculos (InicioMuroY+...), los ladrillos estubieran, por ejemplo, entre los pixels 130 y 150 yo preguntaría algo así como if PelotaPosY >=130 and PelotaPosY <=150.

Si esta circunstancia se dá, es decir que estoy entre las filas de los ladrillos, ahora tengo que verificar que le doy a un ladrillo de verdad, es decir no solo debo comprobar la posición en Vertical, también en Horizontal, para saber si la pelota está en la posición que ocupa uno de los ladrillos.

Para eso es este código, que se pone a continuación del anterior y que es muy simular:
for x = 0 to NLadrillosX -1 
	if PosicionPelotaX + RadioPelota > InicioMuroX+(x*AnchoLadrillo) and PosicionPelotaX + RadioPelota < InicioMuroX+((x+1)*AnchoLadrillo) then

Si estas condiciones se cumplen significa que estamos en la posición que ocupa el ladrillo x, y por lo que procedemos a borralo y a hacer que la pelota rebote.

Gracias, un saludo.
Última Edición: 7 meses 2 semanas antes por pooky2.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Más
7 meses 2 semanas antes - 7 meses 6 días antes #6728 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Vamos a ver entonces cómo Rebotamos la pelota, aunque antes veamos dos rutinas nuevas:

CambiarBorde(ColorAleatorio())

Esta rutina CambiarBorde() solo hace un BORDER (rutina que cambia el color del borde) con el valor que le pasemos por parámetro que será un número entre 1 y 6 pero aquí tenemos algo nuevo porque es la primera subrutina (o rutina) a la que pasamos un valor, simpre había sido LimpiarPantalla(), ComprobarMuro(), etc. Ahora le pasamos un valor entre los paréntesis, podríamos hacer algo como CambiarBorde(5), veremos que al definir la rutina se le pone un nombre ese parámetro (podemos poner todos los que queramos separados por comas) para poderlo usar, fíjate que se define como CambiarBorde(n) y dentro de pone border n.

Además tenemos a ColorAleatorio() una rutina que aunque no tiene parámetros si DEVUELVE un valor, es este caso ya no es solo un trozo de código ahora devuelve un valor y para ello utiliza una nueva palabra reservada (tiene un significado para el compilador y por ello no puede ser el nombre de una variable) denominada RETURN.
sub CambiarBorde(n)
	border n
end sub	

function ColorAleatorio()
	return RND * 6 + 1
end function

ColorAleatorio() devuelve un color entre 1, 6 porque RND devuelve un numero aleatorio que es un decimal entre 0 y 1, al multiplicarlo por 6 da un valor entre 0 y 5 y al sumarle uno, obtenemos un valor entre 1 y 6.

Gracias, un saludo.
Última Edición: 7 meses 6 días antes por pooky2.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Más
7 meses 2 semanas antes #6729 por pooky2
pooky2 respondió el tema: Aprendiendo a programar Videjuegos en Basic
Veamos ahora la rutina que falta, RebotarPelota() que tiene mucho que ver con MoverPelota(), la cual vamos a introducir ahora:
sub RebotarPelota()
	VelocidadPelotaY = -VelocidadPelotaY
end sub

Esto es un ejemplo de rutina elegante, hace que se rebote la pelota simplemente cambiando el sentido de la velocidad de la pelota.

Así que le deja todo el trabajo a MoverPelota, que lo único que hace es volver a dibujar la pelota en el último punto en el que estaba (al hacer eso se BORRA porque tenemos puesto un OVER 1 en DibujarPelota().+

A continuación comprueba si se choca contra alguna de las paredes (izquierda, derecha y superior) y si es así cambia el sentido de la velocidad.

La siguiente instrucción es simplemente sumar a la posición la velocidad (que puede ser positiva o negativa) en ambos ejes y volver a pintar la pelota.
sub	MoverPelota()
	if PelotaLibre = 1 then
	
		' Borramos la pelota anterior.
		DibujarPelota(PosicionPelotaX, PosicionPelotaY)
		
		if PosicionPelotaY + RadioPelota >= MaxY - 1 then
			VelocidadPelotaY = -VelocidadPelotaY
		end if
		
		if PosicionPelotaX + RadioPelota >= MaxX - 1 then
			VelocidadPelotaX = -VelocidadPelotaX
		end if
		
		if PosicionPelotaX - RadioPelota <= 1 then
			VelocidadPelotaX = -VelocidadPelotaX
		end if

		PosicionPelotaX = PosicionPelotaX + VelocidadPelotaX
		PosicionPelotaY = PosicionPelotaY + VelocidadPelotaY
		
		DibujarPelota(PosicionPelotaX, PosicionPelotaY)
	end if
end sub

Gracias, un saludo.

Por favor, Identificarse o Crear cuenta para unirse a la conversación.

Tiempo de carga de la página: 0.331 segundos

© Canarias Go Retro, 2016