Juego del 3 en raya escrito en ensamblador MIPS.

###########################################################################
#####                                                                ######
#####                    3 EN RAYA                            ######
#####                                             ######
#####                   ZAIRA PEREZ (SERTONINA)                  ######
#####                                                                ######
#####                   MIGUEL PERIS     (MRCOMPUTER)               ######
#####                                                                ######
###########################################################################

.data
msg_inicio: .asciiz "3 en raya EC"
msg_empate: .asciiz "Empate del juegon"
msg_felicidades: .asciiz "Felicidades, has ganado!!!"
msg_usuario1: .asciiz "Jugador 1, indique una casilla del 1 al 9:"
msg_usuario2: .asciiz "Jugador 2, indique una casilla del 1 al 9:"
msg_jugador1_nombre: .asciiz "Introduzca su nombre, jugador 1: "
msg_jugador2_nombre: .asciiz "Introduzca su nombre, jugador 2: "
fin_juego: .word 0
num_casillas: .word 0
ganador: .word 0
posiciones:
    .word 1 2 3
    .word 4 5 6
    .word 7 8 9
tablero:
    .word 47 47 47
    .word 47 47 47
    .word 47 47 47
jugador1: .space 20
jugador2: .space 20
blanco: .asciiz " "
salto: .asciiz "n"

.text
.globl main
main:

#Imprimimos el mensaje de inicio
la $a0 msg_inicio
li $v0 4
syscall

la $a0 salto
li $v0 4
syscall

# Pedimos el nombre al jugador 1
la $a0 msg_jugador1_nombre
li $v0 4
syscall

#Guardamos el nombre en la etiqueta jugador 1

la $a0 jugador1
li $a1 20
li $v0 8
syscall

# Pedimos el nombre al jugador 2
la $a0 msg_jugador2_nombre
li $v0 4
syscall

#Guardamos el nombre en la etiqueta jugador 2

la $a0 jugador2
li $a1 20
li $v0 8
syscall

#Llamamos a la subrutina imprimir_posiciones para imprimir las posiciones. Para ello cargamos las posiciones en el registro $a0
la $a0 posiciones
jal imprimir_posiciones

#Llamamos a la subrutina imprimir_tablero para imprimir el tablero. Para ello cargamos el tablero en el registro $s0
la $a0 tablero
jal imprimir_tablero

#Mientras el contenido de la etiqueta fin_juego sea igual a 0 se reliza las siguientes operaciones
bucle_main:
lw $s3 fin_juego

beq $s3 1 SALTAMOS

repetir1:

#Imprimimos el mensaje usuario1
la $a0 msg_usuario1
li $v0 4
syscall

#El jugador debe introducir un numero entre el 1 y el 9
li $v0 5
syscall

#Movemos un registro a otro porque es lo que pide la subrutina introducir_casilla
move $a0 $v0

#Como estamos con el jugador 1 introducimos que su ficha de juego es una X (que se correponde a 88)
la $a1 88
#Cargamos las direcciones de memoria del tablero y del numero de casillas
la $a2 tablero
la $a3 num_casillas

#llamamos a la subrutina

jal introducir_casilla

beq $v0 1 repetir1

#Llamamos a la subrutina imprimir_tablero para imprimir el tablero. Para ello cargamos el tablero en el registro $s0
la $a0 tablero
jal imprimir_tablero

#Cargamos en los registros
la $a1 ganador
la $a2 fin_juego
la $a3 tablero

#Metemos en las distintas posiciones de pila lo que recibe la subrutina comprobar_3_en_raya
subu $sp $sp 16

sw $a1 16($sp)
sw $a2 12($sp)
li $t1 88
sw $t1 8($sp)
sw $a3 4($sp)

#Llamamos a la subrutina comprobar_3_en_raya

jal comprobar_3_en_raya

#cargamos lo necesario para la subrutina
la $a0 fin_juego
la $a1 num_casillas
la $a2 ganador

#llamamos a la subrutina
jal comprobar_fin_partida

beqz $v0 SALTAMOS
#hacemos lo mismo para el jugador 2

repetir2:

#Imprimimos el mensaje usuario2
la $a0 msg_usuario2
li $v0 4
syscall

#El jugador debe introducir un numero entre el 1 y el 9
li $v0 5
syscall

#Movemos un registro a otro porque es lo que pide la subrutina introducir_casilla
move $a0 $v0

#Como estamos con el jugador 1 introducimos que su ficha de juego es una O (que se correponde a 79)
la $a1 79
#Cargamos las direcciones de memoria del tablero y del numero de casillas
la $a2 tablero
la $a3 num_casillas

#llamamos a la subrutina

jal introducir_casilla

beq $v0 1 repetir2

#Llamamos a la subrutina imprimir_tablero para imprimir el tablero. Para ello cargamos el tablero en el registro $s0
la $a0 tablero
jal imprimir_tablero

#Cargamos en los registros
la $a1 ganador
la $a2 fin_juego
la $a3 tablero

#Metemos en las distintas posiciones de pila lo que recibe la subrutina compromar_3_en_raya

subu $sp $sp 16
sw $a1 16($sp)
sw $a2 12($sp)
li $t1 79  
sw $t1 8($sp)
sw $a3 4($sp)

#Llamamos a la subrutina comprobar_3_en_raya

jal comprobar_3_en_raya

#cragamos lo necesario para la subrutina
la $a0 fin_juego
la $a1 num_casillas
la $a2 ganador

#llamamos a la subrutina
jal comprobar_fin_partida

beqz $v0 SALTAMOS
j bucle_main
SALTAMOS:

#leemos la etiqueta ganador
lw $t1 ganador
beqz $t1 gandor_jug1
beq $t1 1 gandor_jug2

#Si se queda empate es porque no se han cumplido ninguna de las condiciones anteriores y por tanto

#imprimimos
la $a0 msg_empate
li $v0 4
syscall

j fin_fin_fin

gandor_jug2:
#Si no se cumple la condicion pasa lo siguiente
la $a0 jugador2
la $a1 msg_felicidades
jal concatenar

#imprimimos
move $a0 $v0
li $v0 4
syscall

j fin_fin_fin
gandor_jug1:
la $a0 jugador1
la $a1 msg_felicidades
jal concatenar

#imprimimos
move $a0 $v0
li $v0 4
syscall

fin_fin_fin:

#Fin de programa
li $v0 10
syscall

###############################################################
####### COMIENZO DE LAS FUNCIONES DEL JUEGO 3 EN RAYA #########
###############################################################

# Imprimimos las posiciones
imprimir_posiciones:

         li $t0 0 # contador de columnas
         li $t2 3 # numero de filas
         li $t1 3 # numero de columnas
         li $t8 0 # contador de filas
      move $t4 $a0 #direccion de memoria matriz POSICIONES

         while_filas1: beq $t8 $t2 fin_while1 # bucle que recorre por filas

               while_c1: beq $t0 $t1 fin_c1 # bucle que recorre todas las columnas de una fila

                        #obtener la direccion de posicion
                        mul $t3 $t8 12
                        mul $t5 $t0 4
                        add $t3 $t5 $t3
                        add $t5 $t3 $t4
                        lw  $t6 ($t5)
                        #imprimir numero
                        move $a0 $t6
                        li $v0 1
                        syscall
#                imprimimos el espacio en blanco
              la $a0 blanco
              li $v0 4
              syscall
#                Aumentamos el contador de columnas
                        add $t0 $t0 1
                        b while_c1

#                Si termina el segundo bucle se ejecuta lo siguiente
               fin_c1:  li $t0 0
                       add $t8 $t8 1
             
#                imprimimos el salto

              la $a0 salto
              li $v0 4
              syscall

#                vuelve a iniciarse el bucle

                      b while_filas1
#           Retornamos
    fin_while1:  jr $ra

# Imprimimos el tablero

