.model small
.data

    ; David Alvarez López  -  sly.dekar@gmail.com
    ; 06-Nov-2005

    pool db "PALOMA           ",0Ah,0Dh,"$"
         db "ILUSION          ",0Ah,0Dh,"$"
         db "ESTRELLA         ",0Ah,0Dh,"$"
         db "ESPERANZA        ",0Ah,0Dh,"$"
         db "CARRETERAS       ",0Ah,0Dh,"$"
		 db "AUDIFONO         ",0Ah,0Dh,"$"
         db "APOPLEJIA        ",0Ah,0Dh,"$"
         db "ACUPUNTURA       ",0Ah,0Dh,"$"
         db "TODOPODEROSO     ",0Ah,0Dh,"$"
         db "COMPUTARIZADO    ",0Ah,0Dh,"$"
		 db "ESPELUZNANTE     ",0Ah,0Dh,"$"
         db "DESLUMBRANTE     ",0Ah,0Dh,"$"
         db "NEUROCIRUJANOS   ",0Ah,0Dh,"$"
         db "GRAMATICALMENTE  ",0Ah,0Dh,"$"
         db "ACONDICIONAMIENTO",0Ah,0Dh,"$"
    palabra db 17 dup(' '),'$'
    tunombre db "Escribe tu nombre por favor: $"
	snivel db "Por favor, selecciona tu nivel     [   ]",0Ah,0Dh
		   db "          1. Facil",0Ah,0Dh
		   db "          2. Normal",0Ah,0Dh
		   db "          3. Dificil$"
	nivel db ?
	casilla db "[   ]$"
	ganado db "FELICIDADES!!! GANASTE!!!$"
	perdido db "LASTIMA... PERDISTE!!$"
	reiniciar db "Deseas Jugar Otra Vez?   ( Si = 1 / No = 0 ): $"
	intentos db "# de intentos: $"
	nIntentos db ?,'$'
	horca db "________________",0Ah,0Dh
		  db "     |               |",0Ah,0Dh
		  db "     |",0Ah,0Dh
		  db "     |",0Ah,0Dh
		  db "     |",0Ah,0Dh
		  db "     |",0Ah,0Dh
		  db "     |____",0Ah,0Dh,'$'
	sJugador db 0Ah,0Dh,"Nombre del jugador: $"
	sJuegos db 0Ah,0Dh,"Juegos jugados: $"
	sPerdidos db 0Ah,0Dh,"Juegos perdidos: $"
	prepare db 0Ah,0Dh,"          $"
	guion db "_ $"
	bandera dw 0h
	buenas dw 0h
	quant dw 0h
	malas dw 0d
	nJuegos db 48d,'$'
	nPerdidos db 48d,'$'
	
	dibujo_cara db "O$"
	dibujo_cuerpo db "|$"
	dibujo_piD db "\$"
	dibujo_piI db "/$"
	dibujo_brazo db "--$"
	sunombre db 20,?,20 dup(0)

