DungeonCrawl
Loading...
Searching...
No Matches
item_database.h File Reference

Declares functions to load and free potion and gear tables from the game database, and count entries. More...

#include "../../combat/ability.h"
#include "../../item/gear.h"
#include "../../item/potion.h"
#include "../database.h"

Go to the source code of this file.

Data Structures

struct  potion_init_t
 To get potion table from the database, we need to define a struct This struct is for the initialization of the potion table The values of the struct corresponds to the init_potion() method in. More...
struct  gear_init_t
 To get gear table from the database, we need to define a struct This struct is for the initialization of the gear table The value of the struct corresponds to the init_gear() method in. More...

Typedefs

typedef struct potion_init_t potion_init_t
 To get potion table from the database, we need to define a struct This struct is for the initialization of the potion table The values of the struct corresponds to the init_potion() method in.
typedef struct gear_init_t gear_init_t
 To get gear table from the database, we need to define a struct This struct is for the initialization of the gear table The value of the struct corresponds to the init_gear() method in.

Functions

potion_init_t * init_potion_table_from_db (const db_connection_t *db_connection)
 Get the potion table from the database.
void free_potion_table_from_db (potion_init_t *potion_init_table, const db_connection_t *db_connection)
 Clean up the potion table Call this function to free the memory allocated for the potion table.
int count_potions_in_db (const db_connection_t *db_connection)
 Count the number of potions in the database.
gear_init_t * init_gear_table_from_db (const db_connection_t *db_connection)
 Get the gear table from the database.
void free_gear_table_from_db (gear_init_t *gear_init_table, const db_connection_t *db_connection)
 Clean up the gear table Call this function to free the memory allocated for the gear table.
int count_gear_in_db (const db_connection_t *db_connection)
 Count the number of gears in the database.

Detailed Description

Declares functions to load and free potion and gear tables from the game database, and count entries.

Definition in file item_database.h.

Typedef Documentation

◆ gear_init_t

typedef struct gear_init_t gear_init_t

To get gear table from the database, we need to define a struct This struct is for the initialization of the gear table The value of the struct corresponds to the init_gear() method in.

See also
{gear.h} &
{gear.c}

◆ potion_init_t

typedef struct potion_init_t potion_init_t

To get potion table from the database, we need to define a struct This struct is for the initialization of the potion table The values of the struct corresponds to the init_potion() method in.

See also
{potion.h} &
{potion.c}

Function Documentation

◆ count_gear_in_db()

int count_gear_in_db ( const db_connection_t * db_connection)

Count the number of gears in the database.

Parameters
db_connectionPointer to the database connection
Returns
int number of gears in the database

Definition at line 206 of file item_database.c.

206 {
207 // Check if the database connection is open
208 if (!db_is_open(db_connection)) {
209 log_msg(ERROR, "Gear", "Database connection is not open");
210 return 0;
211 }
212 // Prepare the SQL statement
213 sqlite3_stmt* stmt_count;
214 int rc = sqlite3_prepare_v2(db_connection->db, SQL_SELECT_COUNT_GEARS, -1, &stmt_count, NULL);
215 if (rc != SQLITE_OK) {
216 log_msg(ERROR, "Gear", "Failed to prepare statement: %s", sqlite3_errmsg(db_connection->db));
217 return 0;
218 }
219 // Execute the statement
220 rc = sqlite3_step(stmt_count);
221 if (rc != SQLITE_ROW) {
222 log_msg(ERROR, "Gear", "Failed to execute statement: %s", sqlite3_errmsg(db_connection->db));
223 sqlite3_finalize(stmt_count);
224 return 0;
225 }
226 // Get the count of gears
227 const int gear_count = sqlite3_column_int(stmt_count, 0);
228 sqlite3_finalize(stmt_count);
229 // Check if there are any gears
230 if (gear_count == 0) {
231 log_msg(ERROR, "Gear", "No gears found in the database");
232 return 0;
233 }
234 return gear_count;
235}
db_is_open
int db_is_open(const db_connection_t *db_connection)
This function is to check if the database is open.
Definition database.c:27
log_msg
void log_msg(const log_level_t level, const char *module, const char *format,...)
Logs a formatted message with a specified log level and module.
Definition logger.c:246

◆ count_potions_in_db()

int count_potions_in_db ( const db_connection_t * db_connection)

Count the number of potions in the database.

Parameters
db_connectionPointer to the database connection
Returns
int number of potions in the database