imprimir_tablero:

         li $t0 0 # contador de columnas
         li $t2 3 # numero de filas
         li $t1 3 # numero de columnas
         li $t8 0 # contador de filas
      move $t4 $a0 #direccion de memoria matriz TABLERO

         while_filas2: beq $t8 $t2 fin_while2 # bucle que recorre por filas

               while_c2: beq $t0 $t1 fin_c2 # bucle que recorre todas las columnas de una fila

                        #obtener la direccion de posicion
                        mul $t3 $t8 12
                        mul $t5 $t0 4
                        add $t3 $t5 $t3
                        add $t5 $t3 $t4
                        lw  $t6 ($t5)
                        #imprimir numero
                        move $a0 $t6
                        li $v0 11
                        syscall
#                imprimimos el espacio en blanco
              la $a0 blanco
              li $v0 4
              syscall
#                Aumentamos el contador de columnas
                        add $t0 $t0 1
                        b while_c2

#                Si termina el segundo bucle se ejecuta lo siguiente
               fin_c2:  li $t0 0
                       add $t8 $t8 1
             
#                imprimimos el salto

              la $a0 salto
              li $v0 4
              syscall

#                vuelve a iniciarse el bucle

                      b while_filas2
#           Retornamos
    fin_while2:  jr $ra

# Introducimos una casilla dentro del tablero, en la posicion que los jugadores deciden
introducir_casilla:

#           Comprobamos si en número que introduce el jugador está entre 1 y 9. Sino, salta a FIN_ERROR
         bgt $a0 9 FIN_ERROR
         blt $a0 1 FIN_ERROR
#           Se realiza la resta en una unidad de la posicion introducida por el jugador, y posteriormente
#           Se multiplica un 4 para obtener la dirección de memoria necesaria.
         sub $t1 $a0 1
         mul $t1 $t1 4
#           Sumamos el valor del registro t1 a la direccion de memoria de la matriz del tablero, que está en $a2
         add $t1 $t1 $a2
#           Cogemos el contenido de la dirección de memoria de $t1
         lw $t2 ($t1)
#           Se comprueba si el contenido de esa posición es igual al valor "/"
#           Si no es igual, salta a la etiqueta FIN_ERROR
         bne $t2 47 FIN_ERROR
#           Como se ha cumplido la condicion anterior, se introduce la ficha del jugador
#           En la posición de memoria anterior que está en $t1
         sw $a1 ($t1)
#           Se incrementa el contenido del número de casillas
         lw $t3 ($a3)
         add $t3 $t3 1
         sw $t3 ($a3)
#           Establecemos a 0 el valor del registro $v0
         li $v0 0
#           Se termina la subrutina
         jr $ra
# Si no se cumple alguna de las condiciones anteriores, se produce un error y salta a la siguiente etiqueta
# Poniéndose el registro $v0 a 1
FIN_ERROR:
         li $v0 1
         jr $ra

#Subrutina que se encarga de comprobar si hay 3 fichas alineadas

comprobar_3_en_raya:
         #Sacamos de pila las siguientes informaciones, guardandolas en distintos registros
         #Sacamos de pila la dirección del tablero que esta en la primera posicion de la pila

          lw $a0 4($sp)

             
          #Sacamos de la segunda posicion de pila la ficha del jugador
          lw $a2 8($sp)
         
          #Sacamos de la tercera posicion de pila la etiqueta fin_juego
          lw $a3 12($sp)
         
          #Sacamos de la cuarta posicion de pila el ganador
          lw $t7 16($sp)
          addu $sp $sp 16

