combat_mode.h File Reference

Declares combat mode state machine, including menus and combat operations. More...

#include "../character/character_fw.h"
#include "../item/potion.h"
#include "ability_fw.h"

Go to the source code of this file.

Enumerations
enum	internal_combat_state_t {   COMBAT_MENU , ABILITY_MENU , POTION_MENU , EVALUATE_COMBAT ,   COMBAT_EXIT }
enum	combat_result_t { CONTINUE_COMBAT , PLAYER_WON , PLAYER_LOST , EXIT_GAME }

Functions
int	init_combat_mode ()
	Initialize the combat mode.
combat_result_t	start_combat (character_t *player, character_t *monster)
	Starts the loop for combat between the player and the monster.
internal_combat_state_t	combat_menu (const character_t *player, const character_t *monster)
	Collects the menu options for the ability menu.
internal_combat_state_t	ability_menu (character_t *player, character_t *monster)
	Collects the menu options for the ability menu.
internal_combat_state_t	potion_menu (character_t *player, character_t *monster)
	Collects the menu options for the potion menu.
void	invoke_potion_effect (character_t *character, potion_t *potion)
	Invoke the effect of a potion on a character.
void	shutdown_combat_mode (void)
	Shuts down the combat mode and frees allocated memory resources.

Detailed Description

Declares combat mode state machine, including menus and combat operations.

Definition in file combat_mode.h.

Enumeration Type Documentation

combat_result_t

enum combat_result_t

Definition at line 20 of file combat_mode.h.

             {
    CONTINUE_COMBAT,
    PLAYER_WON,
    PLAYER_LOST,
    EXIT_GAME
} combat_result_t;

internal_combat_state_t

enum internal_combat_state_t

Definition at line 12 of file combat_mode.h.

             {
    COMBAT_MENU,
    ABILITY_MENU,
    POTION_MENU,
    EVALUATE_COMBAT,// checks if the combat reached an end
    COMBAT_EXIT     // exit combat & game
} internal_combat_state_t;

Function Documentation

ability_menu()

internal_combat_state_t ability_menu	(	character_t *	player,
		character_t *	monster )

Collects the menu options for the ability menu.

Parameters

abilities	Pointer to the player character.
monster	Pointer to the monster character.

Definition at line 209 of file combat_mode.c.

                                                                                {
    clear_screen();
    // draw combat view
    const vector2d_t anchor = draw_combat_view(combat_view_anchor, player, monster, GOBLIN_PNG, GOBLIN_HEIGHT, false);
    int selected_index = 0;
 
    internal_combat_state_t new_state = ABILITY_MENU;
    bool ability_used_or_esc = false;
 
    while (!ability_used_or_esc) {
        // draw menu options
        draw_combat_menu(anchor,
                         combat_mode_strings[ABILITY_MENU_TITLE],
                         ability_menu_options,
                         player->ability_count,
                         selected_index,
                         combat_mode_strings[PRESS_C_RETURN]);
 
        // check for input
        input_event_t input_event;
        if (!get_input_blocking(&input_event)) {
            continue;
        }
 
        // Handle input using logical input types
        switch (input_event.type) {
            case INPUT_UP:
                // Move up
                selected_index = (selected_index - 1 + player->ability_count) % player->ability_count;
                break;
            case INPUT_DOWN:
                // Move down
                selected_index = (selected_index + 1) % player->ability_count;
                break;
            case INPUT_CONFIRM:
                // Use ability
                use_ability(player, monster, player->abilities[selected_index]);
                use_ability(monster, player, get_random_ability(monster));
 
                new_state = EVALUATE_COMBAT;
                ability_used_or_esc = true;
                break;
            case INPUT_CANCEL:
                // go back to the combat menu
                new_state = COMBAT_MENU;
                ability_used_or_esc = true;
                break;
            default:;
        }
    }
    return new_state;
}

combat_menu()

internal_combat_state_t combat_menu	(	const character_t *	player,
		const character_t *	monster )

Collects the menu options for the ability menu.

Parameters

player	Pointer to the player character.
monster	Pointer to the monster character.