Definition at line 108 of file item_database.c.

108 {
109 // Check if the database connection is open
110 if (!db_is_open(db_connection)) {
111 log_msg(ERROR, "Potion", "Database connection is not open");
112 return 0;
113 }
114 // Prepare the SQL statement
115 sqlite3_stmt* stmt_count;
116 int rc = sqlite3_prepare_v2(db_connection->db, SQL_SELECT_COUNT_POTIONS, -1, &stmt_count, NULL);
117 if (rc != SQLITE_OK) {
118 log_msg(ERROR, "Potion", "Failed to prepare statement: %s", sqlite3_errmsg(db_connection->db));
119 return 0;
120 }
121 // Execute the statement
122 rc = sqlite3_step(stmt_count);
123 if (rc != SQLITE_ROW) {
124 log_msg(ERROR, "Potion", "Failed to execute statement: %s", sqlite3_errmsg(db_connection->db));
125 sqlite3_finalize(stmt_count);
126 return 0;
127 }
128 // Get the count of potions
129 const int potion_count = sqlite3_column_int(stmt_count, 0);
130 sqlite3_finalize(stmt_count);
131 // Check if there are any potions
132 if (potion_count == 0) {
133 log_msg(ERROR, "Potion", "No potions found in the database");
134 return 0;
135 }
136 return potion_count;
137}

◆ free_gear_table_from_db()

void free_gear_table_from_db ( gear_init_t * gear_init_table,
const db_connection_t * db_connection )

Clean up the gear table Call this function to free the memory allocated for the gear table.

Parameters
gear_init_tablePointer to the gear table
db_connectionPointer to the database connection

Definition at line 196 of file item_database.c.

196 {
197 if (gear_init_table == NULL) { return; }
198
199 for (int i = 0; i < count_gear_in_db(db_connection); i++) {
200 free(gear_init_table[i].name);
201 gear_init_table[i].name = NULL;
202 }
203 free(gear_init_table);
204}
count_gear_in_db
int count_gear_in_db(const db_connection_t *db_connection)
Count the number of gears in the database.
Definition item_database.c:206

◆ free_potion_table_from_db()

void free_potion_table_from_db ( potion_init_t * potion_init_table,
const db_connection_t * db_connection )

Clean up the potion table Call this function to free the memory allocated for the potion table.

Parameters
potion_init_tablePointer to the potion table
db_connectionPointer to the database connection

Definition at line 98 of file item_database.c.

98 {
99 if (potion_init_table == NULL) { return; }
100
101 for (int i = 0; i < count_potions_in_db(db_connection); i++) {
102 free(potion_init_table[i].name);
103 potion_init_table[i].name = NULL;
104 }
105 free(potion_init_table);
106}
count_potions_in_db
int count_potions_in_db(const db_connection_t *db_connection)
Count the number of potions in the database.
Definition item_database.c:108

◆ init_gear_table_from_db()

gear_init_t * init_gear_table_from_db ( const db_connection_t * db_connection)

Get the gear table from the database.

Parameters
db_connectionPointer to the database connection
Returns
gear_init_t* pointer to the gear table

Definition at line 139 of file item_database.c.