#Comprobamos por FILAS

         #Creamos un registro contador que contará el número de fichas que hay alineadas
         li $s0 0
         # contador de columnas
              li $t0 0
         # numero de filas
              li $t2 3
         # numero de columnas      
              li $t1 3
          # contador de filas
              li $t8 0

         whileFILAScomprobar: beq $t8 $t2 siguiente01 # bucle que recorre por filas

               whileCOLUMNAScomprobar: beq $t0 $t1 finCOLUMNAScomprobar # bucle que recorre todas las columnas de una fila

                        #obtener la direccion de posicion
                        # ($t8 *12)+($t0*4)
                        mul $t3 $t8 12
                        mul $t5 $t0 4
                        add $t3 $t5 $t3
                        add $t5 $t3 $a0
                        lw  $t6 ($t5)

              #Condicional que comprueba si lo leido ($t6) se corresponde con la casilla del jugador
              beq $t6 $a2 PUSHPOP1

              salto_pushpop1:
              #Incrementamos el contador de las columnas
              add $t0 $t0 1
                        b whileCOLUMNAScomprobar

               finCOLUMNAScomprobar:
              # Ponemos el contador de columnas a 0 para que siga recorriendo desde el principio
              li $t0 0
                       #Incrementamos el contador de las filas
                       add $t8 $t8 1
              #Condicional que comprueba si hay 3 fichas iguales
                     beq $s0  3 FINAL_COMPROBAR_3_EN_RAYA
              #Si no se cumple la condicion anterior $s0 será 0
              li $s0 0

                      b whileFILAScomprobar

         PUSHPOP1:
              #Metemos en la segunda posicion de pila el $ra
               subu $sp $sp 8
               sw $ra 8($sp)
               #Metemos en la primera posicion de pila el registro contador $s0
               sw $s0 4($sp)
               #Guardamos el registro $t2 t $t1 en unos registros temporales
              move $s5 $t2
              move $s2 $t1

              #Llamamos a la etiqueta sumar_casillas
              jal sumar_casillas

               #Sacamos de la primera posicion de pila el resgistro contador y lo guardamos de nuevo en $s0
               lw $s0 4($sp)
               #Sacamos de la segunda posicion de pila el $ra guardandolo en ese registro
               lw $ra 8($sp)
               addu $sp $sp 8

              #Sacamos de los registros temporales los registros $t2 y $t1
              move $t2 $s5
              move $t1 $s2
              #Saltamos a donde estabamos antes
              b salto_pushpop1