Definition at line 156 of file combat_mode.c.

                                                                                           {
    // draw combat view
    const vector2d_t anchor = draw_combat_view(combat_view_anchor, player, monster, GOBLIN_PNG, GOBLIN_HEIGHT, false);
    int selected_index = 0;
 
    internal_combat_state_t new_state = COMBAT_MENU;
    bool submenu_selected = false;
 
    while (!submenu_selected) {
        // draw menu options
        draw_combat_menu(anchor,
                         combat_mode_strings[MAIN_MENU_TITLE],
                         &combat_mode_strings[MAIN_MENU_OPTION1],
                         2,
                         selected_index,
                         NULL);
 
        // check for input
        input_event_t input_event;
        if (!get_input_blocking(&input_event)) {
            continue;
        }
 
        // Handle input using logical input types
        switch (input_event.type) {
            case INPUT_UP:
                // Move up
                selected_index = (selected_index - 1 + 2) % 2;
                break;
            case INPUT_DOWN:
                // Move down
                selected_index = (selected_index + 1) % 2;
                break;
            case INPUT_CONFIRM:
                // Return the selected state
                if (selected_index == 0) {
                    new_state = ABILITY_MENU;
                } else if (selected_index == 1) {
                    new_state = POTION_MENU;
                }
                submenu_selected = true;
                break;
            case INPUT_QUIT:
                // Exit the game
                new_state = COMBAT_EXIT;
                submenu_selected = true;
                break;
            default:;
        }
    }
    return new_state;
}

init_combat_mode()

int init_combat_mode

(

)

Initialize the combat mode.

Returns

int 0 on success, 1 on failure

Note

This function must be called before using any other functions in this module.

This function must be called before using any other functions in this module.

Definition at line 67 of file combat_mode.c.

                       {
    combat_mode_strings = (char**) malloc(MAX_COMBAT_MODE_STRINGS * sizeof(char*));
    RETURN_WHEN_NULL(combat_mode_strings, -1, "Combat Mode", "Allocated memory for combat mode strings in memory pool is NULL");
 
    ability_menu_options = (char**) malloc(sizeof(char*) * MAX_ABILITY_LIMIT);
    if (ability_menu_options == NULL) {
        free(combat_mode_strings);
        combat_mode_strings = NULL;
        log_msg(ERROR, "Combat Mode", "Failed to allocate memory for ability menu options.");
        return -1;
    }
 
    potion_menu_options = (char**) malloc(sizeof(char*) * MAX_POTION_LIMIT);
    if (potion_menu_options == NULL) {
        free(combat_mode_strings);
        combat_mode_strings = NULL;
        free(ability_menu_options);
        log_msg(ERROR, "Combat Mode", "Failed to allocate memory for potion menu options.");
        return -1;
    }
 
    for (int i = 0; i < MAX_COMBAT_MODE_STRINGS; i++) {
        combat_mode_strings[i] = NULL;
    }
 
    for (int i = 0; i < MAX_ABILITY_LIMIT; i++) {
        ability_menu_options[i] = NULL;
    }
 
    for (int i = 0; i < MAX_POTION_LIMIT; i++) {
        potion_menu_options[i] = NULL;
    }
 
    //update local once, so the strings are initialized
    update_combat_local();
    //add update local function to the observer list
    observe_local(update_combat_local);
    return 0;
}

invoke_potion_effect()

void invoke_potion_effect	(	character_t *	character,
		potion_t *	potion )

Invoke the effect of a potion on a character.

Parameters

character	Pointer to the character which uses the potion.
potion	Pointer to which potion to be used.

Definition at line 387 of file combat_mode.c.

                                                                    {
    switch (potion->effectType) {
        case HEALING:
            if (potion->value > (character->max_resources.health - character->current_resources.health)) {
                character->current_resources.health = character->max_resources.health;
            } else {
                character->current_resources.health += potion->value;
            }
            break;
        case MANA:
            if (potion->value > (character->max_resources.mana - character->current_resources.mana)) {
                character->current_resources.mana = character->max_resources.mana;
            } else {
                character->current_resources.mana += potion->value;
            }
            break;
 
        case STAMINA:
            if (potion->value > (character->max_resources.stamina - character->current_resources.stamina)) {
                character->current_resources.stamina = character->max_resources.stamina;
            } else {
                character->current_resources.stamina += potion->value;
            }
            break;
 
        default:
            log_msg(ERROR, "Character", "Unknown potion effect type: %d", potion->effectType);
            break;
    }
    remove_potion(character, potion);
}

potion_menu()

internal_combat_state_t potion_menu	(	character_t *	player,
		character_t *	monster )

Collects the menu options for the potion menu.

Parameters

abilities	Pointer to the player character.
monster	Pointer to the monster character.

