A tratar de expresar con mis propias palabras lo que creo haber entendido, lo que he asumido como ciertas a partir de lo que he visto, leído y hecho.
Porque este ha sido otro de esos meses en los que apenas he tocado el teclado para escribir código. Aun así, poco a poco los conceptos se van asentando en mi cabeza. Cosas que, por más que leí cuando comenzaba con esto, no terminaba de asimilar. Y es que las lagunas de mi conocimiento son muy profundas y mi capacidad de concentración en estos últimos años ha dejado bastante que desear.
Pero, por suerte, tengo los vídeos del Profe1. En gran medida, si he logrado avanzar en este proceso de comprensión en estos últimos tiempos, esto ha sido gracias a los vídeos del señor Fran Gallego que, tras el inicio de curso, sigue con su imparable subida de vídeos diaria.
Porque, a base de escuchar como con su paciencia infinita va desgranando los secretos del “debugger” del WinApe, algo va quedando.
En conjunción con esto, los vídeos de Ben Eater también me han ayudado a hacerme una visión global de lo que sucede dentro del procesador. A entender más o menos que significa una arquitectura de 8, 16, 32 o 64 bits. A entender que, aunque aunque el z80 es un procesador de 8bits, también posee registros de 16 que gracias a los que puede acceder hasta 64 ks de RAM. A descubrir como, gracias al intercambio de bancos de memoria2 se podían llegar a gestionar cantidades de memoria mayores a las previstas por el procesador con leves modificaciones en la arquitectura de la máquina o del sistema operativo (lo de leves es un decir).
Como digo, poro a poco las piezas van encajando. Con décadas de retraso, los misterios arcanos detrás de las líneas del Autoexec.bat y el Config.sys van teniendo un poco más de sentido.
No sé cuántas explicaciones he leído acerca de lo que es un puntero, cuantos ejemplos he visto, o cuántos he creado yo por mi cuenta, pero seguía siendo un concepto que se me hacía difuso. Hoy, tras escribir un pequeños programa, las cosas se van asentando un poco (aunque hay ciertos aspectos que me siguen eludiendo)
Por un lado, la manera en la que se se trabajan en C++ con los distintos tipos de punteros se me siguen escapando un poco. Creo que es una cosa de la implementación concreta en este lenguaje, pero no deja de ser una jodienda.
Por otro lado, una vez superado el escollo de escribir el código que buscaba (algo que tampoco me ha resultado trivial), una parte de los resultados que me han aparecido no han sido los que esperaba.
| Variable | Valor |
|---|---|
| TextoConst | Hola Mundo |
| &TextoConst | 0x55fd6c1dcd60 |
| TextoConst[0] | H |
| &TextoConst[1] | ola Mundo |
| &TextoConst[2] | la Mundo |
| TextoNoConst | Holita mundo |
| &TextoNoConst | 0x55fd6c1dd138 |
| TextoNoConst[0] | H |
| &TextoNoConst[1] | olita mundo |
| &TextoNoConst[2] | lita mundo |
| NumeroNoConst | 0x55fd6dd62e90 |
| &NumeroNoConst | 0x55fd6c1dd140 |
| &NumeroNoConst | 66 |
| Caracter | L |
| &Caracter | L |
| Numero | 99 |
| &Numero | 0x55fd6c1dd14c |
| TextoNoConst | Adiosito mundo |
| &TextoNoConst | 0x55fd6c1dd138 |
| TextoNoConst[0] | A |
| &TextoNoConst[1] | diosito mundo |
| &TextoNoConst[2] | iosito mundo |
Porque… ¿por qué la variable tipo char_no_puntero cuando la llamo por referencia (&Caracter) no me da una posición de memoria, y la tipo_int_no_puntero (&Numero) sí?
¿Por qué el puntero_a_int (NumeroNoConst) me da dos posiciones de memoria diferentes dependiendo de si la llamo directamente o por referencia?
De nuevo, asumo que esto deben ser cosas de la implementación de C++, pero no dejan de ser ejemplos de que estoy trabajando con una herramienta que no termino de comprender. De que las cosas que he hecho funcionan gracias al copia pega acrítico del código de otros, no porque tenga del todo claro lo que estoy haciendo.
En otro orden de cosas, el tratar de entender los punteros es algo que sí que me ha ayudado a aclarar el porqué de los “números” en las arquitecturas de procesadores.
El entender que si tengo 8 gigas de RAM en mi ordenador (unos 8,000 millones de bits), un procesador con registros de 32 bits (salvo que hagan ñapas como el intercambio de bancos) nunca podrá llegar hasta la información que se encuentre más allá de los 4,000 millones ya que sus registros no pueden almacenar unos números tan grandes como aquellos en los que se encuentran esas posiciones de memoria.
| Size | Valores únicos representables | Notas |
|---|---|---|
| 8-bit | 256 | = 28 |
| 16-bit | 65 536 | = 216 |
| 32-bit | 4 294 967 296 | = 232 (~4.000 Millones) |
| 64-bit | 18 446 744 073 709 551 616 | = 264 (~18 billones de millones) |
(esta tabla la he sacado de aquí 3)
Y no sé si esto que estoy escribiendo tendrá sentido para alguien que no sea yo. La manera en la que he plasmado esto no deja de ser una interpretación personal, pero sí que creo que sería capaz de explicárselo a alguien que compartiese esta curiosidad. Y este no me parece un logro menor.
En fin. Aparte de esta pequeña reflexión, durante este mes también han4 ido5 apareciendo6 muchas cosas más por la red a las que les he ido hincando el diente, y quedan otras tantas pendientes para7 más adelante8, pero creo que con esto ya es suficiente por hoy.
Enlaces:
1. El Profe
- Ensablador
- Sistema de IA: implementando la acción move_to [#ASM #Z80]
- Entity-System (II): Análisis de Rendimiento, Problemas y Mejoras [#ASM #Z80]
- Entity-System (III): ajustes en los sistemas [#ASM #Z80]
- Sistema de IA: Comportamiento 'Patrol' básico (I) [#ASM #Z80]
- Sistema de IA: 'Patrol' básico (II), mejoras de código [#ASM #Z80]
- Revisión IA 'Patrol' y Entity-System (III) [#ASM #Z80]
- Enfrentándose a flickering y tearing: analizando el raster [#ASM #Z80]
- Técnicas de renderizado y restauración del fondo [#ASM #Z80]
- Render y restauración del fondo (II): modo XOR, tiles tocados y sprites por partes [#ASM #Z80]
- Entender los detalles y ser minuciosos para mejorar en ingeniería
- Entity-System (IV): managers con punteros y mejoras de código [#ASM #Z80]
- Primer dibujado XOR: evitar costes con código automodificable [#ASM #Z80]
- Sistema de colisiones: implementación básica con array de punteros [#ASM #Z80]
- Colisiones entre bounding boxes [#ASM #Z80]
- Entity-System (IV): revisión de estructura e implementación [#ASM #Z80]
- Colisiones con múltiples entidades [#ASM #Z80]
- Optimizaciones de Colisiones e IA
- Entendiendo dibujado de tilemaps en CPCtelera y colisiones [#ASM #Z80]
- Saber limitarse al planificar proyectos
- Pautas simples de Game Design
- Herramientas de depuración y mejoras de código [#ASM #Z80]
- Sistema básico de animaciones (I) [#ASM #Z80]
- Sistema básico de animaciones (II) [#ASM #Z80]
- Entity-System (V): Estructura y Animaciones [#ASM #Z80]
- Sistema de animaciones: estados de movimiento [#ASM #Z80]
- Sistema de animaciones: cambios de secuencia [#ASM #Z80]
- Depuración de bugs irregulares: playback session de WinAPE [#ASM #Z80]
- Compresión de binarios e imágenes en CPCtelera [#ASM #Z80]
- Convertir y reproducir música: Arkos Tracker CPCtelera [#ASM #Z80]
- Controlando las interrupciones [#ASM #Z80]
- Música por interrupciones [#ASM #Z80]
- Basic
- Amstrad GameDev Challenge #07: BASIC vs C #ECS #TeamFromScratch
2. Accediendo a la memoria
- Bank Switching
- Expanded memory
- Extended memory
3. Tamaños de variables y registros
4. GDC
- GDC Plays indivisible with Mike Z and Mariel Cartwright
5. New Frame Plus
- Squash & Stretch - The 12 Principles of Animation in Games
6. Dan Root
- X7 and The Importance of Principles
- The Key to Metroid Prime's Atmosphere
7. Programación Retro del Commodore 64
- Asteroids: activación de nuevos asteroides
- Asteroids: colisiones de la nave con los asteroides
- Asteroids: una explosión en condiciones
- Asteroids: colisiones – algunas mejoras necesarias
- Asteroids: colisiones de disparos con asteroides (paso I)
- Asteroids: colisiones de disparos con asteroides (paso II)
- Asteroids: colisiones de disparos con asteroides (paso III)
- Asteroids: información en la línea inferior de la pantalla
- Asteroids: movimiento de los sprites por toda la pantalla (paso I)
- Asteroids: movimiento de los sprites por toda la pantalla (paso II)
