SHARE
TWEET

Untitled

a guest Jan 8th, 2020 119 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;
  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.     .global inicializa_matriz
  46. inicializa_matriz:
  47.         push {r0-r10, lr}       @;guardar registros utilizados
  48.                 mov r10, r0         @;r10 = direccion matriz juego
  49.                 mov r3, #0
  50.             .Lfor1:
  51.                 cmp r3, #ROWS   @;comparem les files
  52.                 beq .Lfibucle2  @;si igual fi bucle
  53.                 mov r4, #0      @;r4 = 0
  54.             .Lfor2:
  55.                 ldr r2, =mapas      @;direccio de memoria de mapas
  56.                 cmp r4, #COLUMNS    @;comparem columnes
  57.                 beq .Lfibucle1      @;si igual salta fi bucle
  58.                 mov r5, #COLUMNS    @;r5 = columnas
  59.                 mul r5, r5, r3      @;r5 = columnas * fila
  60.                 add r5, r5, r4      @;r5 = (columnas * fila) + col
  61.                 add r0, r0, r5      @;r0 = matriu_joc indexada[f][c]
  62.                 mov r7, #ROWS       @;r7 = filas
  63.                 mov r8, #COLUMNS    @;r8 = columnas
  64.                 mul r6, r7, r8      @;r6= (filas * columnas)
  65.                 mul r6, r6, r1      @;r6 = (filas * columnas) * num. mapa                    
  66.                 add r5, r6, r5      @;r5 = r6 + r5
  67.                 add r2, r2, r5      @;Posicio memoria element (f,c) en matriu configuracio
  68.                 ldrb r6, [r2]       @;obtenim el valor que conte matriu[f][c]
  69.                 cmp r6, #0          @;comparem r6 = 0
  70.                 bne .Lnext1         @;si no igual, salta
  71.                 b .Lrepeticions     @;si es 0, saltem a .Lrepeticions
  72.             .Lnext1:               
  73.                 cmp r6, #8          @;r6 = 8 ?
  74.                 bne .Lnext2         @;si no igual saltem
  75.                 b .Lrepeticions     @;si igual anem a .Lrepeticions
  76.             .Lnext2:
  77.                 cmp r6, #16         @;r6 = 16 ?
  78.                 bne .Lnext3         @;si no igual saltem i guardem el valor tal cual
  79.                 b .Lrepeticions     @;si igual anem a .Lrepeticions
  80.             .Lrepeticions:
  81.                 push {r0}
  82.                     mov r0, #6  @;r0 = 6
  83.                     bl mod_random
  84.                     mov r9, r0      @;r9 = direccio memoria de matriu_joc
  85.                     add r9, r9, #1  @;sumem 1 al valor aleatori 1...6
  86.                 pop {r0}
  87.                     add r9, r9, r6  @;r9=valor_aleatori + r6(0 8 o 16)
  88.                     strb r9, [r0]   @;matriu_joc[f][c] = valor aleatori
  89.                 push {r0-r4}
  90.                     mov r0, r10     @;r0 = r10 (direccio memoria matriu joc)
  91.                     mov r1,
  92.                     mov r2,
  93.                     mov r3
  94.                     bl cuenta_repeticiones
  95.                     mov r9, r0
  96.                 pop {r0-r4}
  97.                     cmp r9, #1      @;si hi ha repeticions, tornem a generar
  98.                     bne .Lrepeticions
  99.             .Lnext3:                @;al arribar aqui hem vist que no es ni 0, ni 8 ni 16
  100.                 strb r6, [r0]       @;per tant guardem el valor tal cual
  101.                 add r4, r4, #1      @;incrementen en 1 la columna
  102.                 b. Lfor2            @;saltem al inici de bucle
  103.             .Lfibucle1:
  104.                 add r3, r3, #1          @;incrementem en 1 la fila
  105.                 b. Lfor1
  106.             .Lfibucle2:
  107.                        
  108.                        
  109.                
  110.         pop {r0-r10, pc}            @;recuperar registros y volver
  111.  
  112.  
  113.  
  114. @;TAREA 1B;
  115. @; recombina_elementos(*matriz): rutina para generar una nueva matriz de juego
  116. @;  mediante la reubicación de los elementos de la matriz original, para crear
  117. @;  nuevas jugadas.
  118. @;  Inicialmente se copiará la matriz original en 'mat_recomb1', para luego ir
  119. @;  escogiendo elementos de forma aleatoria y colocandolos en 'mat_recomb2',
  120. @;  conservando las marcas de gelatina.
  121. @;  Restricciones:
  122. @;      * para obtener elementos de forma aleatoria se invocará la rutina
  123. @;          'mod_random'
  124. @;      * para evitar generar secuencias se invocará la rutina
  125. @;          'cuenta_repeticiones' (ver fichero "candy1_move.s")
  126. @;      * para determinar si existen combinaciones en la nueva matriz, se
  127. @;          invocará la rutina 'hay_combinacion' (ver fichero "candy1_comb.s")
  128. @;      * se supondrá que siempre existirá una recombinación sin secuencias y
  129. @;          con combinaciones
  130. @;  Parámetros:
  131. @;      R0 = dirección base de la matriz de juego
  132.     .global recombina_elementos
  133. recombina_elementos:
  134.     push {r0-r12, lr}
  135.         ldr r1, =mat_recomb1 @; R0: MAT_RECOMB1 Direccio memoria
  136.         ldr r2, =mat_recomb2 @; r1: MAT_RECOMB2 direccio memoria
  137.            
  138.         mov r3, #0
  139.             .Lfor0:
  140.                 cmp r3, #ROWS   @;r3 = ROWS ?
  141.                 beq .Lendfor0   @;Si r3 = rows saltem
  142.         mov r4, #0
  143.             .Lfor1:
  144.                 mov r12, #0         @;r12 = 0 -> vol dir que no ha fet mat_recomb2[i][j]
  145.                 cmp r4, #COLUMNS    @;r4 = columns?
  146.                 beq .Lendfor1       @;si r4 = columns saltem
  147.                 mov r5, #COLUMNS    @;r5 = columns
  148.                 mul r6, r5, r3      @;r6 = columna * r3
  149.                 add r6, r6, r4      @;r6 = (columna * r3)  + r4
  150.                 add r9, r6, r2      @;r9 = r6 + r2 -> r2 = direccio memoria mat_recomb2
  151.                 add r7, r6, r1      @;r7 = r6 + r1 -> direccio posicio memoria mat_recomb1
  152.                 add r8, r6, r0      @;r8 = r6 + r0 es la direccio de matriu joc
  153.                 ldrb r10, [r8]      @;r10 = valor de matriu_joc[i][j]
  154.                 strb r10, [r7]      @;Guardem a mat_recomb1 = matriu_joc[i][j]
  155.                 cmp r10, #7         @;Comparem r10 = 7?
  156.                 bne .Lnext0         @;Si no igual salta
  157.                 push {r10}
  158.                 mov r10, #0         @;r10 = 0
  159.                 strb r10, [r7]      @;Guardem mat_recomb1[i][j] = 0
  160.                 pop {r10}           @;recuperm valor r10
  161.                 b .Lnext1
  162.             .Lnext0:
  163.                 cmp r10, #15        @;comparem r10, 15
  164.                 bne .Lnnext1
  165.                 push {r10}          @;recuperem valor r10
  166.                 mov r10, #0         @; r10 = 0
  167.                 strb r10, [r7]      @; Guardem un 0
  168.                 pop {r10}
  169.             .Lnnext1:
  170.                 cmp r10, #9         @;comparem r10, amb 9
  171.                 blo .Lnnext2
  172.                 cmp r10, #14
  173.                 bhi .Lnnext2            @;matriu[i][j] >=9 && matriu[i][j] <= 14
  174.                 push {r10}
  175.                 mov r11, #8
  176.                 strb r11, [r9]      @;Guardem a mat_recomb2[i][j] = 8;
  177.                 mov r12, #1
  178.                 sub r10, r10, r11
  179.                 strb r10, [r7]
  180.                 pop {r10}
  181.             .Lnnext2:
  182.                 cmp r10, #17        @;comparem r10, amb 9
  183.                 blo .Lnnext3
  184.                 cmp r10, #22       
  185.                 bhi .Lnnext3   
  186.                 push {r10}          @; matriuJoc >= 17 && matriuJoc <= 22
  187.                 mov r11, #16
  188.                 strb r11, [r9]      @; Guardem un 16 a mat_recomb2[i][j] = 16
  189.                 mov r12, #1
  190.                 sub r10, r10, r11
  191.                 strb r10, [r7]
  192.                 pop {r10}
  193.             .Lnnext3:
  194.                 cmp r10, #0
  195.                 bne .Lnext4
  196.                 mov r11, #0
  197.                 strb r11, [r9]      @;Guardem mat_recomb2[i][j] = 0
  198.                 b .Lnext7
  199.             .Lnext4:
  200.                 cmp r10, #7
  201.                 bne .Lnext5
  202.                 strb r10, [r9]      @;Guardem a mat_recomb2[i][j] = matriu_joc[i][j]
  203.                 b .Lnext7
  204.             .Lnext5:
  205.                 cmp r10, #15        @;Guardem a mat_recomb2[i][j] = matriu_joc[i][j]
  206.                 bne .Lnext6
  207.                 strb r10, [r9]
  208.                 b .Lnext7
  209.             .Lnext6:
  210.                 mov r11, #24
  211.                 and r11, r10, r11   @;Obtenim el valor de gelatina de matriu_joc[i][j]
  212.                 strb r11, [r9]
  213.             .Lnext7:
  214.                 cmp r12, #1
  215.                 beq .Lendfor1
  216.                 mov r11, #24        @;r11 = 24
  217.                 and r11, r10, r11
  218.                 strb r11, [r9]      @;Guardem el codi de gelatina a mat_recomb2[i][j]
  219.                 mov r11, #1
  220.                 add r4, r4, r11     @; Columna + 1
  221.                 b .Lfor1
  222.             .Lendfor1:
  223.                 mov r11, #1
  224.                 add r3, r3, r11     @; Fila + 1
  225.                 b .Lfor0
  226.             .Lendfor0:              @;Fi de primer bucle
  227.                
  228.            
  229.                
  230.         mov r3, #0
  231.             .Lffor0:
  232.                 cmp r3, #ROWS   @;r3 = ROWS ?
  233.                 beq .Lendffor0  @;Si r3 = rows saltem
  234.         mov r4, #0
  235.             .Lffor1:
  236.                 mov r12, #0         @;r12 = 0 -> vol dir que no ha fet mat_recomb2[i][j]
  237.                 cmp r4, #COLUMNS    @;r4 = columns?
  238.                 beq .Lendffor1      @;si r4 = columns saltem
  239.                 mov r5, #COLUMNS    @;r5 = columns
  240.                 mul r6, r5, r3      @;r6 = columna * r3
  241.                 add r6, r6, r4      @;r6 = (columna * r3)  + r4
  242.                 add r9, r6, r2      @;r9 = r6 + r2 -> r2 = direccio memoria mat_recomb2
  243.                 add r7, r6, r1      @;r7 = r6 + r1 -> direccio posicio memoria mat_recomb1
  244.                 add r8, r6, r0      @;r8 = r6 + r0 es la direccio de matriu joc
  245.                 ldrb r5, [r9]       @;r5= valor de mat_recomb2[i][j]
  246.                 ldrb r10, [r8]      @;r10=valor de matriu_joc[i][j]
  247.                 and r10, r10, #7    @;Si els 3 bits de matriu joc son 000, passem següent posicio
  248.                 cmp r10, #0
  249.                 beq .Lendffor1
  250.                 cmp r5, #0          @;r5 = 0?
  251.                 bne .Lprox1
  252.                 b .Lbucle
  253.             .Lprox1:
  254.                 cmp r5, #8          @;r5 = 8?
  255.                 bne .Lprox2
  256.                 b .Lbucle
  257.             .Lprox2:
  258.                 cmp r5, #16         @;r5 = 16?
  259.                 bne .Lendfffor1     @;ERROR ERROR AQUI ERRORRRRRRRRRRRRRRRRRRR
  260.             .Lbucle:
  261.                 push {r0}
  262.                     mov r0, #ROWS       @;r0 = fila
  263.                     bl mod_random       @;cridem mod_random RANG (0...r0-1)
  264.                     mov r11, r0         @;r11 = valor aleatori que estava en r0 de la FILA
  265.                     mov r0, #COLUMNS    @;r0 = col
  266.                     bl mod_random       @;r0 = valor aleatori de (0...r0-1)
  267.                     mov r12, r0         @;r12 = valor aleatori COLUMNA
  268.                 pop {r0}
  269.                     mov r5, #COLUMNS    @;r5 = columans
  270.                     mul r5, r11, r5     @;r5 = desplaçament
  271.                     add r5, r5, r12     @;r5 = mat_recomb1[fila_aleatoria][col_random]
  272.                     add r5, r5, r1      @;r5 = mat_recomb1[fila_aleatoria][col_random]
  273.                     mov r7, r5          @;r7 = direccio memoria de mat_recomb1[fila_aleatoria][col_random]
  274.                     ldrb r6, [r5]       @;r6= valor de mat_recomb1[fila_random][col_random]
  275.                     cmp r6, #0          @;r6 es zero?
  276.                     bne .Lprox3
  277.                     b .Lbucle
  278.             .Lprox3:
  279.                 ldrb r5, [r9]           @;r5 = mat_recomb2[i][j]
  280.                 add r5, r5, r6          @;r5 = mat_recomb2[i][j] + mat_recomb1[fila_random][col_random]
  281.                 ldrb r11, [r9]
  282.                 strb r5, [r9]
  283.                 push {r0-r4}
  284.                     mov r0, r2
  285.                     mov r1, r3
  286.                     mov r2, r4
  287.                     mov r3, #3
  288.                     bl cuenta_repeticiones  @;Mirem orientacio NORTE mat_recomb2
  289.                     cmp r0, #1
  290.                 pop {r0-r4}
  291.                     bhi .Lrep
  292.                 push {r0-r4}
  293.                     mov r0, r2
  294.                     mov r1, r3
  295.                     mov r2, r4
  296.                     mov r3, #3
  297.                     bl cuenta_repeticiones  @;Mirem orientacio NORTE mat_recomb2
  298.                     cmp r0, #1
  299.                 pop {r0-r4}
  300.                     bhi .Lrep
  301.                     mov r11, #0             @;Arribat aqui no hi ha repeticio
  302.                     strb r11, [r7]          @; Fiquem un 0 a mat_recomb1[fila_aleatoria][col_random]
  303.                     b .Lcontinuar
  304.             .Lrep:
  305.                 strb r11, [r9]  @; Restituim la matriu
  306.                 b .Lbucle
  307.             .Lcontinuar:
  308.                 add r4, r4, #1
  309.                 b .Lffor1
  310.             .Lendffor1:
  311.                 add r3, r3, #1
  312.                 b .Lffor0
  313.             .Lendffor0:
  314.                
  315.                
  316.         mov r3, #0
  317.             .Lfffor0:
  318.                 cmp r3, #ROWS   @;r3 = ROWS ?
  319.                 beq .Lendfffor0 @;Si r3 = rows saltem
  320.         mov r4, #0
  321.             .Lfffor1:
  322.                 cmp r4, #COLUMNS    @;r4 = columns?
  323.                 beq .Lendfffor1     @;si r4 = columns saltem
  324.                 mov r5, #COLUMNS    @;r5 = columns
  325.                 mul r6, r5, r3      @;r6 = columna * r3
  326.                 add r6, r6, r4      @;r6 = (columna * r3)  + r4
  327.                 add r9, r6, r2      @;r9 = r6 + r2 -> r2 = direccio memoria mat_recomb2
  328.                 add r8, r6, r0      @;r8 = r6 + r0 es la direccio de matriu joc
  329.                
  330.                 ldrb r7, [r9]       @;r7 = valor de mat_recomb2[i][j]
  331.                 strb r7, [r8]       @;guardem r7 a mat_joc[i][j]
  332.                 add r4, r4, #1
  333.                 b .Lfffor1
  334.             .Lendfffor1:
  335.                 add r3, r3, #1
  336.                 b .Lfffor0
  337.             .Lendfffor0:
  338.         pop {r0 - r12, pc}
  339.  
  340.  
  341.  
  342. @;:::RUTINAS DE SOPORTE:::
  343.  
  344.  
  345.  
  346. @; mod_random(n): rutina para obtener un número aleatorio entre 0 y n-1,
  347. @;  utilizando la rutina 'random'
  348. @;  Restricciones:
  349. @;      * el parámetro 'n' tiene que ser un valor entre 2 y 255, de otro modo,
  350. @;        la rutina lo ajustará automáticamente a estos valores mínimo y máximo
  351. @;  Parámetros:
  352. @;      R0 = el rango del número aleatorio (n)
  353. @;  Resultado:
  354. @;      R0 = el número aleatorio dentro del rango especificado (0..n-1)
  355.  
  356.     .global mod_random
  357. mod_random:
  358.         push {r1-r4, lr}
  359.        
  360.         cmp r0, #2              @;compara el rango de entrada con el mínimo
  361.         bge .Lmodran_cont
  362.         mov r0, #2              @;si menor, fija el rango mínimo
  363.     .Lmodran_cont:
  364.         and r0, #0xff           @;filtra los 8 bits de menos peso
  365.         sub r2, r0, #1          @;R2 = R0-1 (número más alto permitido)
  366.         mov r3, #1              @;R3 = máscara de bits
  367.     .Lmodran_forbits:
  368.         cmp r3, r2              @;genera una máscara superior al rango requerido
  369.         bhs .Lmodran_loop
  370.         mov r3, r3, lsl #1
  371.         orr r3, #1              @;inyecta otro bit
  372.         b .Lmodran_forbits
  373.        
  374.     .Lmodran_loop:
  375.         bl random               @;R0 = número aleatorio de 32 bits
  376.         and r4, r0, r3          @;filtra los bits de menos peso según máscara
  377.         cmp r4, r2              @;si resultado superior al permitido,
  378.         bhi .Lmodran_loop       @; repite el proceso
  379.         mov r0, r4          @; R0 devuelve número aleatorio restringido a rango
  380.        
  381.         pop {r1-r4, pc}
  382.  
  383.  
  384. @; random(): rutina para obtener un número aleatorio de 32 bits, a partir de
  385. @;  otro valor aleatorio almacenado en la variable global 'seed32' (declarada
  386. @;  externamente)
  387. @;  Restricciones:
  388. @;      * el valor anterior de 'seed32' no puede ser 0
  389. @;  Resultado:
  390. @;      R0 = el nuevo valor aleatorio (también se almacena en 'seed32')
  391. random:
  392.     push {r1-r5, lr}
  393.        
  394.     ldr r0, =seed32             @;R0 = dirección de la variable 'seed32'
  395.     ldr r1, [r0]                @;R1 = valor actual de 'seed32'
  396.     ldr r2, =0x0019660D
  397.     ldr r3, =0x3C6EF35F
  398.     umull r4, r5, r1, r2
  399.     add r4, r3                  @;R5:R4 = nuevo valor aleatorio (64 bits)
  400.     str r4, [r0]                @;guarda los 32 bits bajos en 'seed32'
  401.     mov r0, r5                  @;devuelve los 32 bits altos como resultado
  402.        
  403.     pop {r1-r5, pc}
  404.  
  405.  
  406.  
  407. .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