#Comprobamos por COLUMNAS

         siguiente01:

          li $s0 0
           # contador de columnas
                li $t0 0
           # numero de filas
                li $t2 3
           # numero de columnas      
                li $t1 3
            # contador de filas
                li $t8 0

                     whileFILAScomprobar2: beq $t8 $t2 siguiente02 # bucle que recorre por filas
 
                 whileCOLUMNAScomprobar2: beq $t0 $t1 finCOLUMNAScomprobar2 # bucle que recorre todas las columnas de una fila
 
                          #obtener la direccion de posicion
                          # ($t0 *12)+($t8*4)
                          mul $t3 $t0 12
                          mul $t5 $t8 4
                          add $t3 $t5 $t3
                          add $t5 $t3 $a0  
                          lw  $t6 ($t5)
 
                #Condicional que comprueba si lo leido ($t6) se corresponde con la casilla del jugador
                beq $t6 $a2 PUSHPOP2
 
                salto_pushpop2:
               #Incrementamos el contador de las columnas
                add $t0 $t0 1
                          b whileCOLUMNAScomprobar2
 
 
                 finCOLUMNAScomprobar2:  li $t0 0
                         #Incrementamos el contador de las filas
                         add $t8 $t8 1
                #Condicional que comprueba si hay 3 fichas iguales
                beq $s0  3 FINAL_COMPROBAR_3_EN_RAYA
                #Si no se cumple la condicion anterior $s0 será 0
                li $s0 0
 
                        b whileFILAScomprobar2
 
           PUSHPOP2:
              #Metemos en la segunda posicion de pila el $ra
               subu $sp $sp 8
               sw $ra 8($sp)
               #Metemos en la primera posicion de pila el registro contador $s0
               sw $s0 4($sp)
               #Guardamos el registro $t2 t $t1 en unos registros temporales
              move $s5 $t2
              move $s2 $t1

              #Llamamos a la etiqueta sumar_casillas
              jal sumar_casillas

               #Sacamos de la primera posicion de pila el resgistro contador y lo guardamos de nuevo en $s0
               lw $s0 4($sp)
               #Sacamos de la segunda posicion de pila el $ra guardandolo en ese registro
               lw $ra 8($sp)
               addu $sp $sp 8

              #Sacamos de los registros temporales los registros $t2 y $t1
              move $t2 $s5
              move $t1 $s2

              #Saltamos a donde estabamos antes

                b salto_pushpop2
 
 
 
 #Comprobamos por DIAGONAL IZQUIERDA
 siguiente02:
 
 
           li $s0 0
 
           # numero de filas
                li $t2 3
            # contador de filas
                li $t8 0
 
 
                    whileFILAScomprobar3: beq $t8 $t2 siguiente03 # bucle que recorre por filas
 
                # whileCOLUMNAScomprobar3: beq $t0 $t1 finCOLUMNAScomprobar3 # bucle que recorre todas las columnas de una ila
 
                          #obtener la direccion de posicion
                          # ($t8 *12)+($t8*4)
                          mul $t3 $t8 12
                          mul $t5 $t8 4
                          add $t3 $t5 $t3
                          add $t5 $t3 $a0  
                          lw  $t6 ($t5)
 
                #Condicional que comprueba si lo leido ($t6) se corresponde con la casilla del jugador
                beq $t6 $a2 PUSHPOP3
 salto_pushpop3:
     
                        #Incrementamos el contador de las filas
                         add $t8 $t8 1
                #Condicional que comprueba si hay 3 fichas iguales
                beq $s0  3 FINAL_COMPROBAR_3_EN_RAYA
 
               
 
                        b whileFILAScomprobar3
 
           PUSHPOP3:
                     #Metemos en la segunda posicion de pila el $ra
               subu $sp $sp 8
               sw $ra 8($sp)
               #Metemos en la primera posicion de pila el registro contador $s0
               sw $s0 4($sp)
               #Guardamos el registro $t2 t $t1 en unos registros temporales
              move $s5 $t2
              move $s2 $t1

              #Llamamos a la etiqueta sumar_casillas
              jal sumar_casillas

               #Sacamos de la primera posicion de pila el resgistro contador y lo guardamos de nuevo en $s0
               lw $s0 4($sp)
               #Sacamos de la segunda posicion de pila el $ra guardandolo en ese registro
               lw $ra 8($sp)
               addu $sp $sp 8

              #Sacamos de los registros temporales los registros $t2 y $t1
              move $t2 $s5
              move $t1 $s2

              #Saltamos a donde estabamos antes
         b salto_pushpop3
 
 #Comprobamos por DIAGONAL DERECHA
 siguiente03:
           #Creamos un registro contador que contará el número de fichas que hay alineadas
           li $s0 0
           # contador de columnas
                li $t0 4
    
      
                li $t1 1
            # contador de filas
                li $t8 0
 
 
                    
 
                 whileCOLUMNAScomprobar4: beq $t0 $t1 siguiente04 # bucle que recorre todas las columnas de una fila
 
                          #obtener la direccion de posicion
                          # ($t8 *10)+($t0*4)
                          mul $t3 $t8 10
                          mul $t5 $t0 2
                          add $t3 $t5 $t3
                          add $t5 $t3 $a0  
                          lw  $t6 ($t5)
 
                #Condicional que comprueba si lo leido ($t6) se corresponde con la casilla del jugador
                beq $t6 $a2 PUSHPOP4
 
                salto_pushpop4:
                #Incrementamos el contador de las columnas
                sub $t0 $t0 1
                       
 
 
                 finCOLUMNAScomprobar4:  
                         #Incrementamos el contador de las filas
                         add $t8 $t8 1
                #Condicional que comprueba si hay 3 fichas iguales
                beq $s0  3 FINAL_COMPROBAR_3_EN_RAYA
                #Si no se cumple la condicion anterior $s0 será 0
                
 
                        b whileCOLUMNAScomprobar4

           PUSHPOP4:
      #Metemos en la segunda posicion de pila el $ra
               subu $sp $sp 8
               sw $ra 8($sp)
               #Metemos en la primera posicion de pila el registro contador $s0
               sw $s0 4($sp)
               #Guardamos el registro $t2 t $t1 en unos registros temporales
              move $s5 $t0
              move $s2 $t1

              #Llamamos a la etiqueta sumar_casillas
              jal sumar_casillas

               #Sacamos de la primera posicion de pila el resgistro contador y lo guardamos de nuevo en $s0
               lw $s0 4($sp)
               #Sacamos de la segunda posicion de pila el $ra guardandolo en ese registro
               lw $ra 8($sp)
               addu $sp $sp 8

              #Sacamos de los registros temporales los registros $t2 y $t1
              move $t0 $s5
              move $t1 $s2

              #Saltamos a donde estabamos antes
                b salto_pushpop4
 
 siguiente04:
    jr $ra

