SHARE
TWEET

Untitled

a guest Jan 9th, 2020 80 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. @;=                                                                     =
  2. @;=== candy1_init.s: rutinas para inicializar la matriz de juego      ===
  3. @;=                                                                     =
  4. @;=== Programador tarea 1A: ernest.tomas@estudiants.urv.cat               ===
  5. @;=== Programador tarea 1B: yyy.yyy@estudiants.urv.cat                ===
  6. @;=                                                                     =
  7.  
  8.  
  9.  
  10. .include "../include/candy1_incl.i"
  11.  
  12.  
  13.  
  14. @;-- .bss. variables (globales) no inicializadas ---
  15. .bss
  16.         .align 2
  17. @; matrices de recombinación: matrices de soporte para generar una nueva matriz
  18. @;  de juego recombinando los elementos de la matriz original.
  19.     mat_recomb1:    .space ROWS*COLUMNS
  20.     mat_recomb2:    .space ROWS*COLUMNS
  21.  
  22.  
  23.  
  24. @;-- .text. código de las rutinas ---
  25. .text  
  26.         .align 2
  27.         .arm
  28.        
  29.  
  30.  
  31. @;TAREA 1A; 09/01/2020 CORRETGIDA
  32. @; inicializa_matriz(*matriz, num_mapa): rutina para inicializar la matriz de
  33. @;  juego, primero cargando el mapa de configuración indicado por parámetro (a
  34. @;  obtener de la variable global 'mapas'), y después cargando las posiciones
  35. @;  libres (valor 0) o las posiciones de gelatina (valores 8 o 16) con valores
  36. @;  aleatorios entre 1 y 6 (+8 o +16, para gelatinas)
  37. @;  Restricciones:
  38. @;      * para obtener elementos de forma aleatoria se invocará la rutina
  39. @;          'mod_random'
  40. @;      * para evitar generar secuencias se invocará la rutina
  41. @;          'cuenta_repeticiones' (ver fichero "candy1_move.s")
  42. @;  Parámetros:
  43. @;      R0 = dirección base de la matriz de juego
  44. @;      R1 = número de mapa de configuración
  45. @;  RUTINA CUENTA REPETICIONES:
  46. @;      R0 = direcci�n base de la matriz
  47. @;      R1 = fila 'f'
  48. @;      R2 = columna 'c'
  49. @;      R3 = orientaci�n 'ori' (0 -> Este, 1 -> Sur, 2 -> Oeste, 3 -> Norte)
  50. @;  Resultado:
  51. @;      R0 = n�mero de repeticiones detectadas (m�nimo 1)
  52.     .global inicializa_matriz
  53. inicializa_matriz:
  54.         push {r0-r10, lr}               @;guardar registros utilizados
  55.             mov r3, #0                  @;filas=0
  56.             mov r10, r0                 @;r10 = direccio memoria matriu joc
  57.                 .Lfor0:
  58.                     cmp r3, #ROWS
  59.                     beq .Lfi
  60.             mov r4, #0                  @;columna=0
  61.                 .Lfor1:
  62.                     ldr r2, =mapas      @;direccio memoria mapa 2
  63.                     cmp r4, #COLUMNS    @;r4 = columnas?
  64.                     beq .Lfinal2        @;si r4 = cols salta
  65.                     mov r5, #COLUMNS    @;r5 = columnas
  66.                     mul r6, r5, r3      @;r6 = (columnas * fila)
  67.                     add r6, r6, r4      @;r6 = (columnas * fila) + columna -> posició indexada
  68.                     mov r7, #ROWS       @;r7 = filas
  69.                     mul r8, r5, r7      @;r8 = filas * columnas = 81
  70.                     mul r5, r8, r1      @;r5 = (filas * columnas) * num. mapa
  71.                     add r5, r5, r6      @;r5 = ((filas * columnas) * num mapa) + posicio indexada (f,c)
  72.                     add r2, r2, r5      @;r2 = pos. memoria de mapas + ((filas * columnas) * num mapa) + posicio indexada (f,c)
  73.                     add r0, r0, r6      @;r0 = matriu_joc[f][c]
  74.                     ldrb r7, [r2]       @;r7 = valor que conte la matriu mapas(f,c)
  75.                     cmp r7, #0          @;r7 = 0?
  76.                     bne .Lprox0:       
  77.                 .Lprox0:
  78.                     cmp r7, #8          @;r7 = 8?
  79.                     bne .Lprox1:
  80.                 .Lprox1:
  81.                     cmp r7, #16         @;r7 = 16?
  82.                     bne .Lprox2:
  83.                 .Lvaloraleatori:
  84.                     push {r0}
  85.                         mov r0, #6      @;r0=6
  86.                         bl mod_random   @;valor aleatori (0...5)
  87.                         add r0, r0, #1  @;valor aleatori + 1
  88.                         mov r8, r0      @;r8=valor aleatori
  89.                         add r8, r8, r7  @;r8=valor aleatori + valor que conte matriu_mapes (0, 8 o 16)
  90.                     pop {r0}
  91.                     strb r8, [r0]       @;guardem el valor aleatori+ suma a matriu_joc[f][c]
  92.                     b .Lrepeticions
  93.                 .Lprox2:                @;al arribar aqui ja sabem que no es ni 0 ni 8 ni 16 per tant guardem el valor directament a la matriu joc
  94.                     strb r7, [r0]       @;guardem a matriu_joc[f][c] el valor de r7
  95.                 .Lrepeticions:
  96.                     push {r0,r1,r2,r3}
  97.                         mov r0, r10     @;direccio base matriu_joc
  98.                         mov r1, r3      @;r1=fila
  99.                         mov r2, r4      @;r2=columna
  100.                         mov r3, #3      @;r3=0 -> orientacio nord
  101.                         bl cuenta_repeticiones
  102.                         cmp r0, #1      @;reps. = 1?
  103.                     pop {r0,r1,r2,r3}
  104.                         bne .Lvaloraleatori
  105.                 .Lrepeticions2:
  106.                     push {r0,r1,r2,r3}
  107.                         mov r0, r10     @;direccio base matriu_joc
  108.                         mov r1, r3      @;r1=fila
  109.                         mov r2, r4      @;r2=columna
  110.                         mov r3, #0      @;r3=0 -> orientacio est
  111.                         bl cuenta_repeticiones
  112.                         cmp r0, #1      @;reps = 1?
  113.                     pop {r0,r1,r2,r3}
  114.                     bne .Lvaloraleatori
  115.                     b .Lfinal1
  116.                 .Lfinal1:
  117.                     add r4, #1          @;incrementem en 1 la columna
  118.                     b .Lfor1
  119.                 .Lfinal2:
  120.                     add r3, #1          @;incrementem en 1 la fila
  121.                     b .Lfor0   
  122.                 .Lfi:                   @;el bucle acaba
  123.                    
  124.         pop {r0-r10, pc}            @;recuperar registros y volver
  125.  
  126.  
  127.  
  128. @;TAREA 1B;
  129. @; recombina_elementos(*matriz): rutina para generar una nueva matriz de juego
  130. @;  mediante la reubicación de los elementos de la matriz original, para crear
  131. @;  nuevas jugadas.
  132. @;  Inicialmente se copiará la matriz original en 'mat_recomb1', para luego ir
  133. @;  escogiendo elementos de forma aleatoria y colocandolos en 'mat_recomb2',
  134. @;  conservando las marcas de gelatina.
  135. @;  Restricciones:
  136. @;      * para obtener elementos de forma aleatoria se invocará la rutina
  137. @;          'mod_random'
  138. @;      * para evitar generar secuencias se invocará la rutina
  139. @;          'cuenta_repeticiones' (ver fichero "candy1_move.s")
  140. @;      * para determinar si existen combinaciones en la nueva matriz, se
  141. @;          invocará la rutina 'hay_combinacion' (ver fichero "candy1_comb.s")
  142. @;      * se supondrá que siempre existirá una recombinación sin secuencias y
  143. @;          con combinaciones
  144. @;  Parámetros:
  145. @;      R0 = dirección base de la matriz de juego
  146.  
  147.     .global recombina_elementos
  148. recombina_elementos:
  149.     push {r0-r12, lr}
  150.         ldr r1, =mat_recomb1 @; R0: MAT_RECOMB1 Direccio memoria
  151.         ldr r2, =mat_recomb2 @; r1: MAT_RECOMB2 direccio memoria
  152.            
  153.         mov r3, #0
  154.             .Lfor0:
  155.                 cmp r3, #ROWS   @;r3 = ROWS ?
  156.                 beq .Lendfor0   @;Si r3 = rows saltem
  157.         mov r4, #0
  158.             .Lfor1:
  159.                 mov r12, #0         @;r12 = 0 -> vol dir que no ha fet mat_recomb2[i][j]
  160.                 cmp r4, #COLUMNS    @;r4 = columns?
  161.                 beq .Lendfor1       @;si r4 = columns saltem
  162.                 mov r5, #COLUMNS    @;r5 = columns
  163.                 mul r6, r5, r3      @;r6 = columna * r3
  164.                 add r6, r6, r4      @;r6 = (columna * r3)  + r4
  165.                 add r9, r6, r2      @;r9 = r6 + r2 -> r2 = direccio memoria mat_recomb2
  166.                 add r7, r6, r1      @;r7 = r6 + r1 -> direccio posicio memoria mat_recomb1
  167.                 add r8, r6, r0      @;r8 = r6 + r0 es la direccio de matriu joc
  168.                 ldrb r10, [r8]      @;r10 = valor de matriu_joc[i][j]
  169.                 strb r10, [r7]      @;Guardem a mat_recomb1 = matriu_joc[i][j]
  170.                 cmp r10, #7         @;Comparem r10 = 7?
  171.                 bne .Lnext0         @;Si no igual salta
  172.                 push {r10}
  173.                 mov r10, #0         @;r10 = 0
  174.                 strb r10, [r7]      @;Guardem mat_recomb1[i][j] = 0
  175.                 pop {r10}           @;recuperm valor r10
  176.                 b .Lnext1
  177.             .Lnext0:
  178.                 cmp r10, #15        @;comparem r10, 15
  179.                 bne .Lnnext1
  180.                 push {r10}          @;recuperem valor r10
  181.                 mov r10, #0         @; r10 = 0
  182.                 strb r10, [r7]      @; Guardem un 0
  183.                 pop {r10}
  184.             .Lnnext1:
  185.                 cmp r10, #9         @;comparem r10, amb 9
  186.                 blo .Lnnext2
  187.                 cmp r10, #14
  188.                 bhi .Lnnext2            @;matriu[i][j] >=9 && matriu[i][j] <= 14
  189.                 push {r10}
  190.                 mov r11, #8
  191.                 strb r11, [r9]      @;Guardem a mat_recomb2[i][j] = 8;
  192.                 mov r12, #1
  193.                 sub r10, r10, r11
  194.                 strb r10, [r7]
  195.                 pop {r10}
  196.             .Lnnext2:
  197.                 cmp r10, #17        @;comparem r10, amb 9
  198.                 blo .Lnnext3
  199.                 cmp r10, #22       
  200.                 bhi .Lnnext3   
  201.                 push {r10}          @; matriuJoc >= 17 && matriuJoc <= 22
  202.                 mov r11, #16
  203.                 strb r11, [r9]      @; Guardem un 16 a mat_recomb2[i][j] = 16
  204.                 mov r12, #1
  205.                 sub r10, r10, r11
  206.                 strb r10, [r7]
  207.                 pop {r10}
  208.             .Lnnext3:
  209.                 cmp r10, #0
  210.                 bne .Lnext4
  211.                 mov r11, #0
  212.                 strb r11, [r9]      @;Guardem mat_recomb2[i][j] = 0
  213.                 b .Lnext7
  214.             .Lnext4:
  215.                 cmp r10, #7
  216.                 bne .Lnext5
  217.                 strb r10, [r9]      @;Guardem a mat_recomb2[i][j] = matriu_joc[i][j]
  218.                 b .Lnext7
  219.             .Lnext5:
  220.                 cmp r10, #15        @;Guardem a mat_recomb2[i][j] = matriu_joc[i][j]
  221.                 bne .Lnext6
  222.                 strb r10, [r9]
  223.                 b .Lnext7
  224.             .Lnext6:
  225.                 mov r11, #24
  226.                 and r11, r10, r11   @;Obtenim el valor de gelatina de matriu_joc[i][j]
  227.                 strb r11, [r9]
  228.             .Lnext7:
  229.                 cmp r12, #1
  230.                 beq .Lendfor1
  231.                 mov r11, #24        @;r11 = 24
  232.                 and r11, r10, r11
  233.                 strb r11, [r9]      @;Guardem el codi de gelatina a mat_recomb2[i][j]
  234.                 mov r11, #1
  235.                 add r4, r4, r11     @; Columna + 1
  236.                 b .Lfor1
  237.             .Lendfor1:
  238.                 mov r11, #1
  239.                 add r3, r3, r11     @; Fila + 1
  240.                 b .Lfor0
  241.             .Lendfor0:              @;Fi de primer bucle
  242.                
  243.            
  244.                
  245.         mov r3, #0
  246.             .Lffor0:
  247.                 cmp r3, #ROWS   @;r3 = ROWS ?
  248.                 beq .Lendffor0  @;Si r3 = rows saltem
  249.         mov r4, #0
  250.             .Lffor1:
  251.                 mov r12, #0         @;r12 = 0 -> vol dir que no ha fet mat_recomb2[i][j]
  252.                 cmp r4, #COLUMNS    @;r4 = columns?
  253.                 beq .Lendffor1      @;si r4 = columns saltem
  254.                 mov r5, #COLUMNS    @;r5 = columns
  255.                 mul r6, r5, r3      @;r6 = columna * r3
  256.                 add r6, r6, r4      @;r6 = (columna * r3)  + r4
  257.                 add r9, r6, r2      @;r9 = r6 + r2 -> r2 = direccio memoria mat_recomb2
  258.                 add r7, r6, r1      @;r7 = r6 + r1 -> direccio posicio memoria mat_recomb1
  259.                 add r8, r6, r0      @;r8 = r6 + r0 es la direccio de matriu joc
  260.                 ldrb r5, [r9]       @;r5= valor de mat_recomb2[i][j]
  261.                 ldrb r10, [r8]      @;r10=valor de matriu_joc[i][j]
  262.                 and r10, r10, #7    @;Si els 3 bits de matriu joc son 000, passem següent posicio
  263.                 cmp r10, #0
  264.                 beq .Lendffor1
  265.                 cmp r5, #0          @;r5 = 0?
  266.                 bne .Lprox1
  267.                 b .Lbucle
  268.             .Lprox1:
  269.                 cmp r5, #8          @;r5 = 8?
  270.                 bne .Lprox2
  271.                 b .Lbucle
  272.             .Lprox2:
  273.                 cmp r5, #16         @;r5 = 16?
  274.                 bne .Lendfffor1     @;ERROR ERROR AQUI ERRORRRRRRRRRRRRRRRRRRR
  275.             .Lbucle:
  276.                 push {r0}
  277.                     mov r0, #ROWS       @;r0 = fila
  278.                     bl mod_random       @;cridem mod_random RANG (0...r0-1)
  279.                     mov r11, r0         @;r11 = valor aleatori que estava en r0 de la FILA
  280.                     mov r0, #COLUMNS    @;r0 = col
  281.                     bl mod_random       @;r0 = valor aleatori de (0...r0-1)
  282.                     mov r12, r0         @;r12 = valor aleatori COLUMNA
  283.                 pop {r0}
  284.                     mov r5, #COLUMNS    @;r5 = columans
  285.                     mul r5, r11, r5     @;r5 = desplaçament
  286.                     add r5, r5, r12     @;r5 = mat_recomb1[fila_aleatoria][col_random]
  287.                     add r5, r5, r1      @;r5 = mat_recomb1[fila_aleatoria][col_random]
  288.                     mov r7, r5          @;r7 = direccio memoria de mat_recomb1[fila_aleatoria][col_random]
  289.                     ldrb r6, [r5]       @;r6= valor de mat_recomb1[fila_random][col_random]
  290.                     cmp r6, #0          @;r6 es zero?
  291.                     bne .Lprox3
  292.                     b .Lbucle
  293.             .Lprox3:
  294.                 ldrb r5, [r9]           @;r5 = mat_recomb2[i][j]
  295.                 add r5, r5, r6          @;r5 = mat_recomb2[i][j] + mat_recomb1[fila_random][col_random]
  296.                 ldrb r11, [r9]
  297.                 strb r5, [r9]
  298.                 push {r0-r4}
  299.                     mov r0, r2
  300.                     mov r1, r3
  301.                     mov r2, r4
  302.                     mov r3, #3
  303.                     bl cuenta_repeticiones  @;Mirem orientacio NORTE mat_recomb2
  304.                     cmp r0, #1
  305.                 pop {r0-r4}
  306.                     bhi .Lrep
  307.                 push {r0-r4}
  308.                     mov r0, r2
  309.                     mov r1, r3
  310.                     mov r2, r4
  311.                     mov r3, #3
  312.                     bl cuenta_repeticiones  @;Mirem orientacio NORTE mat_recomb2
  313.                     cmp r0, #1
  314.                 pop {r0-r4}
  315.                     bhi .Lrep
  316.                     mov r11, #0             @;Arribat aqui no hi ha repeticio
  317.                     strb r11, [r7]          @; Fiquem un 0 a mat_recomb1[fila_aleatoria][col_random]
  318.                     b .Lcontinuar
  319.             .Lrep:
  320.                 strb r11, [r9]  @; Restituim la matriu
  321.                 b .Lbucle
  322.             .Lcontinuar:
  323.                 add r4, r4, #1
  324.                 b .Lffor1
  325.             .Lendffor1:
  326.                 add r3, r3, #1
  327.                 b .Lffor0
  328.             .Lendffor0:
  329.                
  330.                
  331.         mov r3, #0
  332.             .Lfffor0:
  333.                 cmp r3, #ROWS   @;r3 = ROWS ?
  334.                 beq .Lendfffor0 @;Si r3 = rows saltem
  335.         mov r4, #0
  336.             .Lfffor1:
  337.                 cmp r4, #COLUMNS    @;r4 = columns?
  338.                 beq .Lendfffor1     @;si r4 = columns saltem
  339.                 mov r5, #COLUMNS    @;r5 = columns
  340.                 mul r6, r5, r3      @;r6 = columna * r3
  341.                 add r6, r6, r4      @;r6 = (columna * r3)  + r4
  342.                 add r9, r6, r2      @;r9 = r6 + r2 -> r2 = direccio memoria mat_recomb2
  343.                 add r8, r6, r0      @;r8 = r6 + r0 es la direccio de matriu joc
  344.                
  345.                 ldrb r7, [r9]       @;r7 = valor de mat_recomb2[i][j]
  346.                 strb r7, [r8]       @;guardem r7 a mat_joc[i][j]
  347.                 add r4, r4, #1
  348.                 b .Lfffor1
  349.             .Lendfffor1:
  350.                 add r3, r3, #1
  351.                 b .Lfffor0
  352.             .Lendfffor0:
  353.         pop {r0 - r12, pc}
  354.  
  355.  
  356.  
  357. @;:::RUTINAS DE SOPORTE:::
  358.  
  359.  
  360.  
  361. @; mod_random(n): rutina para obtener un número aleatorio entre 0 y n-1,
  362. @;  utilizando la rutina 'random'
  363. @;  Restricciones:
  364. @;      * el parámetro 'n' tiene que ser un valor entre 2 y 255, de otro modo,
  365. @;        la rutina lo ajustará automáticamente a estos valores mínimo y máximo
  366. @;  Parámetros:
  367. @;      R0 = el rango del número aleatorio (n)
  368. @;  Resultado:
  369. @;      R0 = el número aleatorio dentro del rango especificado (0..n-1)
  370.  
  371.     .global mod_random
  372. mod_random:
  373.         push {r1-r4, lr}
  374.        
  375.         cmp r0, #2              @;compara el rango de entrada con el mínimo
  376.         bge .Lmodran_cont
  377.         mov r0, #2              @;si menor, fija el rango mínimo
  378.     .Lmodran_cont:
  379.         and r0, #0xff           @;filtra los 8 bits de menos peso
  380.         sub r2, r0, #1          @;R2 = R0-1 (número más alto permitido)
  381.         mov r3, #1              @;R3 = máscara de bits
  382.     .Lmodran_forbits:
  383.         cmp r3, r2              @;genera una máscara superior al rango requerido
  384.         bhs .Lmodran_loop
  385.         mov r3, r3, lsl #1
  386.         orr r3, #1              @;inyecta otro bit
  387.         b .Lmodran_forbits
  388.        
  389.     .Lmodran_loop:
  390.         bl random               @;R0 = número aleatorio de 32 bits
  391.         and r4, r0, r3          @;filtra los bits de menos peso según máscara
  392.         cmp r4, r2              @;si resultado superior al permitido,
  393.         bhi .Lmodran_loop       @; repite el proceso
  394.         mov r0, r4          @; R0 devuelve número aleatorio restringido a rango
  395.        
  396.         pop {r1-r4, pc}
  397.  
  398.  
  399. @; random(): rutina para obtener un número aleatorio de 32 bits, a partir de
  400. @;  otro valor aleatorio almacenado en la variable global 'seed32' (declarada
  401. @;  externamente)
  402. @;  Restricciones:
  403. @;      * el valor anterior de 'seed32' no puede ser 0
  404. @;  Resultado:
  405. @;      R0 = el nuevo valor aleatorio (también se almacena en 'seed32')
  406. random:
  407.     push {r1-r5, lr}
  408.        
  409.     ldr r0, =seed32             @;R0 = dirección de la variable 'seed32'
  410.     ldr r1, [r0]                @;R1 = valor actual de 'seed32'
  411.     ldr r2, =0x0019660D
  412.     ldr r3, =0x3C6EF35F
  413.     umull r4, r5, r1, r2
  414.     add r4, r3                  @;R5:R4 = nuevo valor aleatorio (64 bits)
  415.     str r4, [r0]                @;guarda los 32 bits bajos en 'seed32'
  416.     mov r0, r5                  @;devuelve los 32 bits altos como resultado
  417.        
  418.     pop {r1-r5, pc}
  419.  
  420.  
  421.  
  422. .end
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top