gear.c File Reference

Implementation of the gear system. More...

#include "gear.h"
#include "../database/game/item_database.h"
#include "../logging/logger.h"
#include <stdio.h>
#include <stdlib.h>

Go to the source code of this file.

Functions
gear_t *	init_gear (memory_pool_t *memory_pool, const char *name, gear_identifier_t gear_identifier, gear_slot_t slot, stats_t stats, defenses_t defenses, ability_table_t *ability_table, ability_names_t *abilities, int num_abilities)
	Initializes a gear object.
gear_table_t *	init_gear_table (memory_pool_t *memory_pool, const db_connection_t *db_connection, ability_table_t *ability_table)
	Initializes a gear table.
void	free_gear_table (memory_pool_t *memory_pool, gear_table_t *table)
	Frees the memory allocated for a gear table.
const char *	gear_slot_to_string (gear_slot_t slot)
	Converts a gear slot enumeration value to its string representation.

Detailed Description

Implementation of the gear system.

Definition in file gear.c.

Function Documentation

free_gear_table()

void free_gear_table	(	memory_pool_t *	memory_pool,
		gear_table_t *	table )

Frees the memory allocated for a gear table.

This function releases all memory associated with a gear_table_t object, including the memory for each individual gear object and the table itself. It ensures that the memory pool and table pointers are not NULL before attempting to free memory.

Parameters

memory_pool	A pointer to the memory pool used for memory allocation.
table	A pointer to the gear_table_t object to be freed.

Definition at line 74 of file gear.c.

                                                                      {
    NULL_PTR_HANDLER_RETURN(memory_pool, , "Gear", "In free_gear_table memory pool is NULL");
    NULL_PTR_HANDLER_RETURN(table, , "Gear", "In free_gear_table table is NULL");
    for (int i = 0; i < table->num_gears; ++i) {
        gear_t* gear = table->gears[i];
        if (gear != NULL) {
            memory_pool_free(memory_pool, gear);
        }
    }
    memory_pool_free(memory_pool, table);
}

gear_slot_to_string()

const char * gear_slot_to_string

(

gear_slot_t

slot

)

Converts a gear slot enumeration value to its string representation.

This function takes a gear_slot_t enumeration value and returns a human-readable string that represents the corresponding gear slot. If the provided slot does not match any known value, the function returns "Unknown Slot".

Parameters

slot	The gear slot enumeration value of type gear_slot_t.

Returns

A string representing the gear slot. If the slot is invalid, returns "Unknown Slot".

Definition at line 86 of file gear.c.

                                                  {
    switch (slot) {
        case SLOT_HEAD:
            return "Head";
        case SLOT_CHEST:
            return "Chest";
        case SLOT_LEGS:
            return "Legs";
        case SLOT_FEET:
            return "Feet";
        case SLOT_HANDS:
            return "Hands";
        case SLOT_NECK:
            return "Neck";
        case SLOT_FINGER_RIGHT:
            return "Right Finger";
        case SLOT_FINGER_LEFT:
            return "Left Finger";
        case SLOT_LEFT_HAND:
            return "Left Hand";
        case SLOT_RIGHT_HAND:
            return "Right Hand";
        case SLOT_BOTH_HANDS:
            return "Both Hands";
        default:
            return "Unknown Slot";
    }
}

init_gear()

gear_t * init_gear	(	memory_pool_t *	memory_pool,
		const char *	name,
		gear_identifier_t	gear_identifier,
		gear_slot_t	slot,
		stats_t	stats,
		defenses_t	defenses,
		ability_table_t *	ability_table,
		ability_names_t *	abilities,
		int	num_abilities )

Initializes a gear object.

This function creates and initializes a new gear_t object with the specified parameters. It allocates memory, sets the properties of the object, and links it with the provided abilities.

Parameters

memory_pool	A pointer to the memory pool used for memory allocation.
name	The name of the gear as a string.
gear_identifier	The unique identifier of the gear of type gear_identifier_t.
slot	The slot in which the gear will be equipped, of type gear_slot_t.
stats	The base stats of the gear, of type stats_t.
defenses	The defense values of the gear, of type defenses_t.
ability_table	A pointer to the ability table containing the available abilities.
abilities	An array of ability names to be assigned to the gear.
num_abilities	The number of abilities to be assigned to the gear.

Returns

A pointer to the initialized gear_t object or NULL if initialization fails.

Definition at line 14 of file gear.c.

                                                                                                                                                                                                                                        {
    NULL_PTR_HANDLER_RETURN(memory_pool, NULL, "Gear", "In init_gear memory pool is NULL");
    NULL_PTR_HANDLER_RETURN(name, NULL, "Gear", "In init_gear name is NULL");
    gear_t* gear = memory_pool_alloc(memory_pool, sizeof(gear_t));
 
 
    NULL_PTR_HANDLER_RETURN(gear, NULL, "Gear", "Failed to allocate memory for gear: %s", name);
 
    snprintf(gear->local_key, sizeof(gear->local_key), "%s", name);
    gear->gear_identifier = gear_identifier;
    gear->slot = slot;
    gear->stats = stats;
    gear->defenses = defenses;
    gear->num_abilities = num_abilities;
 
    int i = 0;
    for (; i < MAX_ABILITY_PER_GEAR && i < num_abilities; ++i) {
        ability_names_t idx = abilities[i];
        if (idx < MAX_ABILITIES) {
            gear->abilities[i] = &ability_table->abilities[abilities[i]];
        } else {
            gear->abilities[i] = &(ability_t) {0};
        }
    }
    for (; i < MAX_ABILITY_PER_GEAR; ++i) {
        gear->abilities[i] = &(ability_t) {0};
    }
    return gear;
}

init_gear_table()

gear_table_t * init_gear_table	(	memory_pool_t *	memory_pool,
		const db_connection_t *	db_connection,
		ability_table_t *	ability_table )

Initializes a gear table.

This function creates and initializes a gear_table_t object by fetching gear data from the database, allocating memory for the table, and populating it with gear objects.

Parameters

memory_pool	A pointer to the memory pool used for memory allocation.
db_connection	A pointer to the database connection used to fetch gear data.
ability_table	A pointer to the ability table containing the available abilities.

Returns

A pointer to the initialized gear_table_t object or NULL if initialization fails.

Definition at line 45 of file gear.c.

                                                                                                                                {
    NULL_PTR_HANDLER_RETURN(memory_pool, NULL, "Gear", "Memory pool is NULL");
 
    gear_init_t* rows = init_gear_table_from_db(db_connection);
    NULL_PTR_HANDLER_RETURN(rows, NULL, "Gear", "Could not fetch gear data from DB");
 
    int count = count_gear_in_db(db_connection);
 
    gear_table_t* table = memory_pool_alloc(memory_pool, sizeof(gear_table_t));
    NULL_PTR_HANDLER_RETURN(table, NULL, "Gear", "Failed to allocate gear table");
 
    table->num_gears = count;
    NULL_PTR_HANDLER_RETURN(table->gears, NULL, "Gear", "Failed to allocate gear array for table");
 
    for (int i = 0; i < count; ++i) {
        table->gears[i] = init_gear(memory_pool,
                                    rows[i].name,
                                    rows[i].gear_identifier,
                                    rows[i].slot,
                                    rows[i].stats,
                                    rows[i].defenses,
                                    ability_table,
                                    rows[i].ability_names,
                                    rows[i].num_abilities);
    }
    free_gear_table_from_db(rows, db_connection);
    return table;
}