139 {
140 // Check if the database connection is open
141 if (!db_is_open(db_connection)) {
142 log_msg(ERROR, "Gear", "Database connection is not open");
143 return NULL;
144 }
145 // Prepare the SQL statement to select all gears
146 sqlite3_stmt* stmt;
147 int rc = sqlite3_prepare_v2(db_connection->db, SQL_SELECT_ALL_GEARS, -1, &stmt, NULL);
148 if (rc != SQLITE_OK) {
149 log_msg(ERROR, "Gear", "Failed to prepare statement: %s", sqlite3_errmsg(db_connection->db));
150 return NULL;
151 }
152 // Count the number of gears in the database
153 const int gear_counted = count_gear_in_db(db_connection);
154 // Allocate memory for the gear table
155 if (gear_counted <= 0) {
156 log_msg(ERROR, "Gear", "No gears found in the database");
157 sqlite3_finalize(stmt);
158 return NULL;
159 }
160 gear_init_t* gear_init_table = malloc(sizeof(gear_init_t) * gear_counted);
161 if (gear_init_table == NULL) {
162 log_msg(ERROR, "Gear", "Failed to allocate memory for gear table");
163 sqlite3_finalize(stmt);
164 return NULL;
165 }
166 // Execute the statement and fetch the results
167 int index = 0;
168 while ((rc = sqlite3_step(stmt)) == SQLITE_ROW && index < gear_counted) {
169 gear_init_table[index].name = strdup((const char*) sqlite3_column_text(stmt, 0));
170 gear_init_table[index].gear_identifier = sqlite3_column_int(stmt, 1);
171 gear_init_table[index].slot = (gear_slot_t) sqlite3_column_int(stmt, 2);
172 gear_init_table[index].defenses.armor = sqlite3_column_int(stmt, 3);
173 gear_init_table[index].defenses.magic_resist = sqlite3_column_int(stmt, 4);
174 gear_init_table[index].stats.strength = sqlite3_column_int(stmt, 5);
175 gear_init_table[index].stats.dexterity = sqlite3_column_int(stmt, 6);
176 gear_init_table[index].stats.intelligence = sqlite3_column_int(stmt, 7);
177 gear_init_table[index].stats.constitution = sqlite3_column_int(stmt, 8);
178 gear_init_table[index].num_abilities = sqlite3_column_int(stmt, 9);
179 gear_init_table[index].ability_names[0] = sqlite3_column_int(stmt, 10);
180 gear_init_table[index].ability_names[1] = sqlite3_column_int(stmt, 11);
181 gear_init_table[index].ability_names[2] = sqlite3_column_int(stmt, 12);
182 gear_init_table[index].ability_names[3] = sqlite3_column_int(stmt, 13);
183 index++;
184 }
185 if (rc != SQLITE_DONE) {
186 log_msg(ERROR, "Gear", "Failed to execute statement: %s", sqlite3_errmsg(db_connection->db));
187 free(gear_init_table);
188 sqlite3_finalize(stmt);
189 return NULL;
190 }
191 // Finalize the statement
192 sqlite3_finalize(stmt);
193 return gear_init_table;
194}
gear_init_t
To get gear table from the database, we need to define a struct This struct is for the initialization...
Definition item_database.h:30

◆ init_potion_table_from_db()

potion_init_t * init_potion_table_from_db ( const db_connection_t * db_connection)

Get the potion table from the database.

Parameters
db_connectionPointer to the database connection
Returns
potion_init_t* pointer to the potion table

Definition at line 51 of file item_database.c.

51 {
52 // Check if the database connection is open
53 if (!db_is_open(db_connection)) {
54 log_msg(ERROR, "Potion", "Database connection is not open");
55 return NULL;
56 }
57
58 // Prepare the SQL statement to select all potions
59 sqlite3_stmt* stmt;
60 int rc = sqlite3_prepare_v2(db_connection->db, SQL_SELECT_ALL_POTIONS, -1, &stmt, NULL);
61 if (rc != SQLITE_OK) {
62 log_msg(ERROR, "Potion", "Failed to prepare statement: %s", sqlite3_errmsg(db_connection->db));
63 return NULL;
64 }
65 // Count the number of potions in the database
66 const int potion_counted = count_potions_in_db(db_connection);
67 // Allocate memory for the potion table
68 if (potion_counted <= 0) {
69 log_msg(ERROR, "Potion", "No potions found in the database");
70 sqlite3_finalize(stmt);
71 return NULL;
72 }
73 potion_init_t* potion_init_table = malloc(sizeof(potion_init_t) * potion_counted);
74 if (potion_init_table == NULL) {
75 log_msg(ERROR, "Potion", "Failed to allocate memory for potion table");
76 sqlite3_finalize(stmt);
77 return NULL;
78 }
79 // Execute the statement and fetch the results
80 int index = 0;
81 while ((rc = sqlite3_step(stmt)) == SQLITE_ROW && index < potion_counted) {
82 potion_init_table[index].potion_type = sqlite3_column_int(stmt, 0);
83 potion_init_table[index].name = strdup((const char*) sqlite3_column_text(stmt, 1));
84 potion_init_table[index].value = sqlite3_column_int(stmt, 2);
85 index++;
86 }
87 if (rc != SQLITE_DONE) {
88 log_msg(ERROR, "Potion", "Failed to execute statement: %s", sqlite3_errmsg(db_connection->db));
89 free(potion_init_table);
90 sqlite3_finalize(stmt);
91 return NULL;
92 }
93 // Finalize the statement
94 sqlite3_finalize(stmt);
95 return potion_init_table;
96}
potion_init_t
To get potion table from the database, we need to define a struct This struct is for the initializati...
Definition item_database.h:18