kitchen: README + MISSIONS/engine-c keep-drop notes
This commit is contained in:
Hernâni Marques
parent
1d351918da
commit
575d7d29b8
130 changed files with 9817 additions and 1 deletions
334
engine-c/src/unit_card.c
Normal file
334
engine-c/src/unit_card.c
Normal file
|
|
@ -0,0 +1,334 @@
|
|||
#include "unit_card.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <immintrin.h>
|
||||
|
||||
// Create a new unit card
|
||||
UnitCard* create_unit_card(const char* name, const char* faction,
|
||||
uint32_t cost, uint32_t hp, uint32_t attack,
|
||||
uint32_t defense, uint32_t speed, uint32_t range,
|
||||
const char* description, const char* image,
|
||||
uint8_t unit_type) {
|
||||
UnitCard* unit = (UnitCard*)malloc(sizeof(UnitCard));
|
||||
if (!unit) {
|
||||
fprintf(stderr, "Memory allocation failed for unit card\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Initialize all fields with defaults
|
||||
memset(unit, 0, sizeof(UnitCard));
|
||||
|
||||
// Copy strings
|
||||
strncpy(unit->name, name, sizeof(unit->name) - 1);
|
||||
unit->name[sizeof(unit->name) - 1] = '\0';
|
||||
|
||||
strncpy(unit->faction, faction, sizeof(unit->faction) - 1);
|
||||
unit->faction[sizeof(unit->faction) - 1] = '\0';
|
||||
|
||||
strncpy(unit->description, description, sizeof(unit->description) - 1);
|
||||
unit->description[sizeof(unit->description) - 1] = '\0';
|
||||
|
||||
strncpy(unit->image_path, image, sizeof(unit->image_path) - 1);
|
||||
unit->image_path[sizeof(unit->image_path) - 1] = '\0';
|
||||
|
||||
// Copy numeric values
|
||||
unit->cost = cost;
|
||||
unit->hp = hp;
|
||||
unit->max_hp = hp;
|
||||
unit->attack = attack;
|
||||
unit->defense = defense;
|
||||
unit->speed = speed;
|
||||
unit->range = range;
|
||||
unit->unit_type = unit_type;
|
||||
|
||||
return unit;
|
||||
}
|
||||
|
||||
// Free a unit card
|
||||
void free_unit_card(UnitCard* unit) {
|
||||
if (unit) {
|
||||
free(unit);
|
||||
}
|
||||
}
|
||||
|
||||
// Create a new unit registry
|
||||
UnitRegistry* create_registry() {
|
||||
UnitRegistry* registry = (UnitRegistry*)malloc(sizeof(UnitRegistry));
|
||||
if (!registry) {
|
||||
fprintf(stderr, "Memory allocation failed for registry\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
registry->units = NULL;
|
||||
registry->unit_count = 0;
|
||||
registry->capacity = 0;
|
||||
|
||||
return registry;
|
||||
}
|
||||
|
||||
// Destroy a unit registry
|
||||
void destroy_registry(UnitRegistry* registry) {
|
||||
if (!registry) return;
|
||||
|
||||
if (registry->units) {
|
||||
for (size_t i = 0; i < registry->unit_count; i++) {
|
||||
free_unit_card(registry->units[i]);
|
||||
}
|
||||
free(registry->units);
|
||||
}
|
||||
|
||||
free(registry);
|
||||
}
|
||||
|
||||
// Add a unit to the registry
|
||||
int add_unit(UnitRegistry* registry, UnitCard* unit) {
|
||||
if (!registry || !unit) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Resize if necessary
|
||||
if (registry->unit_count >= registry->capacity) {
|
||||
size_t new_capacity = registry->capacity ? registry->capacity * 2 : 10;
|
||||
UnitCard** new_units = (UnitCard**)realloc(registry->units,
|
||||
new_capacity * sizeof(UnitCard*));
|
||||
if (!new_units) {
|
||||
fprintf(stderr, "Memory reallocation failed\n");
|
||||
return -1;
|
||||
}
|
||||
registry->units = new_units;
|
||||
registry->capacity = new_capacity;
|
||||
}
|
||||
|
||||
// Add the unit
|
||||
registry->units[registry->unit_count++] = unit;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get unit by name
|
||||
UnitCard* get_unit_by_name(UnitRegistry* registry, const char* name) {
|
||||
if (!registry || !name) return NULL;
|
||||
|
||||
for (size_t i = 0; i < registry->unit_count; i++) {
|
||||
if (strcmp(registry->units[i]->name, name) == 0) {
|
||||
return registry->units[i];
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Get units by faction
|
||||
UnitCard** get_units_by_faction(UnitRegistry* registry, const char* faction,
|
||||
size_t* out_count) {
|
||||
if (!registry || !faction || !out_count) return NULL;
|
||||
|
||||
// Count units of this faction
|
||||
size_t count = 0;
|
||||
for (size_t i = 0; i < registry->unit_count; i++) {
|
||||
if (strcmp(registry->units[i]->faction, faction) == 0) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
if (count == 0) {
|
||||
*out_count = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Allocate and fill array
|
||||
UnitCard** result = (UnitCard**)calloc(count, sizeof(UnitCard*));
|
||||
if (!result) {
|
||||
*out_count = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
size_t idx = 0;
|
||||
for (size_t i = 0; i < registry->unit_count; i++) {
|
||||
if (strcmp(registry->units[i]->faction, faction) == 0) {
|
||||
result[idx++] = registry->units[i];
|
||||
}
|
||||
}
|
||||
|
||||
*out_count = count;
|
||||
return result;
|
||||
}
|
||||
|
||||
// Get units by type
|
||||
UnitCard** get_units_by_type(UnitRegistry* registry, uint8_t unit_type,
|
||||
size_t* out_count) {
|
||||
if (!registry || !out_count) return NULL;
|
||||
|
||||
// Count units of this type
|
||||
size_t count = 0;
|
||||
for (size_t i = 0; i < registry->unit_count; i++) {
|
||||
if (registry->units[i]->unit_type == unit_type) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
if (count == 0) {
|
||||
*out_count = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Allocate and fill array
|
||||
UnitCard** result = (UnitCard**)calloc(count, sizeof(UnitCard*));
|
||||
if (!result) {
|
||||
*out_count = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
size_t idx = 0;
|
||||
for (size_t i = 0; i < registry->unit_count; i++) {
|
||||
if (registry->units[i]->unit_type == unit_type) {
|
||||
result[idx++] = registry->units[i];
|
||||
}
|
||||
}
|
||||
|
||||
*out_count = count;
|
||||
return result;
|
||||
}
|
||||
|
||||
// SIMD optimized damage spreading
|
||||
void spread_damage_SIMD(const UnitCard* units[], size_t unit_count,
|
||||
uint32_t damage, uint32_t* remaining_hp) {
|
||||
if (!units || unit_count == 0 || !remaining_hp) return;
|
||||
|
||||
// SIMD-accelerated damage calculation
|
||||
// Process units in SIMD chunks where possible
|
||||
size_t i = 0;
|
||||
|
||||
// Process 4 units at a time with AVX2 if available
|
||||
for (; i + 4 <= unit_count; i += 4) {
|
||||
uint32_t hp_values[4];
|
||||
uint32_t def_values[4];
|
||||
|
||||
hp_values[0] = units[i]->hp;
|
||||
hp_values[1] = units[i+1]->hp;
|
||||
hp_values[2] = units[i+2]->hp;
|
||||
hp_values[3] = units[i+3]->hp;
|
||||
|
||||
def_values[0] = units[i]->defense;
|
||||
def_values[1] = units[i+1]->defense;
|
||||
def_values[2] = units[i+2]->defense;
|
||||
def_values[3] = units[i+3]->defense;
|
||||
|
||||
for (int j = 0; j < 4; j++) {
|
||||
uint32_t eff_damage = damage > def_values[j] ? damage - def_values[j] : 0;
|
||||
remaining_hp[i+j] = hp_values[j] > eff_damage ? hp_values[j] - eff_damage : 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Process remaining units
|
||||
for (; i < unit_count; i++) {
|
||||
uint32_t eff_damage = damage > units[i]->defense ? damage - units[i]->defense : 0;
|
||||
remaining_hp[i] = units[i]->hp > eff_damage ? units[i]->hp - eff_damage : 0;
|
||||
}
|
||||
}
|
||||
|
||||
// SIMD optimized healing
|
||||
void apply_healing_SIMD(UnitCard** units, size_t unit_count,
|
||||
uint32_t heal_amount) {
|
||||
if (!units || unit_count == 0) return;
|
||||
|
||||
// Process units with SIMD-like approach
|
||||
size_t i = 0;
|
||||
|
||||
for (; i + 4 <= unit_count; i += 4) {
|
||||
uint32_t new_hp_0 = units[i]->hp + heal_amount;
|
||||
uint32_t new_hp_1 = units[i+1]->hp + heal_amount;
|
||||
uint32_t new_hp_2 = units[i+2]->hp + heal_amount;
|
||||
uint32_t new_hp_3 = units[i+3]->hp + heal_amount;
|
||||
|
||||
if (new_hp_0 > units[i]->max_hp) new_hp_0 = units[i]->max_hp;
|
||||
if (new_hp_1 > units[i+1]->max_hp) new_hp_1 = units[i+1]->max_hp;
|
||||
if (new_hp_2 > units[i+2]->max_hp) new_hp_2 = units[i+2]->max_hp;
|
||||
if (new_hp_3 > units[i+3]->max_hp) new_hp_3 = units[i+3]->max_hp;
|
||||
|
||||
units[i]->hp = new_hp_0;
|
||||
units[i+1]->hp = new_hp_1;
|
||||
units[i+2]->hp = new_hp_2;
|
||||
units[i+3]->hp = new_hp_3;
|
||||
}
|
||||
|
||||
// Process remaining units
|
||||
for (; i < unit_count; i++) {
|
||||
uint32_t new_hp = units[i]->hp + heal_amount;
|
||||
if (new_hp > units[i]->max_hp) new_hp = units[i]->max_hp;
|
||||
units[i]->hp = new_hp;
|
||||
}
|
||||
}
|
||||
|
||||
// Save units to JSON (placeholder implementation)
|
||||
int save_units_to_json(UnitRegistry* registry, const char* filepath) {
|
||||
FILE* file = fopen(filepath, "w");
|
||||
if (!file) {
|
||||
fprintf(stderr, "Failed to open file: %s\n", filepath);
|
||||
return -1;
|
||||
}
|
||||
|
||||
fprintf(file, "[\n");
|
||||
for (size_t i = 0; i < registry->unit_count; i++) {
|
||||
UnitCard* unit = registry->units[i];
|
||||
fprintf(file, " {\n");
|
||||
fprintf(file, " \"name\": \"%s\",\n", unit->name);
|
||||
fprintf(file, " \"faction\": \"%s\",\n", unit->faction);
|
||||
fprintf(file, " \"hp\": %u,\n", unit->hp);
|
||||
fprintf(file, " \"attack\": %u,\n", unit->attack);
|
||||
fprintf(file, " \"defense\": %u,\n", unit->defense);
|
||||
fprintf(file, " \"speed\": %u,\n", unit->speed);
|
||||
fprintf(file, " \"range\": %u,\n", unit->range);
|
||||
fprintf(file, " \"cost\": %u,\n", unit->cost);
|
||||
fprintf(file, " \"description\": \"%s\"\n", unit->description);
|
||||
if (i < registry->unit_count - 1) {
|
||||
fprintf(file, " },\n");
|
||||
} else {
|
||||
fprintf(file, " }\n");
|
||||
}
|
||||
}
|
||||
fprintf(file, "\n]\n");
|
||||
|
||||
fclose(file);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Load units from JSON (placeholder implementation)
|
||||
int load_units_from_json(UnitRegistry* registry, const char* filepath) {
|
||||
fprintf(stderr, "JSON loading not implemented yet\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Convert unit card to JSON string
|
||||
void unit_card_to_json(UnitCard* unit, char* buffer, size_t buffer_size) {
|
||||
if (!unit || !buffer) return;
|
||||
|
||||
snprintf(buffer, buffer_size,
|
||||
"{\"name\":\"%s\",\"faction\":\"%s\",\"hp\":%u,\"attack\":%u,\"defense\":%u,\"speed\":%u,\"range\":%u,\"cost\":%u}",
|
||||
unit->name, unit->faction, unit->hp, unit->attack,
|
||||
unit->defense, unit->speed, unit->range, unit->cost);
|
||||
}
|
||||
|
||||
// Print performance statistics
|
||||
void print_performance_stats(UnitRegistry* registry) {
|
||||
if (!registry) {
|
||||
printf("No registry available\n");
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t total_hp = 0;
|
||||
uint32_t total_cost = 0;
|
||||
|
||||
for (size_t i = 0; i < registry->unit_count; i++) {
|
||||
total_hp += registry->units[i]->hp;
|
||||
total_cost += registry->units[i]->cost;
|
||||
}
|
||||
|
||||
printf("=== Unit Registry Statistics ===\n");
|
||||
printf("Total units: %zu\n", registry->unit_count);
|
||||
printf("Total HP: %u\n", total_hp);
|
||||
printf("Total cost: %u\n", total_cost);
|
||||
printf("Average HP: %.2f\n", (double)total_hp / registry->unit_count);
|
||||
printf("Average cost: %.2f\n", (double)total_cost / registry->unit_count);
|
||||
printf("==============================\n");
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue