Ensamblador

Arquitectura de Computadores. Rutinas de Servicio. Interrupciones. Macros. EQU's. Funciones y Procedimientos

  • Enviado por: Eduardo Monteagudo Moreno
  • Idioma: castellano
  • País: España España
  • 64 páginas

publicidad
cursos destacados
Objective-C para verdaderos principiantes
Objective-C para verdaderos principiantes
Objective-C es el pilar correcto para desarrollar aplicaciones para iPhones y iPads. Podrás probar paquetitos y...
Ver más información

Diseña tu proyecto web con Bootstrap
Diseña tu proyecto web con Bootstrap
Creación de páginas web totalmente con diseño responsive, potente diseño adaptable a cualquier dispositivo, de una...
Ver más información


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&cent;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&pound;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