Ingeniero Técnico en Informática de Sistemas
Ensamblador
Asignatura: Arquitectura de Computadores.
Curso: 1º Ingeniería Informática (97-98) .
Índice de -->contenidos[Author:Edu].
-
Breve descripción de las macros y funciones empleadas. pag. 3-6
Detalles de implementación. pag.
-
Descripciones en alto nivel:
-
Programa principal. pag. 7
-
Rutina de servicio a la interrupción de reloj. pag. 8
-
Rutina de servicio a la interrupción de teclado. pag. 9
-
Listado en ensamblador del programa.
-
Macros. pag. 10-12
-
Variables y EQU's. pag. 13-16
-
Programa principal. pag. 17-18
-
Funciones/Procedimientos. pag. 19-62
-
Índice alfabético. pag. 63
Breve descripción de las macros y funciones empleadas.
Macros:
-
Borracaza:
Borra el caza , estando el origen del caza en es:di , luego di deberá tener el valor adecuado antes de realizarse la llamada a la macro.
-
Dibujacaza:
Dibuja un caza , estando el origen del caza en la posición del buffer de video es:di , luego di deberá tener el valor adecuado antes de realizarse la llamada a la macro.
-
Un_Strobe:
Realiza el strobe necesario tras leer un dato del registro de datos del controlador de teclado.
-
Inhibe_tec:
Inhibir en el 8259 la interrupción de teclado.
-
Desinhibe_tec:
Desinhibir en el 8259 la interrupción de teclado.
-
Ini_pres:
Prepara la llamada (bloque de activación a la función presenta).
-
Ini_wtoa:
Prepara la llamada (bloque de activación a la función wtoa).
Funciones /procedimientos:
-
Ini_VI:
Salva las direcciones del VI que se van a modificar e inicializa las posiciones correspondientes del VI con las direcciones de las rutinas de servicio programadas.
-
Res_VI:
Restaura las direcciones de las rutinas de servicio originales en el VI.
-
Presenta:
Presentar una cadena ascii en pantalla en la posición que se le indica , además se le pasa un parámetro adicional para indicar el color en que se debe visualizar la cadena.
Los parámetros color,fila,columna se pasan a través de la pila , mientras que la dirección de la cadena de pasa mediante registro: es:di.
La llamada a la función se realiza mediante la macro ini_pres.
-
Wtoa:
Convierte un número entero positivo en C2 de 16 bits a sus dígitos en código ascii , escribiéndolo además en pantalla en la posición que se le indica .
La llamada (long,color,numero,fila,columna ) se realiza a través de la macro ini_wtoa.
En long se indica el número de dígitos que se quieren utilizar para visualizar el número , si el número de dígitos deseados es superior al del número convertido , entonces se completa con ceros a la izquierda.
-
Redidisp:
Recorre las posiciones de memoria del buffer de video(recorrido creciente) , reconociendo los caracteres de disparo y tratándolos con el procedimiento correspondiente según el sentido de cada disparo.
Los disparos de bajada primero son situados en una fila más abajo en un color distinto (col_bajar) para ser posteriormente redibujados, ya que sino serían bajados hasta el límite inferior de la pantalla en una sola pasada.
-
P_dis_izq:
Tratar los disparos a izquierda , analizando las diferentes posibilidades que pueden surgir al redibujar el disparo en su nueva posición.
-
P_dis_der , P_dis_sub , P_dis_baj :
Análogos a P_dis_izq ,pero tratando respectivamente los disparos de derecha, subida y bajada respectivamente.
-
Redicaza:
Recorre las posiciones de memoria del buffer de video (recorrido creciente) , buscando los cazas y tratando para cada uno si le toca disparar , este caso es tratado por los procedimientos misma_fila o misma columna según proceda ; o en caso contrario estudiar su movimiento , lo cual lo realizan los procedimientos mov_caza_hor o mov_caza_ver según el valor de la variable sentido_caza.
Se han tomado las siguientes decisiones:
-
Si colisionan con el marco los cazas se detienen.
-
Si colisionan con la estrella mueren y se genera un nuevo caza
-
Si colisiona un caza con el rubbiatrón se gana la partida.
-
Si colisiona un caza con el héroe se pierde la partida.
-
Si colisionan dos cazas , mueren ambos y se generan dos nuevos cazas.
Nota: los cazas se referencian siempre desde su extremo izquierda.
-
Redihalcon:
Actualiza las coordenadas del halcón en función del sentido de las variables sxh y syh. (las cuales son modificadas por la rutina de teclado).
Posteriormente redibuja el halcón en la posición indicada por las variables yh,xh.
Notas:
- El halcón se referencia desde su extremo izdo.
- Movimientos del halcón en función de las varibles syh , sxh :
| syh | sxh | Movimiento |
| -1 | 0 | Abajo |
| 1 | 0 | Arriba |
| 0 | -1 | Izquierda |
| 0 | 1 | Derecha |
| -2 | -2 | Stop |
| 2 | 2 | Hiperespacio |
- El halcón al inicio de la partida y siempre que vuelve del hiperespacio aparece parado ( Stop)
-
Calculo_posicion:
Da como resultado en el registro DI el desplazamiento en el buffer del video correspondiente a la posición que se le pasa a la función mediante los parámetros fil y col por medio de la pila.
-
Calculo_coordenadas:
Proceso inverso a calculo_posicion , ya que la función devuelve en los registros AX y BX la fila y la columna , respectivamente, correspondiente a la posición del buffer de video ,que se pasa por medio del registro DI ,como parámetro de entrada.
-
Ini_pant:
Dibuja la pantalla inicial: marco , rótulos de reloj y marcador , fondo.
Además se dibujan la estrella y el halcón en las posiciones (ys_ini,xs_ini) y (yh_ini,xh_ini) respectivamente , luego ambos elementos aparecen en posiciones fijas al iniciar una partida.
También se dibujan aleatoriamente los cazas (el número de cazas iniciales es :la_dif (inicial) +2) , por medio del procedimiento nuevo_caza.
-
Redefinir:
Permite configurar las teclas de juego, las cuales son por defecto:
Q: up ; A:down; O:left; P:right ; Espacio: stop ; H: hiperespacio y Control: disparo.
-
Encuesta:
Devuelve en el registro AL el dato que se obtiene al acceder una vez al registro de datos del controlador de teclado.
-
Menu:
Visualiza en pantalla las opciones del menu.
-
Dificultad:
Procedimiento que realiza un encuesta continuada hasta que se introduce un nivel de dificultad comprendido entre 1 y 3.
-
Reiniciar:
Actualiza las variables necesarias antes de comenzar cada partida.
-
Act_marc
Actualiza marcador en pantalla.
Recibe un parámetro por medio de la pila para indicar la cifra en que se tiene que incrementar el marcador.
-
Act_reloj:
Actualiza en pantalla el tiempo de juego en función de las variables minutos y segundos.
-
Ini_marc:
Marcador a cero.
-
Borra_star:
Borra la estrella , cuyo desplazamiento en el buffer de video se pasa en el registro DI .
Nota: La estrella se referencia desde el extremo superior izquierdo.
-
Dibuja-star.
Dibuja la estrella , con un desplazamiento en el buffer de video que se pasa en el registro DI .
Nota: La estrella se referencia desde el extremo superior izquierdo.
-
Rand:
Función estudiada en clase.
-
Fire_star:
Dibuja los disparos de la estrella , uno en cada uno de los cuatro orificios.
-
Redi_star:
Trata los siguientes aspectos sobre la estrella:
-
Debe pasar al hiperespacio. (suceso aleatorio) , en caso afirmativo se actualizarán las variables ys,xs.
-
Debe disparar. (suceso aleatorio).
-
Test_star:
Función que devuelve en la pila el valor uno si no es posible redibujar la estrella a partir del desplazamiento que se pasa en el registro DI como parámetro de entrada; en caso afirmativo devuelve en la pila como resultado de salida un uno.
-
Nuevo_caza:
Genera un nuevo caza en una posición aleatoria de la pantalla.
Para ello realiza un test para ver si es posible ubicar el caza en la posición aleatoria generada, en caso de no ser posible se repite el proceso hasta obtener un ubicación correcta.
-
Init_rand:
Inicializar semilla de una secuencia pseudoaleatoria.
-
Mensa_ganador:
Indica cual ha sido el resultado final de la partida:
| ganador: | Resultado: |
| 0 | pierde halcón |
| 1 | gana halcón |
| 2 | fallo en la generación de número aleatorio |
-
Redi_pant:
Redibujo de la pantalla por medio de los procedimientos : redistar, redicaza , redidisp , redihalcon y act_reloj.
El redibujo de los cazas sólo se hará si la variable c_mover es igual a cero.
-
Ini_int:
Habilita ints. de teclado y reloj en le 8259 , desactivando antes interrupciones pendientes en 8259 mediante un EOI.
-
Mas_cazas:
Pone un caza más cada vez que transcurre un minuto de juego.
Descricipción en alto nivel del programa principal.
Programa Star_Wars
principio
salvar / inicializar VI
cargar @ del buffer de video
mientras_que (fin /= 1) hacer
la_dif:=1
poner opciones del menu
encuesta(laopcion)
mientras_que( 1< laopcion >4 ) hacer
encuesta (laopcion)
fin_mq
selección:
laopcion=1: redefinir
laopcion=2: dificultad
laopcion=3:
borrar pantalla
reiniciar variables_de_juego
ini_pant
mietras_que (terminar/=1) hacer
redibujar pantalla
bucle de espera
fin_mq
poner mensaje de ganador/perdedor
laopcion=4: fin:=1
fin_sel
fin_mq
restaurar VI
borrar pantalla
salir a DOS
fin star_wars
Descripción en alto nivel de la rutina de servicio a la interrupción de reloj.
Programa rut_reloj.
principio
delay:=delay - 1
max_18 := max_18 + 1
si (max_18 = 18) entonces
segundos := segundos + 1
si (segundos = 59) entonces
minutos := minutos +1
segundos := 0
si (la_dif < max_dif) entonces
c_mover :=c_mover - 1
la_dif := la_dif +1
frec := frec - 1
fin_si
fin_si
max_18 := 0
fin_si
EOI
fin rut_reloj
Descripción en alto nivel de la rutina de servicio a la interrupción de teclado.
Programa rut_teclado.
principio
leer (pulsación) ; leer dato del registro de datos del teclado.
si (estado = 0) entonces
si (es_pulsación_de_bajada) entonces
selección:
pulsacion= ESC : terninar:= 1
pulsacion= right : syh:= 0
sxh:= 1
pulsacion= left : syh:= 0
sxh:= -1
pulsacion= up : syh:= 1
sxh:= 0
pulsacion= down : syh:= -1
sxh:= 0
pulsacion= hiper : syh:= 2
sxh:= 2
pulsacion= stop : syh:= -2
sxh:= -2
pulsacion= control : estado:= 1
otros_casos: seguir
sino
estado:= 0
selección:
pulsacion= right : si (xh < 75) entonces
poner_disparo_right.
fin_si
pulsacion= left : si (xh > 4) entonces
poner_disparo_left.
fin_si
pulsacion= up : si (yh > 3) entonces
poner_disparo_up.
fin_si
pulsacion= right : si (yh < 24) entonces
poner_disparo_down.
fin_si
otros_casos: seguir
fin_sel
fin_si
EOI
fin rut_teclado.
TITLE STAR_WARDOSSEGMODEL small
.STACK 100h
;-------------------------------------------------------------------
borrapant MACRO atr
push ax
push cx
push es
push di
pushf
cld
mov ax, dir_pant
mov es, ax
xor di, di
mov al, espacio
mov ah, ATR
mov cx, lineas*columnas
rep stosw
popf
pop di
pop es
pop cx
pop ax
ENDM
;----------------------------------------------------------------------------
ini_buf MACRO
local b0,b8,termina
push ax
push es
xor ax,ax
mov es,ax
mov al,es:[449h]
cmp al,7
je B0
cmp al,2
je B8
cmp al,3
je B8
B0:
mov ax,0B000h
jmp termina
B8:
mov ax,0B800h
termina:
mov dir_pant,ax
pop es
pop ax
ENDM
; Borra el caza,estando el origen del caza en es:[di] , luego di debera tener; el valor adecuado antes de realizar la llamada a la MACRO BORRACAZA MACRO push cx pushf cld
mov ax,hueco
mov cx,lcaza
rep stosw
popf
pop cx
ENDM
;-------------------------------------------------------------------
; Dibuja un caza, estando el origen del caza en la posicion del
; del buffer de video es:[di], luego di debera tenerel valor adecuado
; antes de realizar la llamada a la MACRO
DIBUJACAZA MACRO un_color
local ciclo
push cx
push si
pushf
mov si,offset caza
mov ah,un_color
mov cx,lcaza
cld
ciclo: lodsb
stosw
loop ciclo
popf
pop si
pop cx
ENDM
;----------------------------------------------------------------------------
UN_STROBE MACRO
push ax
in al, strobe
or al, 10000000b
out strobe, al
and al, 01111111b
out strobe, al
pop ax
ENDM
INHIBE_TEC MACRO
push ax
in al, imr
or al, 00000010b
out imr, al
pop ax
ENDM
;-------------------------------------------------------------------
DESINHIBE_TEC MACRO
push ax
in al, imr
and al, 11111101b
out imr, al
pop ax
ENDM
;-------------------------------------------------------------------
INI_PRES MACRO color, fila, columna, cadena, long
push ax
push cx
push dx
push color
push fila
push columna
mov ax, @DATA
mov es, ax
mov dx, OFFSET cadena
mov cx, long
call presenta
mov ax,dir_pant
mov es,ax
pop dx
pop cx
pop ax
ENDM
;-------------------------------------------------------------------
INI_WTOA MACRO num_car ,uncolor, unnumero, unafila, unacolumna
push num_car
push uncolor
push unnumero
push unafila
push unacolumna
call wtoa
ENDM
; VARIABLES Y EQU'S; Atributos de colorcol_tit EQU 04h ; color titulo menu
col_op EQU 0Eh ; color opciones del menu
col_marco EQU 55h ; color marco
col_men_marco EQU 57h ; color mensajes marco
col_fondo EQU 07h ; color fondo
col_bajar EQU 00h ; color para bajar diparos y cazas
col_rubbi EQU 11h ; color rubbiatron
col_star EQU 0CCh ; color estrella
col_dis EQU 0Ah ; color disparos
col_hal EQU 0EEh ; color halcon
col_caza EQU 0Fh ; color caza
hueco EQU 0720h ; hueco
espacio EQU ' ' ; codigo Ascii del caracter espacio
;Codigos de rastreo
escape EQU 1 ; tecla escape
uno EQU 2 ; tecla 1
dos EQU 3 ; tecla 2
tres EQU 4 ; tecla 3
cuatro EQU 5 ; tecla 4
; E/S : direcciones no mapeadas
dato EQU 60h ; reg. datos teclado
strobe EQU 61h ; reg. control teclado
reg_est EQU 64h ; reg. estado teclado
imr EQU 21h ; IMR 8259A
icr EQU 20h ; Reg. control 8259A
; dimensiones de pantalla
lineas EQU 25 ; n. de lineas de la pantalla
columnas EQU 80 ; n. de columnas de la pantalla
lin_arena EQU 22 ; n. de lineas de juego (3..24)
col_arena EQU 76 ; n. de columnas de juego (3..76)
max_di EQU 3998 ; desplazamiento maximo en el buffer de video
.DATA
;codigos de rastreo de los controles
left DB 24 ; tecla O
right DB 25 ; tecla P
up DB 16 ; tecla Q
down DB 30 ; tecla A
hiper DB 35 ; tecla H
stop DB 57 ; tecla Espacio
ctrl EQU 29 ; tecla Control
; Variables relacionadas con el halcon
xh_ini EQU 3 ; columna inicial del halconyh_ini EQU 24 ; fila inicial del halconxh DW xh_ini ; columna actual del halcon
yh DW yh_ini ; fila actual del halcon
sxh DB -2 ; sentido en las x's
syh DB -2 ; sentido en las y's
cad_hal DB " " ; simbolo del halcon
l_cad_hal EQU $-cad_hal ; longitud del halcon
halcon_hiper DB 0 ; controla si debe pasar el halcon al hiper.
; halcon_hiper=1 --> paso al hiper
; Variables relacionadas con la estrella
a_star EQU 3 ; ancho de la estrella
l_star EQU 5 ; longitud de la estrella
xs_ini EQU 60 ; columna inicial de la estrella
ys_ini EQU 6 ; fila inicial de la estrella
xs DW xs_ini ; columna actual de la estrella
ys DW ys_ini ; fila actual de la estrella
h_star DB 1 ; controla si debe pasar la estrella al hiper.
; halcon_h= --> paso al hiper
; Variables relacionadas con los cazas
caza DB '-0-' ; simbolo del caza
lcaza EQU $-caza ; longitud del caza
sentido_caza DB 0 ; sentido del movimiento del caza
; 0 --> horizontal ; 1 --> vertical
c_mover DB max_dif ; frecuencia de movimiento de los cazas
aux_caza DB 0 ; contador de la frec. de moviento de los cazas
frec DB 0 ; frecuencia de disparo de los cazas
aux_frec DB 0 ; contador de la frec. de disparo de los cazas
n_cazas_juego DW 0 ; numero actual de cazas
; variables relacionadas con el reloj
pos_min EQU 25 ; columna de los minutos en pantalla
pos_seg EQU 28 ; columna de los segundos en pantalla
minutos DW 0
segundos DW 0
max_18 DB 0
cad_rel DB "00:00" ; simbolo del reloj
l_cad_rel EQU $-cad_rel ; longitud de cad_rel
; variables necesarias para menu
; mensajes del menu y sus correspondientes longitudes
tit DB "STAR WARS"
l_tit EQU $-tit
op1 DB "1) Redefinir"
l_op1 EQU $-op1
op2 DB "2) Dificultad"
l_op2 EQU $-op2
op3 DB "3) Jugar"
l_op3 EQU $-op3
op4 DB "4) Salir"
l_op4 EQU $-op4
; variables necesarias para la funcion redefinir ; mensajes que aparecen al redefinir y sus logitudes
red1 DB "Izquierda"
l_red1 EQU $-red1
red2 DB "Derecha"
l_red2 EQU $-red2
red3 DB "Arriba"
l_red3 EQU $-red3
red4 DB "Abajo"
l_red4 EQU $-red4
red5 DB "Hiperespacio"
l_red5 EQU $-red5
red6 DB "Stop"
l_red6 EQU $-red6
; variables necesarias para la funcion ini_pant
; mensajes que aparecen en el marco y sus longitudes
marco_1 DB 'Tiempo de juego:'
lmarco_1 EQU $-marco_1
marco_2 DB '00:00'
lmarco_2 EQU $-marco_2
marco_3 DB 'Puntos:'
lmarco_3 EQU $-marco_3
; variables necesarias para la funcion dificultad
; mensajes que aparecen al elegir dificultad y sus longitudes
m_dif DB 'Elige dificultad (1-3): '
lm_dif EQU $-m_dif
la_dif DB 1
max_dif EQU 3
; variables necesarias para la funcion mensa_ganador
; mensajes que aparecen al acabar una partida y sus longitudes
ganador DB 0 ; indica quien gana la partida.
m_win DB 'Enhorabuena , eres un campeon.'
l_m_win EQU $-m_win
m_lose DB 'Dedicate a los estudios , esto no es lo tuyo.'
l_m_lose EQU $-m_lose
merror DB 'Un fallo en la generaci¢n de un n£mero aleatorio,'
DB 'ha hecho fracasar tu misi¢n'
lmerror EQU $-merror
;variables necesarias para la funcion rand
decisiones DW 0
timer DB 4 dup(0) ; para almacenar tiempo muestreado
; del reloj del sistema
a DQ 16807.0 ; coeficientes del alg. de Shrase
m DQ 2147483647.0 ; versi¢n float.
q DQ 127773.0 ; Son reales IEEE754 de 64 bits
r DQ 2836.0
lastx DQ 0.0 ; x_(n-1)
randn DW 0 ; Entero resultado de multiplicar el
; n£m. de decisiones (ej. 2000) por
; el valor aleatorio obtenido
; en la uniforme 0-1
; caracteres ascii de los disparosfire_up DB 18h ; definidas como variables para poder
fire_down DB 19h ; pasarselas a presenta como parametros
fire_right DB 1Ah
fire_left DB 1Bh
; varios
estado DB 0
marcador DW 0
fin DB 0 ; fin=1 --> fin de ejecucion del programa
terminar DB 0 ; terminar=1 --> acabar la partida
iptec DW 0 ; ip rut. servicio teclado del sistema
cstec DW 0 ; cs rut. servicio teclado del sistema
IRQ1 EQU 9*4 ; de la int. de teclado
iprel DW 0 ; ip rut. servicio relo del sistema
csrel DW 0 ; cs rut. servicio reloj del sistema
IRQ0 EQU 8*4 ; de la int. de reloj
dir_pant DW 0 ; direccion de base del buffer de pantalla
delay DB 3 ; variable para controlar la velocidad del
; bucle de espera del juego
.CODE ini: mov ax, @DATA mov ds, ax ;modificar vector de interrupciones call ini_VI ini_buf mov ax,dir_pant
mov es,ax
inicio_game:
mov la_dif,1 ;reinicio la_dif al comienzo de cada partida
cmp fin,1
jne sel
jmp final
sel:
call menu
call encuesta
cmp al, uno
je sel1
cmp al, dos
je sel2
cmp al, tres
je sel3
cmp al, cuatro
jne sel
jmp sel4
sel1:
call redefinir
jmp sel
sel2:
call dificultad
jmp sel
sel3:
borrapant col_fondo
call reiniciar
call ini_pant
call ini_int
buc_h:
cmp terminar, 1
je fin_partida
call redi_pant
mov delay,3
;bucle de espera controlado por la variable delay
esp_fin:
cmp delay,0
jne esp_fin
jmp buc_h
fin_partida:
call mensa_ganador
jmp inicio_game
sel4:
mov fin,1
jmp inicio_game
final:
call res_VI
BORRAPANT col_fondo
mov ah, 4Ch
int 21h
rut_reloj PROC far push ax dec delay ctrl_reloj: inc max_18 cmp max_18,18 jne fin_reloj inc segundos
cmp segundos, 59
je mod_60
jmp n_mod_60
mod_60:
inc minutos
mov segundos, 0
cmp la_dif,max_dif
je n_mod_60
dec c_mover
inc la_dif
dec frec
n_mod_60:
mov max_18, 0
fin_reloj:
mov al, 20h
out icr, al
pop ax
iret
rut_reloj ENDP
rut_teclado PROC far
push ax
;leer dato
in al, dato ;al<- cod. ras.
UN_STROBE
;si estado=1 entoces ha habido una bajada de ctrl
cmp estado,0
je tecla_normal
jmp ya_bajo_control
tecla_normal:
test al, 10000000b
jnz salto0
jmp nosalto0
salto0:
jmp fin_rut_tec
nosalto0:
;identificar tecla de bajada
cmp al, escape
je eti_esc
cmp al, right
je eti_r
cmp al, left
je eti_l
cmp al, up
je eti_u
cmp al, down
je eti_d
cmp al,hiper
je eti_hiper
cmp al,stop
je eti_stop
cmp al,ctrl
je eti_control
jmp fin_rut_tec
eti_esc:
mov terminar, 1
jmp fin_rut_tec
eti_r:
mov syh, 0
mov sxh, 1
jmp fin_rut_tec
eti_l:
mov syh, 0
mov sxh, -1
jmp fin_rut_tec
eti_u:
mov syh, 1
mov sxh, 0
jmp fin_rut_tec
eti_d:
mov syh, -1
mov sxh, 0
jmp fin_rut_tec
eti_hiper:
mov syh,2
mov sxh,2
jmp fin_rut_tec
eti_stop:
mov syh,-2
mov sxh,-2
jmp fin_rut_tec
eti_control:
mov estado,1
jmp fin_rut_tec
ya_bajo_control:
mov estado,0
cmp al,right
je pon_fire_der
cmp al,left
je pon_fire_izq
cmp al,up
je salto1
jmp nosalto1
salto1:
jmp pon_fire_up
nosalto1:
cmp al,down
je salto2
jmp fin_rut_tec ;control+tecla que no es de direcci¢n
salto2:
jmp pon_fire_down
;para los disparos tener en cuenta como se referencia el halcon
;en funcion de xh,yh
pon_fire_der:
cmp xh,75
jae salto3
jmp nosalto3
salto3:
jmp fin_rut_tec
nosalto3:
add xh,4
ini_pres col_dis,yh,xh,fire_right,1
sub xh,4
jmp fin_rut_tec
pon_fire_izq:
cmp xh,4
jbe salto4
jmp nosalto4
salto4:
jmp fin_rut_tec
nosalto4:
sub xh,2
ini_pres col_dis,yh,xh,fire_left,1
add xh,2
jmp fin_rut_tec
pon_fire_up:
cmp yh,3
jae sig_pon_fire_up
jmp fin_rut_tec
sig_pon_fire_up:
dec yh
inc xh ;centrar disparo
ini_pres col_dis,yh,xh,fire_up,1
inc yh
dec xh
jmp fin_rut_tec
pon_fire_down:
cmp yh,24
jae fin_rut_tec
inc yh
inc xh ;centrar disparo
ini_pres col_dis,yh,xh,fire_down,1
dec yh
dec xh
jmp fin_rut_tec
fin_rut_tec:
mov al, 20h
out icr, al
pop ax
iret
rut_teclado ENDP
ini_VI PROC near push ax push es push si xor ax,ax mov es,ax mov si,IRQ1 mov ax,es:[si] mov iptec,ax
mov ax,es:2[si]
mov cstec,ax
cli
mov ax,@CODE
mov es:2[si],ax
mov ax,offset rut_teclado
mov es:[si],ax
sti
mov si,IRQ0
mov ax,es:[si]
mov iprel,ax
mov ax,es:2[si]
mov csrel,ax
cli
mov ax,@CODE
mov es:2[si],ax
mov ax,offset rut_reloj
mov es:[si],ax
sti
pop si
pop es
pop ax
ret
ini_VI ENDP
res_VI PROC near push ax push es push si mov si, IRQ1 xor ax,ax mov es,ax cli
mov ax,iptec mov es:[si],ax
mov ax,cstec
mov es:2[si],ax
sti
mov si, IRQ0
cli
mov ax,iprel
mov es:[si],ax
mov ax,csrel
mov es:2[si],ax
sti
pop si
pop es
pop ax
ret
res_VI ENDP
wtoa PROC near ; llamada: (long,color, numero, fila, col) long EQU 12[bp]col EQU 10[bp]
n EQU 8[bp]
f EQU 6[bp]
c EQU 4[bp]
push bp
mov bp, sp
push ax
push bx
push cx
push dx
push di
mov ax, n
mov bx,10
xor cx, cx ; numero de digitos
buc_wtoa:
xor dx,dx
div bx
add dl,30h
push dx
inc cx
cmp ax,0
jne buc_wtoa
push f
push c
call calculo_posicion
mov ax, dir_pant
mov es, ax
cmp long, cx
je buc_esc
push cx
sub long, cx
mov cx, long
buc_ceros:
mov al, '0'
mov ah, col
mov es:[di], ax
add di, 2
loop buc_ceros
pop cx
buc_esc:
pop ax
mov ah, col
mov es:[di], ax
add di, 2
loop buc_esc
pop di
pop dx
pop cx
pop bx
pop ax
mov sp, bp
pop bp
ret 10
wtoa ENDP
presenta PROC near color EQU 8[bp]f EQU 6[bp]c EQU 4[bp] push bp
mov bp,sp
push ax
push dx
push di
push si
push f
push c
call calculo_posicion
mov si,dx
mov dx,es
mov ds, dx
mov ax,dir_pant
mov es,ax
cld
mov ah,color
desde: lodsb ;al<--ds:si
stosw ;es:di<--ax
loop desde
pop si
pop di
pop dx
pop ax
mov sp, bp
pop bp
ret 6
presenta ENDP
redidisp PROC near push bp mov bp, sp
push ax
push cx
push dx
push di
pushf
mov di, 0
buc_redidisp: cmp terminar,1 je fin_redidisp cmp di,max_di ja fin_redidisp mov ax, es:[di] ;no inc. por los stosw
cmp ah,col_bajar
je ya_bajado
cmp al,fire_down
je eti_bajar
cmp al, fire_left
je eti_izq
cmp al, fire_right
je eti_der
cmp al, fire_up
je eti_subir
add di, 2
jmp buc_redidisp
ya_bajado:
mov ah,col_dis
mov al,fire_down
stosw
jmp buc_redidisp
eti_izq:
call p_dis_izq
jmp buc_redidisp
eti_der:
call p_dis_der
jmp buc_redidisp
eti_subir:
call p_dis_sub
jmp buc_redidisp
eti_bajar:
call p_dis_baj
jmp buc_redidisp
fin_redidisp:
popf
pop di
pop dx
pop cx
pop ax
mov sp, bp
pop bp
ret
redidisp ENDP
p_dis_izq PROC near push bp mov bp, sp mov ax,hueco
stosw
sub di, 2 ;Borro disp. viejo
sub di,2
mov ax, dir_pant
mov es, ax
mov ax, es:[di]
cmp ah, col_dis
je colision_izq
cmp ah, col_caza
je diana_caza_izq
cmp ah, col_fondo
je normal_izq ; Implicito que no se ponga
;en marco o color_star
cmp ah,col_hal
je halcon_izq
cmp ah,col_rubbi
je rubbi_izq
jmp fin_p_dis_izq
colision_izq: ; Si hay otro disparo ,lo borro
mov ax,hueco
stosw
add di,2
jmp fin_p_dis_izq
diana_caza_izq: ; Si hay un caza lo borro
sub di,8
BORRACAZA
call nuevo_caza
push 1
call act_marc
jmp fin_p_dis_izq
normal_izq: mov ah, col_dis mov al, fire_left stosw ; Coloco nuevo disparo
add di,2
jmp fin_p_dis_izq
halcon_izq:
mov terminar,1
mov ganador,0
jmp fin_p_dis_izq
rubbi_izq:
mov terminar,1 ; Si impacta partida acabada
mov ganador,1
jmp fin_p_dis_izq
fin_p_dis_izq:
mov sp, bp
pop bp
ret
p_dis_izq ENDP
p_dis_der PROC
push bp
mov bp, sp
mov ax,hueco
stosw
mov ax, es:[di]
cmp ah, col_dis
je colision_der
cmp ah,col_caza
je diana_caza_der
cmp ah, col_fondo
je normal_der
cmp ah,col_hal
je halcon_der
cmp ah,col_rubbi
je rubbi_der
jmp fin_p_dis_der
colision_der:
mov ax,hueco
stosw
jmp fin_p_dis_der
diana_caza_der:
BORRACAZA
call nuevo_caza
push 1
call act_marc
jmp fin_p_dis_der
normal_der:
mov ah, col_dis
mov al, fire_right
stosw ;di<-di+2
jmp fin_p_dis_der
halcon_der:
mov terminar,1
mov ganador,0
jmp fin_p_dis_der
rubbi_der:
mov terminar,1
mov ganador,1
jmp fin_p_dis_der
fin_p_dis_der:
mov sp, bp
pop bp
ret
p_dis_der ENDP
p_dis_sub PROC push bp mov bp, sp mov ax,hueco stosw sub di,2 sub di, columnas*2 mov ax, es:[di]
cmp ah, col_dis
je colision_sub
cmp ah,col_caza
je diana_caza_sub
cmp ah, col_fondo
je normal_sub
cmp ah,col_hal
je halcon_sub
cmp ah,col_rubbi
je rubbi_sub
add di, columnas*2
jmp fin_p_dis_sub
diana_caza_sub:
;buscar extremo inicial del caza
rewind1:
sub di,2
mov ax,es:[di]
cmp ah,col_caza
je rewind1
add di,2
BORRACAZA
call nuevo_caza
push 1
call act_marc
sub di,(2*lcaza)
add di,columnas*2
jmp fin_p_dis_sub
colision_sub:
mov ax,hueco
stosw
add di,columnas*2
jmp fin_p_dis_sub
normal_sub:
mov ah, col_dis
mov al, fire_up
stosw
add di, columnas*2
jmp fin_p_dis_sub
halcon_sub:
mov terminar,1
mov ganador,0
jmp fin_p_dis_sub
rubbi_sub: mov terminar,1
mov ganador,1
jmp fin_p_dis_sub
fin_p_dis_sub:
mov sp, bp
pop bp
ret
p_dis_sub ENDP
p_dis_baj PROC push bp mov bp, sp mov ax,hueco stosw sub di, 2 add di, columnas*2
mov ax, es:[di]
cmp ah, col_dis
je colision_baj
cmp ah,col_caza
je diana_caza_baj
cmp ah, col_fondo
je normal_baj
cmp ah,col_hal
je halcon_baj
cmp ah,col_rubbi
je rubbi_baj
sub di, columnas*2
jmp fin_p_dis_baj
colision_baj:
mov ax,hueco
stosw
sub di, columnas*2
jmp fin_p_dis_baj
diana_caza_baj:
rewind2:
sub di,2
mov ax,es:[di]
cmp ah,col_caza
je rewind2
add di,2
BORRACAZA
call nuevo_caza
push 1
call act_marc
sub di,(2*lcaza)
jmp fin_p_dis_baj
normal_baj:
mov ah, col_bajar ; Disparo camuflado
mov al, fire_down
stosw
sub di, 2
sub di, columnas*2
jmp fin_p_dis_baj
halcon_baj:
mov terminar,1
mov ganador,0
jmp fin_p_dis_baj
rubbi_baj:
mov terminar,1
mov ganador,1
jmp fin_p_dis_baj
fin_p_dis_baj:
mov sp, bp
pop bp
ret
p_dis_baj ENDP
redicaza PROC near push bp mov bp, sp push ax push cx push di push OFFSET randn ; frec. sentido cazas
mov decisiones,1 ; (50% de prob para cambiar)
push decisiones
call rand
cmp randn, 0 ; se modifica si sale cero
jne sigue_redicaza
not sentido_caza
and sentido_caza, 00000001b ; para decidir en [0,1]
sigue_redicaza:
mov di, 0
buc_redicaza:
cmp terminar,1
je fin_redicaza
cmp di,max_di
ja fin_redicaza
mov ax, es:[di] ;no inc. por los stosw
cmp ah,col_bajar
je reaparicion
cmp ah, col_caza
je eti_caza
add di,2
jmp buc_redicaza
reaparicion:
DIBUJACAZA col_caza
jmp buc_redicaza
eti_caza: ;ver si debe disparar el caza
call calculo_coordenadas
cmp yh,ax ;comparo fila
je misma_fila
inc bx ;para optimizar objetivo del disparo
cmp xh,bx
je misma_columna
;si no hay coincidencia --> muevo el halcon
dec bx
cmp sentido_caza,0
je caza_horizontal
cmp sentido_caza,1
je caza_vertical
caza_horizontal:
call mov_caza_hor
jmp buc_redicaza
caza_vertical:
call mov_caza_ver
jmp buc_redicaza
misma_fila:
call h_misma_fila
jmp buc_redicaza
misma_columna:
call h_misma_columna
jmp buc_redicaza
fin_redicaza:
pop di
pop cx
pop ax
mov sp, bp
pop bp
ret
redicaza ENDP
mov_caza_hor PROC near
push bp
mov bp,sp
cmp xh,bx
jb caza_izq
jmp caza_der
caza_izq:
sub di,2 ; Ver lo que hay junto al extremo izdo
mov ax,es:[di]
cmp ah,col_marco
je bloqueo_izq
cmp ah,col_rubbi
je choque_rubbi_izq
cmp ah,col_hal
je choque_hal_izq
cmp ah,col_star
je choque_star_izq
cmp ah,col_dis
je hay_choque_izq
cmp ah,col_caza
je choque_caza_izq
jmp avance_izq
bloqueo_izq:
add di,2
add di,(2*lcaza)
jmp fin_mov_caza_hor
choque_rubbi_izq:
mov terminar,1
mov ganador,1
jmp fin_mov_caza_hor
choque_hal_izq:
mov terminar,1
mov ganador,0
jmp fin_mov_caza_hor
hay_choque_izq:
mov ax,hueco
mov es:[di],ax
add di,2
BORRACAZA
call nuevo_caza
push 1
call act_marc
jmp fin_mov_caza_hor
choque_star_izq:
add di,2
BORRACAZA
call nuevo_caza
push 1
call act_marc
jmp fin_mov_caza_hor
choque_caza_izq:
sub di,(2*lcaza)-2
BORRACAZA
BORRACAZA
call nuevo_caza
call nuevo_caza
push 2
call act_marc
jmp fin_mov_caza_hor
avance_izq:
;Avance sin problemas
add di,2
BORRACAZA
sub di,(2*lcaza)
sub di,2
DIBUJACAZA col_caza
jmp fin_mov_caza_hor
caza_der:
add di,(2*lcaza)
mov ax,es:[di]
cmp ah,col_marco
je bloqueo_der
cmp ah,col_rubbi
je choque_rubbi_der
cmp ah,col_hal
je choque_hal_der
cmp ah,col_star
je choque_star_der
cmp ah,col_dis
je hay_choque_der
cmp ah,col_caza
je choque_caza_der
jmp avance_der
bloqueo_der: add di,2
jmp fin_mov_caza_hor
choque_rubbi_der:
mov terminar,1
mov ganador,1
jmp fin_mov_caza_hor
choque_hal_der:
mov terminar,1
mov ganador,0
jmp fin_mov_caza_hor
hay_choque_der:
mov ax,hueco
mov es:[di],ax
sub di,(2*lcaza)
BORRACAZA
call nuevo_caza
push 1
call act_marc
jmp fin_mov_caza_hor
choque_star_der:
sub di,(2*lcaza)
BORRACAZA
call nuevo_caza
push 1
call act_marc
jmp fin_mov_caza_hor
choque_caza_der:
sub di,(2*lcaza)
BORRACAZA
BORRACAZA
call nuevo_caza
call nuevo_caza
push 2
call act_marc
jmp fin_mov_caza_hor
avance_der:
;Avance sin problemas.
sub di,(2*lcaza)
BORRACAZA
sub di,(2*lcaza)
;redibujo el caza
add di,2
DIBUJACAZA col_caza
jmp fin_mov_caza_hor
fin_mov_caza_hor:
mov sp,bp
pop bp
ret
mov_caza_hor ENDP
mov_caza_ver PROC near push bp mov bp,sp cmp yh,ax
ja caza_down
jmp caza_up
caza_down:
BORRACAZA
sub di,(2*lcaza)
;primero debo ver si estan libres las cinco posiciones de abajo
add di,(columnas*2)
push cx
mov cx,lcaza
unbucle:
mov ax,es:[di]
cmp ax,hueco
jne no_mover_down
add di,2
loop unbucle
pop cx
; es posible el movimiento de bajada
;dibujo el caza con color de bajada (!ojo)
sub di,(2*lcaza)
DIBUJACAZA col_bajar
sub di,(columnas*2)
jmp fin_mov_caza_ver
no_mover_down:
pop cx ; se hizo un push antes del bucle
cmp ah,col_marco
je bloqueo_down
cmp ah,col_hal
je halcon_abajo
cmp ah,col_dis
je choque_disp_baj
cmp ah,col_star
je choque_star_baj
cmp ah,col_caza
je choque_caza_down
bloqueo_down:
sub di,columnas*2
DIBUJACAZA col_caza
jmp fin_mov_caza_ver
halcon_abajo:
mov terminar,1
mov ganador,0
jmp fin_mov_caza_ver
choque_disp_baj:
mov ax,hueco
stosw
sub di,(columnas*2)
call nuevo_caza
push 1
call act_marc
jmp fin_mov_caza_ver
choque_star_baj:
sub di,(columnas*2)
call nuevo_caza
push 1
call act_marc
jmp fin_mov_caza_ver
choque_caza_down: ;debo buscar el inicio del caza
elbucle:
sub di,2
mov ax,es:[di]
cmp ah,col_caza
je elbucle
add di,2
BORRACAZA
call nuevo_caza
call nuevo_caza
push 2
call act_marc
sub di,(2*lcaza)
sub di,(2*columnas)
jmp fin_mov_caza_ver
caza_up:
BORRACAZA
sub di,(2*lcaza)
; primero debo ver si estan libres las
; cinco posicion de arriba
sub di,(columnas*2)
push cx
mov cx,lcaza
unbucle1:
mov ax,es:[di]
cmp ax,hueco
jne no_mover_up
add di,2
loop unbucle1
pop cx
; es posible el movimiento de subida
sub di,(2*lcaza)
DIBUJACAZA col_caza
add di,(columnas*2)
jmp fin_mov_caza_ver
no_mover_up:
pop cx ; se hizo un push antes del bucle
cmp ah,col_marco
je bloqueo_up
cmp ah,col_hal
je choque_halcon_up
cmp ah,col_dis
je choque_disp_up
cmp ah,col_star
je choque_star_up
cmp ah,col_caza
je choque_caza_up
bloqueo_up:
add di,columnas*2
DIBUJACAZA col_caza
jmp fin_mov_caza_ver
choque_halcon_up:
mov terminar,1
mov ganador,0
choque_disp_up:
mov ax,hueco
stosw
add di,(columnas*2)
call nuevo_caza
push 1
call act_marc
jmp fin_mov_caza_ver
choque_star_up:
add di,(columnas*2)
call nuevo_caza
push 1
call act_marc
jmp fin_mov_caza_ver
choque_caza_up: ;debo buscar el inicio del caza
elbucle1:
sub di,2
mov ax,es:[di]
cmp ah,col_caza
je elbucle1
add di,2
BORRACAZA
call nuevo_caza
call nuevo_caza
push 2
call act_marc
sub di,(2*lcaza)
add di,(2*columnas)
jmp fin_mov_caza_ver
fin_mov_caza_ver:
mov sp,bp
pop bp
ret
mov_caza_ver ENDP
h_misma_fila PROC near push bp
mov bp,sp
cmp aux_frec,0
jne no_fire_fila
cmp bx,xh ;comparo columnas
ja halcon_en_izda
;ponemos un disparo en el extremo derecho del caza
;puesto que el halcon esta a la derecha
add di,(2*lcaza) ;para situarnos en extremo derecho
mov ah,col_dis
mov al,fire_right
stosw
jmp fin_h_misma_fila
no_fire_fila:
add di,(2*lcaza)
jmp fin_h_misma_fila
halcon_en_izda:
sub di,2
mov ah,col_dis
mov al,fire_left
stosw
add di,(2*lcaza) ;una vez puesto el disparo saltamos el caza
jmp fin_h_misma_fila
fin_h_misma_fila:
mov sp,bp
pop bp
ret
h_misma_fila ENDP
h_misma_columna PROC near push bp mov bp,sp cmp aux_frec,0
jne no_fire_columna
cmp ax,yh
jae halcon_arriba
add di,4 ;optimizar posici¢n de disparo
add di,(columnas*2)
mov ah,col_dis
mov al,fire_down
stosw
sub di,(columnas*2)
add di,4 ;saltar resto del caza
jmp fin_h_misma_columna
no_fire_columna:
add di,(2*lcaza)
jmp fin_h_misma_columna
halcon_arriba:
add di,4
sub di,(columnas*2)
mov ah,col_dis
mov al, fire_up
stosw
add di,(columnas*2)
add di,4 ;saltar resto del caza
jmp fin_h_misma_columna
fin_h_misma_columna:
mov sp,bp
pop bp
ret
h_misma_columna ENDP
redihalcon PROC near push bp mov bp, sp push di ;Borrar halcon viejo
ini_pres 07h, yh, xh, cad_hal, l_cad_hal
; Actualizar coordenadas en funcion del sentido
; de movimiento, se incluye tratamiento para
; cuando el halcon se sale del marco
cmp sxh, 1
je eti_r_r
cmp sxh, -1
je eti_r_l
cmp syh, 1
je eti_r_u
cmp syh, -1
je eti_r_d
cmp sxh, 2
je eti_r_h
jmp eti_r_s
;el halcon solo puede estar en la col: (3..74)
;el halcon solo puede estar en la fil: (3..24)
;despues de cada actualizacion se comprueba si la nueva casilla esta libre
;tener en cuenta que el halc¢n se referencia desde el extremo izdo
eti_r_r:
inc xh
cmp xh,77
jne salto5
jmp nosalto5
salto5:
jmp redi_h
nosalto5:
mov xh,3
jmp redi_h
eti_r_l:
dec xh
cmp xh,2
jne redi_h
mov xh,76
jmp redi_h
eti_r_u:
dec yh
cmp yh,2
jne redi_h
mov yh,24
jmp redi_h
eti_r_d:
inc yh
cmp yh,25
jne redi_h
mov yh,3
jmp redi_h
eti_r_h:
mov halcon_hiper, 1
push OFFSET randn
mov decisiones,((columnas*lineas)-1)
push decisiones
call rand
mov di,randn
shl di, 1
call calculo_coordenadas
mov yh,ax
mov xh,bx
mov sxh, -2 ;paro el halc¢n
mov syh, -2
jmp redi_h
eti_r_s:
jmp redi_h
redi_h:
push yh
push xh
call calculo_posicion
push cx
mov cx,l_cad_hal
mov ax,dir_pant
mov es,ax
ver_ocupa:
mov ax,es:[di]
cmp ax,hueco
je seguir_ocupa
jmp muerte
seguir_ocupa:
add di,2
loop ver_ocupa
pop cx
sub di,(2*lcaza)
ini_pres col_hal, yh, xh, cad_hal, l_cad_hal
jmp fin_redihalcon
muerte:
cmp halcon_hiper, 1
jne termina_h ; si halcon_hiper=1 , buscar una
jmp eti_r_h ; nueva posici¢n en el hiper
termina_h:
pop cx
mov terminar,1
fin_redihalcon:
mov halcon_hiper, 0
pop di
mov sp, bp
pop bp
ret
redihalcon ENDP
calculo_posicion PROC near fil EQU 6[bp]col EQU 4[bp] push bp mov bp, sp
push ax
push dx
mov ax,fil
dec ax
mov dx,columnas
mul dx
mov dx,col
dec dx
add ax,dx
shl ax,1
mov di, ax
pop dx
pop ax
fin_cal_pos:
mov sp, bp
pop bp
ret 4
calculo_posicion ENDP
;----------------------------------------------------------------------
calculo_coordenadas PROC near
;parametros: E: di ;Sal ;ax,bx
push bp
mov bp, sp
push dx
xor dx,dx
mov ax,di
mov bx,(columnas)*2
div bx ; ax:cociente(fila) ; dx:resto(columna)
inc ax ; incrementos puesto que contamos:
; fila:1-25 columna:1-80
mov bx,dx
shr bx,1
pop dx
fin_cal_coor:
mov sp, bp
pop bp
ret
calculo_coordenadas ENDP
ini_pant PROC near push ax push bx push cx push dx push si push di ;dibujo del marco (color rosa)
; primero todo de color de col_marco y después
; pinto las lineas de 'color_fondo' borrapant col_marco mov si,2 ; 'y' de la fila inicial mov bx,2 ; 'x'de la columna inicial mov ax,dir_pant mov es,ax
mov cx,lin_arena
ancho:
mov ax,si
mov dx,columnas
mul dx
add ax,bx
shl ax,1
mov di,ax
push cx
mov cx,col_arena
mov ax,hueco
rep stosw
pop cx
inc si
loop ancho
;escribir mensajes iniciales
INI_PRES col_men_marco,1 ,6 , marco_1, lmarco_1
INI_PRES col_men_marco,1 ,25 , marco_2, lmarco_2
INI_PRES col_men_marco,1 ,50 , marco_3, lmarco_3
INI_WTOA 5,col_men_marco,marcador,1,62
;dibujar estrella en posici¢n(ys,xs)
push ys
push xs
call calculo_posicion
call dibuja_star
;dibujar halcon en la posicion (yh_ini,xh_ini)
ini_pres col_hal, yh, xh, cad_hal, l_cad_hal
;dibujar cazas: n§cazas=(la_dif)+2
xor cx,cx
mov cl,la_dif
add cx,2
mov n_cazas_juego, cx
dibu_caza: call nuevo_caza loop dibu_caza pop di pop si pop dx pop cx pop bx pop ax
ret
ini_pant ENDP
menu PROC near push bp mov bp, sp borrapant col_fondo INI_PRES col_tit, 4, 35 , tit, l_tit INI_PRES col_op, 7, 15, op1, l_op1 INI_PRES col_op, 9, 15, op2, l_op2
INI_PRES col_op, 11, 15, op3, l_op3
INI_PRES col_op, 13, 15, op4, l_op4
mov sp, bp
pop bp
ret
menu ENDP
;-------------------------------------------------------------------
encuesta PROC near push bp mov bp,sp INHIBE_TEC consulta: in al, reg_est test al, 00000001b jz consulta in al, dato ;al<- cod. ras.
UN_STROBE
test al, 10000000b
jnz consulta
DESINHIBE_TEC
mov sp, bp
pop bp
ret
encuesta ENDP
redefinir PROC near
push bp mov bp,sp push ax push cx push dx borrapant col_fondo INI_PRES col_op,5 ,25 , red1, l_red1 call encuesta
mov left, al
INI_PRES col_op,6 ,25 , red2, l_red2
call encuesta
mov right, al
INI_PRES col_op,7 ,25 , red3, l_red3
call encuesta
mov up, al
INI_PRES col_op,8 ,25 , red4, l_red4
call encuesta
mov down, al
INI_PRES col_op,9 ,25 , red5, l_red5
call encuesta
mov hiper, al
INI_PRES col_op,10 ,25 , red6, l_red6
call encuesta
mov stop, al
pop dx
pop cx
pop ax
mov sp,bp
pop bp
ret
redefinir ENDP
dificultad PROC near push bp mov bp,sp
push ax
borrapant col_fondo
INI_PRES col_op,5 ,25 ,m_dif , lm_dif
pedir_dif:
call encuesta
cmp al,uno
je dif_correcta
cmp al,dos
je dif_correcta
cmp al,tres
je dif_correcta
jmp pedir_dif
dif_correcta:
dec al ; Convertir el codigo de rastreo
mov la_dif,al
pop ax
mov sp,bp
pop bp
ret
dificultad ENDP
reiniciar PROC near push bp mov bp,sp call init_rand mov ganador,0 mov terminar,0 mov yh,yh_ini
mov xh,xh_ini
mov syh, -2
mov sxh, -2
mov xs, xs_ini
mov ys, ys_ini
mov al,max_dif
sub al,la_dif
mov c_mover,al
mov aux_caza,al
inc al ; auxfrec: 0..(max_dif+1)
mov frec,al
mov aux_frec,al
call ini_marc
mov segundos,0
mov minutos,0
mov sp,bp
pop bp
ret
reiniciar ENDP
;-------------------------------------------------------------------
act_marc PROC near
; le pasamos en la pila como parametro la cifra en que se incrementa
; el marcador
cifra EQU 4[bp]
push bp
mov bp,sp
push bx
xor bx,bx
mov bx,cifra
add marcador,bx
INI_WTOA 5,col_men_marco,marcador,1,62
pop bx
mov sp, bp
pop bp
ret 2
act_marc ENDP
act_reloj PROC near INI_WTOA 2,col_men_marco,minutos,1,pos_min INI_WTOA 2,col_men_marco,segundos,1,pos_seg ret act_reloj ENDP
;-------------------------------------------------------------------
ini_marc PROC near
mov marcador,0
ret
ini_marc ENDP
;-------------------------------------------------------------------
borra_star PROC near ;borra la estrella cuyo origen se pasa a traves de di push bp mov bp, sp push ax push di push ys push xs call calculo_posicion
mov ax, hueco
stosw ; borrar linea superior
stosw
add di,2
stosw
stosw
sub di, 2*l_star
add di, 2*columnas
add di,4
stosw ; borrar rubbiatron
add di,4
sub di, 2*l_star
add di, 2*columnas
stosw
stosw
add di,2 ; borrar linea inferior
stosw
stosw
pop di
pop ax
mov sp, bp
pop bp
ret
borra_star ENDP
dibuja_star PROC near
push bp
mov bp, sp
push ax
push di
push ys
push xs
call calculo_posicion
mov al, espacio
mov ah, col_star
stosw
stosw
mov ah, col_fondo
stosw
mov ah, col_star
stosw
stosw
sub di, 2*l_star
add di, 2*columnas
mov ah, col_fondo
stosw
stosw
mov ah, col_rubbi
stosw
mov ah, col_fondo
stosw
stosw
sub di, 2*l_star
add di, 2*columnas
mov ah, col_star
stosw
stosw
mov ah, col_fondo
stosw
mov ah, col_star
stosw
stosw
pop di
pop ax
mov sp, bp
pop bp
ret
dibuja_star ENDP
rand PROC near push bp mov bp, sp sub sp, 10 push ax push bx pushf finit fld lastx ; st <- x_(n-1)
fdiv q ; st <- x_(n-1)/q
frndint ; st<-TRUNC( x_(n-1)/q)
fst qword ptr -8[bp] ; tmp <- st
fmul q ; st <- st * q
fsubr lastx ; st <- lastx - st
fmul a ; st <- a*(x % q)
fld r ; st <- r, st(1) <- a*(x % q)
fmul qword ptr -8[bp] ; tmp <- r*tmp
fstp qword ptr -8[bp]
fsub qword ptr -8[bp] ; st <- st - tmp
fst lastx
ftst ; modifico la PSW del copro
fstsw word ptr -10[bp] ; guardo la sw del copro
fwait
mov ah, byte ptr -9[bp] ; pongo en ah el msB
sahf ; cf = c0; zf = c3
; zf cf resul
; 0 0 ST>0
; 0 1 ST< 0
; 1 0 ST = 0
; 1 1 error
jc menig
jnz mayor ; cf = 0; si zf = 0 ent mayor
menig:
jz el_error ; cf = zf = 1 ent error
fadd m
mayor:
fdiv m
; leo 4[bp] y lo cargo en ST convertido a real:
fild word ptr 4[bp]
fmul ; st <- st * st(1)
mov bx, 6[bp]
fistp word ptr[bx] ; redondeo y almaceno en el entero
jmp randfin
el_error:
mov terminar,1
mov ganador,2
randfin:
popf
pop bx
pop ax
mov sp, bp
pop bp
ret 4
rand ENDP
fire_star PROC near push bp mov bp, sp push ax
push di
push es
push ys
push xs
call calculo_posicion
;Situarnos en el rubbiatron
add di, columnas*2
add di, 4
;colocar los disparos
mov ax, dir_pant
mov es, ax
mov ah, col_dis
add di, 2
mov al, fire_right
mov es:[di], ax
sub di, 4
mov al, fire_left
mov es:[di], ax
add di, 2
sub di, columnas*2
mov al, fire_up
mov es:[di], ax
add di, columnas*2*2
mov al, fire_down
mov es:[di], ax
pop es
pop di
pop ax
mov sp, bp
pop bp
ret
fire_star ENDP
redistar PROC near push bp mov bp, sp ; frecuencia de hiperespacio de la estrella
push OFFSET randn
mov decisiones,10
xor dh,dh
mov dl,la_dif
shl dx,1
sub decisiones,dx
push decisiones
call rand
cmp randn, 0
jne frec_fire_star
mov h_star,
frec_fire_star: ; frecuencia de disparo de la estrella
push OFFSET randn
mov decisiones,10
xor dh,dh
mov dl,la_dif
shl dx,1
sub decisiones,dx
push decisiones
call rand
cmp randn, 0
jne no_fire_star
call fire_star
no_fire_star:
cmp h_star, 0
jne fin_redistar
push ys
push xs
call calculo_posicion
add di, 2
call borra_star
reap_star: ;Reaparicion
push OFFSET randn ; frec. velocidad cazas
mov decisiones,((columnas*lineas)-1)
push decisiones
call rand
mov di, randn
shl di, 1
call calculo_coordenadas
mov ys, ax
mov xs, bx
sub sp, 2
call test_star
pop cx
cmp cx, 1
je reap_star
call dibuja_star
mov h_star, 1
fin_redistar: mov sp, bp pop bp ret redistar ENDP
test_star PROC near resul_star EQU 4[bp] push bp mov bp, sp push ax
push cx
push di
sub di, 2
mov cx, a_star
mov ax, dir_pant
mov es, ax
mi_buc:
push cx
mov cx, l_star
mi_buc1:
mov ax,es:[di]
cmp ax, hueco
jne error_star
add di, 2
loop mi_buc1
add di,(columnas-l_star)*2
pop cx
loop mi_buc
xor cx, cx
mov resul_star, cx
jmp fin_test_star
error_star:
pop cx
mov cx, 1
mov resul_star, cx
fin_test_star:
pop di
pop cx
pop ax
mov sp, bp
pop bp
ret
test_star ENDP
nuevo_caza PROC near
push bp
mov bp, sp
push ax
push cx
push di
genera_rand:
push OFFSET randn
mov decisiones, ((columnas*lineas)-1)
push decisiones
call rand
mov di,randn
shl di,1
mov cx, lcaza
push di
buc_nuevo_caza:
mov ax, es:[di]
cmp ax, hueco
jne error_caza
add di, 2
loop buc_nuevo_caza
pop di
push di
DIBUJACAZA col_caza
pop di
jmp fin_nuevo_caza
error_caza:
pop di
jmp genera_rand
fin_nuevo_caza:
pop di
pop cx
pop ax
mov sp, bp
pop bp
ret
nuevo_caza ENDP
init_rand PROC near push bx push cx push dx push ds mov ah, 02h ;ch,cl, dh <- hh:mm:ss
int 1ah
pop ds
mov bx, offset timer ; copio los bits en timer
mov [bx], cx
add bx, 2
mov [bx], dh
finit
lea bx, timer
fild DWord ptr [bx] ; ST<- timer convertido a float64
fstp lastx ; lastx<-ST
pop dx
pop cx
pop bx
ret
init_rand ENDP
;---------------------------------------------------------------------------
mensa_ganador PROC near
BORRAPANT col_fondo
cmp ganador,2
je mensa_fallo_rand ; fallo en la generacion de un numero aleatorio
cmp ganador,1
je mensa_win ; partida ganada
ini_pres col_op,12,15,m_lose,l_m_lose ;partida perdida
jmp fin_mensa
mensa_fallo_rand:
ini_pres col_op,12,15,merror,lmerror
jmp fin_mensa
mensa_win:
ini_pres col_op,12,15,m_win,l_m_win
add marcador,50 ; Bonificacion por ganar
fin_mensa:
ini_pres col_op,14,15,marco_3,lmarco_3
ini_wtoa 5,col_op,marcador,14,24
call encuesta
ret
mensa_ganador ENDP
redi_pant PROC near push bp mov bp,sp push dx call redistar cmp aux_frec,0 je actualizar_frec dec aux_frec jmp speed_cazaactualizar_frec:
mov al,frec
mov aux_frec,al
speed_caza: cmp aux_caza,0
je hay_redicaza
dec aux_caza
jmp no_hay_redicaza
hay_redicaza:
mov al,c_mover
mov aux_caza,al
call redicaza
no_hay_redicaza:
call redidisp
call redihalcon
call act_reloj
call mas_cazas
pop dx
mov sp,bp
pop bp
ret
redi_pant ENDP
ini_int PROC near
push ax
in al,imr
and al,11111100b
out imr,al
mov al,20h
out icr,al
pop ax
ret
ini_int ENDP
;----------------------------------------------------------------------------mas_cazas PROC near push bp mov bp,sp xor ax, ax mov al, la_dif add al, 2 ; porque n§cazas=ladif+2
cmp ax, n_cazas_juego
je no_pongo
call nuevo_caza
add n_cazas_juego, 1
no_pongo:
pop ax
mov sp,bp
pop bp
ret
mas_cazas ENDP
;---------------------------------------------------------------------------
END
Índice alfabético-->[Author:Edu].
- Act_marc. pag. 52
- Act_reloj. pag. 53
- Borracaza. (Macro) pag. 11
- Borrapant. (Macro) pag. 10
- Borra_star. pag. 53
- Calculo_posicion. pag. 46
- Calculo_coordenadas. pag. 46
- Desinhibe_tec pag. 12
- Dibujacaza. (Macro) pag. 11
- Dificultad. pag. 51
- Dibuja_star. pag. 54
- Encuesta. pag. 49
- Fire_star. pag. 56
- H_misma_fila. pag. 42
- H_misma_columna. pag. 43
- Ini_buf. (Macro) pag. 10
- Inhibe_tec. (Macro). pag. 12
- Ini_int. pag. 62
- Ini_marc. pag. 53
- Ini_pant. pag. 47-48
- Ini_pres. (Macro). pag. 12
- Ini_wtoa. (Macro). pag. 12
- Ini_VI. pag. 23
- Init_rand. pag. 60
- Mas_cazas. pag. 62
- Mov_caza_hor. pag. 36-38
- Mov_caza_ver. pag. 39-41
- Mensa_ganador. pag. 60
- Menu. pag. 49
- Nuevo_caza. pag. 59
- P_dis_baj. pag. 32-33
- P_dis_der. pag. 29
- P_dis_izq. pag. 28
- P_dis_sub. pag. 30-31
- Presenta. pag. 26
- Rand. pag. 55
- Redefinir. pag. 50
- Redicaza. pag. 34-35
- Redidisp. pag. 27
- Redihalcon. pag. 44-45
- Redi_pant. pag. 61
- Redistar. pag. 57
- Reiniciar. pag. 52
- Res_VI. pag. 24
- Rut_reloj. pag. 19
- Rut_teclado. pag. 20-22
- Test_star. pag. 58
- Un_strobe. (Macro) pag. 11
- Wtoa. pag. 25
2
completar páginas definitivas
completar páginas definitivas
Descargar
| Enviado por: | Eduardo Monteagudo Moreno |
| Idioma: | castellano |
| País: | España |
Todos los derechos reservados.