[Day 4] - 100 days of code em C

Continuando o trabalho de ontem tentem implementar os outros registradores virtuais de 16 bits que são formados usando duplas de registradores reais de 8 bits, o que na real foi bem tranquilo mas dado o tempo foi o que deu pra fazer porém gastei um tempinho olhando algumas anotações que eu já tinha feito em como eu gostaria de rodar testes e vendo se eu iria querer usar alguma lib já existente porém sei lá usar C tem me despertado o lado de querer fazer a montar minhas coisinhas pra ir usando sempre que dá, então provavelmente nos próximos dias essa vai ser a fonte da minha procastinação objetiva XD, no mais a pira de usar testes é por que eu me sinto bem inseguro codando sem fazer nenhum testes provavelmente por causa da falta do TDD, aproveitei hoje também para juntar o trabalho que eu já tinha feito relacionado a como funciona o clock do gameboy inclusive é bem interessante pois eu gosto da ideia de implementar o comportamento como ele realmente é então acabei por não omitir o valor pra não ocultar o valor da frequência master. Com isso nos próximos dias eu devo me focar em implementar testes e trazer a dinâmica do Program counter e o stack pointer pra poder pensar em como vou fazer para quando as operações forem rolando ao logno do tempo, apesar de tudo essa é uma parte que tenho me sentido um pouco travado em pensar como fazer em C mas certamente é só limitação de conhecimento da linguagem mesmo.

#include <stdio.h> 
#include <time.h>
#include <stdint.h>
#include <stdlib.h>

//TODO - Modularize this in future
typedef struct {
	uint16_t PC;	
	uint16_t SP;
	uint8_t A;
	uint8_t B;
	uint8_t C;
	uint8_t D;
	uint8_t E;
	uint8_t F;
	uint8_t H;
	uint8_t L;
} Registers;

uint16_t get_af_register(const Registers* reg) {
	uint16_t virtual_register = (((uint16_t)reg->A) << 8) | reg->F;
	return virtual_register;
}

void set_af_register(Registers* reg, const uint8_t value_a, const uint8_t value_f) {
	reg->A = value_a;
	reg->F = value_f;
}

uint16_t get_bc_register(const Registers* reg) {
	uint16_t virtual_register = (((uint16_t)reg->B) << 8) | reg->C;
	return virtual_register;
}

void set_bc_register(Registers* reg, const uint8_t value_b, const uint8_t value_c) {
	reg->B = value_b;
	reg->C = value_c;
}

uint16_t get_de_register(const Registers* reg) {
	uint16_t virtual_register = (((uint16_t)reg->D) << 8) | reg->E;
	return virtual_register;
}

void set_de_register(Registers* reg, const uint8_t value_d, const uint8_t value_e) {
	reg->D = value_d;
	reg->E = value_e;
}

uint16_t get_hl_register(const Registers* reg) {
	const uint16_t virtual_register = (((uint16_t)reg->H) << 8) | reg->L;
	return virtual_register;
}

void set_hl_register(Registers* reg, const uint8_t value_l, const uint8_t value_h) {
	reg->H = value_h;
	reg->L = value_l;
}

int system_clock_count = 0;

static inline void cycle(float seconds) {
	float milli_seconds = CLOCKS_PER_SEC * seconds;

	clock_t start_time = clock();
	while(clock() < start_time + milli_seconds);
	system_clock_count++;
	printf("Master clock | Passou %f segundos\n", seconds);
	printf("Count system clock: %d\n", (system_clock_count));
	if(system_clock_count == 4) {
		printf("System clock | 1/4 do master clock\n");
		system_clock_count = 0;
	}
}

int main(){
	Registers reg;
	set_bc_register(&reg, 0xAA, 0x1A);
	uint16_t result = get_bc_register(&reg);
	printf("0x%04X \n", result);

	// PREPARE FOR CLOCK
	float master_clock_frequency = ((float)1/4.194304 * 1000000.0f) / 1000000.0f;;
	while(1) {
		cycle(master_clock_frequency);
	}
	return 0;
}