Definition at line 262 of file combat_mode.c.

                                                                               {
    // draw combat view
    const vector2d_t anchor = draw_combat_view(combat_view_anchor, player, monster, GOBLIN_PNG, GOBLIN_HEIGHT, false);
    int selected_index = 0;
 
    if (player->potion_count == 0) {
        draw_combat_log(anchor, combat_mode_strings[NO_MORE_POTIONS]);
        return COMBAT_MENU;
    }
 
    internal_combat_state_t new_state = POTION_MENU;
    bool item_used_or_esc = false;
 
    while (!item_used_or_esc) {
        // draw menu options
        draw_combat_menu(anchor,
                         combat_mode_strings[POTION_MENU_TITLE],
                         potion_menu_options,
                         player->potion_count,
                         selected_index,
                         combat_mode_strings[PRESS_C_RETURN]);
 
        // check for input
        input_event_t input_event;
        if (!get_input_blocking(&input_event)) {
            continue;
        }
 
        // Handle input using logical input types
        switch (input_event.type) {
            case INPUT_UP:
                // Move up
                selected_index = (selected_index - 1 + player->potion_count) % player->potion_count;
                break;
            case INPUT_DOWN:
                // Move down
                selected_index = (selected_index + 1) % player->potion_count;
                break;
            case INPUT_CONFIRM:
                // Use the selected potion
                use_potion(player, monster, player->potion_inventory[selected_index]);
                use_ability(monster, player, get_random_ability(monster));
                new_state = EVALUATE_COMBAT;
 
                collect_potion_menu_options(player->potion_inventory, player->potion_count);
                item_used_or_esc = true;
                break;
            case INPUT_CANCEL:
                // Go back to the combat menu
                new_state = COMBAT_MENU;
                item_used_or_esc = true;
                break;
            default:;
        }
    }
    return new_state;
}

shutdown_combat_mode()

void shutdown_combat_mode

(

void

)

Shuts down the combat mode and frees allocated memory resources.

Note

This function deallocates memory associated with combat mode and must be called before exiting the module to prevent memory leaks.

Definition at line 511 of file combat_mode.c.

                            {
    if (combat_mode_strings != NULL) {
        for (int i = 0; i < MAX_COMBAT_MODE_STRINGS; i++) {
            if (combat_mode_strings[i] != NULL) {
                free(combat_mode_strings[i]);
                combat_mode_strings[i] = NULL;
            }
        }
        free(combat_mode_strings);
        combat_mode_strings = NULL;
    }
 
    if (ability_menu_options != NULL) {
        for (int i = 0; i < MAX_ABILITY_LIMIT; i++) {
            if (ability_menu_options[i] != NULL) {
                free(ability_menu_options[i]);
                ability_menu_options[i] = NULL;
            }
        }
        free(ability_menu_options);
        ability_menu_options = NULL;
    }
 
    if (potion_menu_options != NULL) {
        for (int i = 0; i < MAX_POTION_LIMIT; i++) {
            if (potion_menu_options[i] != NULL) {
                free(potion_menu_options[i]);
                potion_menu_options[i] = NULL;
            }
        }
        free(potion_menu_options);
        potion_menu_options = NULL;
    }
}

start_combat()

combat_result_t start_combat	(	character_t *	player,
		character_t *	monster )

Starts the loop for combat between the player and the monster.

Parameters

player	Pointer to the player character.
monster	Pointer to the monster character.

Returns

combat_result_t The result of the combat.

Definition at line 107 of file combat_mode.c.

                                                                        {
    // initial combat state
    const vector2d_t anchor = draw_combat_view(combat_view_anchor, player, monster, GOBLIN_PNG, GOBLIN_HEIGHT, false);
 
    //collect menu options
    collect_ability_menu_options(player->abilities, player->ability_count);
    collect_potion_menu_options(player->potion_inventory, player->potion_count);
 
    switch (combat_state) {
        case COMBAT_MENU:
            combat_state = combat_menu(player, monster);
            break;
        case ABILITY_MENU:
            combat_state = ability_menu(player, monster);
            break;
        case POTION_MENU:
            combat_state = potion_menu(player, monster);
            break;
        case EVALUATE_COMBAT:
            // evaluate the combat result
            if (player->current_resources.health <= 0) {
                media_cleanup();
                draw_game_over();
                return PLAYER_LOST;
            }
            if (monster->current_resources.health <= 0) {
                clear_screen();
                media_cleanup();
 
                char message[MAX_STRING_LENGTH];
                snprintf(message, sizeof(message), "You won the combat! %s is dead.", monster->name);
                draw_combat_log(anchor, message);
 
                player->xp += monster->xp_reward;
                if (player->xp >= calculate_xp_for_next_level(player->level)) {
                    level_up(player);
                }
                return PLAYER_WON;
            }
            clear_screen();
            combat_state = COMBAT_MENU;
            break;
        case COMBAT_EXIT:
            media_cleanup();
            return EXIT_GAME;
    }
    return CONTINUE_COMBAT;
}