.code

	clrscr proc
        mov ah,6
        mov al,00h
        mov cx,0
        mov dx,184Fh
        mov bh,07
        int 10h
        ret
    clrscr endp

	dibuja_horca proc
		mov ah,2
        mov bh,0    ;pagina 0
        mov dh,2    ;renglon
        mov dl,5	;columna
        int 10h
        
        mov ah,9
        mov dx,offset horca
        int 21h
        
        ret
	dibuja_horca endp
	
		;incrementa 'malas', despliega una parte del mono dependiendo de la cantidad de malas
	tecla_equivocada proc
		inc malas
		
		cmp malas,1d
		je dibuja_cara
		cmp malas,2d
		je dibuja_cuerpo
		cmp malas,3d
		je dibuja_piD
		cmp malas,4d
		je dibuja_piI
		cmp malas,5d
		je dibuja_brD
		cmp malas,6d
		je dibuja_brI
	
		dibuja_cara:
			mov ah,2
			mov bh,0    ;pagina 0
			mov dh,4    ;renglon
			mov dl,21	;columna
			mov cx,0
			int 10h
			
			mov ah,9
			mov dx,offset dibujo_cara
			int 21h
			ret
			
		dibuja_cuerpo:
			mov ah,2
			mov bh,0    ;pagina 0
			mov dh,5    ;renglon
			mov dl,21	;columna
			mov cx,0
			int 10h
			
			mov ah,9
			mov dx,offset dibujo_cuerpo
			int 21h
			ret
			
		dibuja_piD:
			mov ah,2
			mov bh,0    ;pagina 0
			mov dh,6    ;renglon
			mov dl,22	;columna
			mov cx,0
			int 10h
			
			mov ah,9
			mov dx,offset dibujo_piD
			int 21h
			ret
			
		dibuja_piI:
			mov ah,2
			mov bh,0    ;pagina 0
			mov dh,6    ;renglon
			mov dl,20	;columna
			mov cx,0
			int 10h
			
			mov ah,9
			mov dx,offset dibujo_piI
			int 21h
			ret
			
		dibuja_brI:
			mov ah,2
			mov bh,0    ;pagina 0
			mov dh,5    ;renglon
			mov dl,19	;columna
			mov cx,0
			int 10h
			
			mov ah,9
			mov dx,offset dibujo_brazo
			int 21h
			ret
			
		dibuja_brD:
			mov ah,2
			mov bh,0    ;pagina 0
			mov dh,5    ;renglon
			mov dl,22	;columna
			mov cx,0
			int 10h
			
			mov ah,9
			mov dx,offset dibujo_brazo
			int 21h
			ret
	tecla_equivocada endp
	
	final_display proc
		;Nombre del jugador.
		mov ah,9
		mov dx,offset sJugador
		int 21h
		mov bl,sunombre+1
        mov bh,0
        mov [sunombre+2+bx],'$'
		mov ah,9
        mov dx, offset sunombre+2
        int 21h
		;Número de palabras (cuántas veces jugó al Ahorcado).
		mov ah,9
		mov dx,offset sJuegos
		int 21h
		mov ah,9
        mov dx,offset nJuegos
        int 21h
		;Número de fracasos (cuántas veces se “ahorcó” el jugador).
		mov ah,9
		mov dx,offset sPerdidos
		int 21h
		mov ah,9
        mov dx,offset nPerdidos
        int 21h
        ret
	final_display endp



	inicio proc
	
		mov ax,@data
		mov ds,ax
	
		call clrscr
		
		;se pide el nombre
		mov ah,9
        mov dx,offset tunombre
        int 21h
		;se captura el nombre
		mov ah,0ah
        mov dx,offset sunombre
        int 21h
		
		;al volver a jugar, lo hace con una palabra distinta esta vez
		
		;un juego nuevo
	gamer:
		call clrscr
		
		call dibuja_horca

		mov ah,2
        mov bh,0    ;pagina 0
        mov dh,11   ;renglon
        mov dl,10   ;columna
        int 10h
		;despliega la seleccion de nivel
        mov ah,9
        mov dx,offset snivel
        int 21h
        
        mov ah,2
        mov bh,0    ;pagina 0
        mov dh,11   ;renglon
        mov dl,47   ;columna
        int 10h
		;captura el nivel
        mov ah,0
        int 16h
        ;despliega el nivel
        mov ah,2
        mov dl,al
        int 21h
        
        sub al,49
        ;al tiene el valor numerico nivel
        
        ;multiplicamos al (level)por 5*20
        mov dl,100
        mul dl
        ;al tiene el desvio entre niveles
        mov ah,0
        mov bp,ax
        ;bp tiene el desvio entre niveles
        
        ;interrupcion para generar el random
        mov ah,2ch
        int 21h
        ;DL = x/100 seconds
        ;se divide DL entre cinco para obtener el residuo 0-4
        mov ax,dx
        mov dx,0h
        mov bX,5h
        div bX
        mov dh,0
        ;dl tiene un valor entre 0 y 4
        
        ;multiplicamos dl por 20
        mov al,20d
        mul dl
        ;al tiene un valor entre 0..4 * 20
        
        mov ah,0
        mov si,ax
        ;si tiene n*20
        
        mov cx,offset pool
        add si,cx
        add si,bp
        ;si tiene el offset de la palabra de la palabra que vamos a usar
		
		;pone en blanco las variables necesarias en cada juego
		mov nIntentos,47d
		and malas,0
		and quant,0
		and buenas,0
		mov bx,offset palabra
	borra_palabra:
		mov byte ptr [bx],' '
		inc bx
		cmp byte ptr [bx],' '
		jne borra_palabra
		
		;copia en 'palabra' la que vamos a usar, recordar que SI tiene el offset de la palabra que vamos a usar
		mov bx,offset palabra
	ciclo_copia_string:
		mov al,[si]
		mov [bx],al
		inc bx
		inc si
		inc quant
		cmp byte ptr [si],' '
		jne ciclo_copia_string
	
        ;posiciona el cursor
        mov ah,2
        mov bh,0    ;pagina 0
        mov dh,18   ;renglon
        mov dl,18   ;columna
        int 10h
		
        ;pone un guion bajo por cada letra de la palabra
        mov si, offset [palabra]
	ciclo_guiones:
		mov ah,9
		mov dx,offset guion
		int 21h
		inc si
		cmp byte ptr [si],' '
		jne ciclo_guiones
		
		;dibuja la casilla donde recibira la letra
		mov ah,2
        mov bh,0    ;pagina 0
        mov dh,18   ;renglon
        mov dl,45   ;columna
        int 10h
		
		mov ah,9
		mov dx,offset casilla
		int 21h
		
	;let the games begin!
	jugada:
		inc nIntentos
		
		;despliega los intentos que van
		mov ah,2
        mov bh,0    ;pagina 0
        mov dh,5    ;renglon
        mov dl,55   ;columna
        int 10h
		
		mov ah,9
		mov dx,offset intentos
		int 21h
		
		mov ah,9
		mov dx,offset nIntentos
		int 21h
	
		and bandera,0d
		mov ch,18d
	
		;recibe una letra
		mov ah,0
        int 16h

		mov cl,al
		
		mov ah,2
        mov bh,0    ;pagina 0
        mov dh,18   ;renglon
        mov dl,ch	;columna
        int 10h
        
		mov si,offset [palabra]
		;recorre el arreglo buscando la letra
	ciclo_letra:
		;compara la letra: si no coincide, brinca para no borrar el guion
		cmp byte ptr [si],cl
		jne buffer_space
		;Si coincide, la despliega. Incrementa 'banderas'. Borra esas repeticiones en el arreglo para evitar que se vuelvan a contar.
		mov ah,2
		mov dl,[si]
		int 21h
			mov ah,2
			mov dl,' '
			int 21h
			inc ch
			inc ch
		inc bandera
		and byte ptr [si],0d
		jmp continua
		
		;mueve la posicion del cursor
	buffer_space:
		mov ah,2
        mov bh,0    ;pagina 0
        mov dh,18   ;renglon
        inc ch
        inc ch
        mov dl,ch	;columna
        int 10h
		
	continua:
		inc si
		cmp byte ptr [si],' '
		jne ciclo_letra
		
		;compara si se encontro la letra o no
		cmp bandera,0d
		jne encontrada
		;despliega la letra equivocada
		mov ah,2
        mov bh,0    ;pagina 0
        mov dh,18   ;renglon
        mov dl,47	;columna
        int 10h
		
		mov ah,2
		mov dl,cl
		int 21h
		
		;maneja los procedimientos de 'letra no encontrada'
		call tecla_equivocada
		;revisa que sea menor a 6 para detener o continuar el juego
		cmp malas,6d
		je perdio
		jmp jugada
		
	encontrada:
		;le suma la cantidad de banderas encontradas a buenas
		mov cx,bandera
		add buenas,cx
		;revisa que 'buenas' sea menor a la cantidad de letras, para seguir recibiendo letras
		mov cx,buenas
		cmp cx,quant
		jb jmp_jugada
		;el juego termina pues el usuario ganó
		inc nJuegos
		
		mov ah,2
        mov bh,0    ;pagina 0
        mov dh,20   ;renglon
        mov dl,30	;columna
        int 10h
		
		mov ah,9
        mov dx,offset ganado
        int 21h
        
        mov ah,0
        int 16h
        jmp finito
        
    perdio:        
        ;le avisa al usuario que perdió
        inc nJuegos
        inc nPerdidos
        mov ah,2
        mov bh,0    ;pagina 0
        mov dh,20   ;renglon
        mov dl,30	;columna
        int 10h
        
		mov ah,9
        mov dx,offset perdido
        int 21h
        
        mov ah,0
        int 16h
        
    finito:
		call clrscr
		;pregunta si el usuario quiere jugar de nuevo
		mov ah,2
        mov bh,0    ;pagina 0
        mov dh,22   ;renglon
        mov dl,10   ;columna
        int 10h
		
		mov ah,9
        mov dx,offset reiniciar
        int 21h
        
        mov ah,0
        int 16h
        
        cmp al,'1'        
        je play_again
		
		;el usuario no quiere jugar de nuevo
		call clrscr
		call final_display
		
		;termina el programa
		mov ah,04ch
		mov al,00h
		int 21h
	
	play_again:
		jmp gamer
		
	jmp_jugada:
		jmp jugada
	
	inicio endp

end inicio