FINAL_COMPROBAR_3_EN_RAYA:

#Siempre se pone el registro $t6 a 1
    li $t6 1
    sw $t6 ($a3)
   

#Comprobamos a que jugador corresponde la ficha y por tanto cual es el ganador

    beq $a2 88 ganador_jugador_1
   
#Si no se cumple la condicion anterior, entonces

    li $t4 1
    sw $t4 ($t7)
    jr $ra

ganador_jugador_1:

li $t4 0
    sw $t4 ($t7)
#Fin de de la subrutina
jr $ra

#Subrutina que se encarga de aumentar en uno el contador
sumar_casillas:
         #Sacamos de pila el valor del contador inicial
         lw $s6 4($sp)
         addu $sp $sp 4

         #Aumentamos el contador
         add $s6 $s6 1

         #Metemos el contador modificado a pila
         subu $sp $sp 4
         sw $s6 4($sp)

comprobar_fin_partida:
         #Sacamos el contenido de dos de los operandos
         lw $t1 ($a0)    
           
         lw $t2 ($a1)
         #Si el contenido de la etiqueta fin_juego es 1, saltamos a la etiqueta reg1
         beq $t1 1 reg1
         #Si el contenido de la etiqueta num_casillas es 9 saltamos a la etiqueta reg2
         beq $t2 9 reg2
         #Si no se cumple ninguna de las dos condiciones anteriores ponemos el registro
         #v0 en 1 direcamente
         li $v0 1
         jr $ra

#Primera etiqueta
reg1:

li $v0 0
jr $ra

#Segunda etiqueta
reg2:
    #Cargamos los valores inmediatos y los introducis en los operandos
    li $s0 3
    sw $s0 ($a2)
    li $s0 1
    sw $s0 ($a0)
    li $v0 0
    jr $ra

concatenar:

#movemos el contenido de $a0 y $a1 a losregistros $t1 y $ t0

move $t1 $a0
move $t2 $a1

#reservamos la memoria dinamicamente
li $a0 100
li $v0 9
syscall

move $t6 $v0

#hacemos dos bucles para concatenar las dos cadenas

bucle_cad1:
lb $t5 ($t1)
beqz $t5 bucle_cad2
sb $t5 ($t6)
add $t1 $t1 1
add $t6 $t6 1
b bucle_cad1

bucle_cad2:
lb $t5 ($t2)
beqz $t5 fin
sb $t5 ($t6)
add $t2 $t2 1
add $t6 $t6 1
b bucle_cad2

#Saltamos a fin si las cadenas han terminado
fin:
#Introducimos el salto de linea al final de la ultima cadena concatenada
lb $s1 salto
sb $s1 ($t6)
#fin de la subrutina
jr $ra

##########
#   EOF  #
##########

Fuente: autor: mrcomputer & sertonina	Visitas: 984
Idioma: Castellano	Puntuación: 5.00 (2 votos) 1 2 3 4 5 6 7 8 9 10
Comentarios: 0