#include "globals.h"
#include "graphics.h"
#include "parseobject.h"

Include dependency graph for menu.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	menu_item_t

struct	menu_t

Macros
#define	MENU_ITEM_MAX 20

#define	MAX_MENUS 10

#define	MENU_BACKGROUND "Background"

#define	MENU_ITEMS "Items"

#define	MENU_ITEM_SPRITE "sprite"

#define	MENU_ITEM_TEXT "text"

#define	MENU_ITEM_LINK "link"

#define	MENU_ITEM_EXTRA "extra"

#define	MENU_TYPE "Type"

#define	MENU_TYPE_STR_POWER "power_select"

#define	MENU_TYPE_STR_CHOOSE "choose_power"

#define	MENU_TYPE_STR_H "horizontal"

#define	MENU_TYPE_STR_V "vertical"

#define	MENU_TYPE_STR_GRID "grid"

Enumerations
enum	menu_type_t { MENU_TYPE_NULL = 0x0, MENU_TYPE_H = 0x1, MENU_TYPE_V = 0x2, MENU_TYPE_GRID = 0x4, MENU_TYPE_POWER = 0x8, MENU_TYPE_CHOOSE = 0x10, MENU_TYPE_MAX = 0x20 }

Functions
int	InitMenuSystem ()

menu_t *	LoadMenu (object_t object, char g_str, GameState curr_state, GameState previous_state)

menu_t *	FindMenuFromGameState (GameState curr_state)

menu_t *	FindFreeMenu ()

menu_item_t *	FindMenuItem (menu_t menu, char item)

Variables
menu_t *	gMenus

Macro Definition Documentation

#define MAX_MENUS 10

Definition at line 9 of file menu.h.

Referenced by FindFreeMenu(), FindMenuFromGameState(), and InitMenuSystem().

#define MENU_BACKGROUND "Background"

Definition at line 10 of file menu.h.

Referenced by LoadMenu().

#define MENU_ITEM_EXTRA "extra"

Definition at line 15 of file menu.h.

Referenced by LoadMenu().

#define MENU_ITEM_LINK "link"

Definition at line 14 of file menu.h.

Referenced by LoadMenu().

#define MENU_ITEM_MAX 20

Definition at line 8 of file menu.h.

Referenced by LoadMenu().

#define MENU_ITEM_SPRITE "sprite"

Definition at line 12 of file menu.h.

Referenced by LoadMenu().

#define MENU_ITEM_TEXT "text"

Definition at line 13 of file menu.h.

Referenced by LoadMenu().

#define MENU_ITEMS "Items"

Definition at line 11 of file menu.h.

Referenced by LoadMenu().

#define MENU_TYPE "Type"

Definition at line 16 of file menu.h.

Referenced by LoadMenu().

#define MENU_TYPE_STR_CHOOSE "choose_power"

Definition at line 18 of file menu.h.

Referenced by LoadMenu(), and StrToMenuType().

#define MENU_TYPE_STR_GRID "grid"

Definition at line 21 of file menu.h.

Referenced by StrToMenuType().

#define MENU_TYPE_STR_H "horizontal"

Definition at line 19 of file menu.h.

Referenced by StrToMenuType().

#define MENU_TYPE_STR_POWER "power_select"

Definition at line 17 of file menu.h.

Referenced by LoadMenu(), and StrToMenuType().

#define MENU_TYPE_STR_V "vertical"

Definition at line 20 of file menu.h.

Referenced by LoadMenu(), and StrToMenuType().

Enumeration Type Documentation

enum menu_type_t

Defines the enum for what type of menu it is

Enumerator
MENU_TYPE_NULL
MENU_TYPE_H	An enum constant representing the menu type - horizontal
MENU_TYPE_V	An enum constant representing the menu type - vertical
MENU_TYPE_GRID	An enum constant representing the menu type - grid
MENU_TYPE_POWER	An enum constant representing the menu type - half circle for power selection
MENU_TYPE_CHOOSE	An enum constant representing the menu - same as power, but used to differ the menu operations
MENU_TYPE_MAX

Definition at line 24 of file menu.h.

 {
         MENU_TYPE_NULL = 0x0,
         MENU_TYPE_H = 0x1,              /**< An enum constant representing the menu type - horizontal */
         MENU_TYPE_V = 0x2,              /**< An enum constant representing the menu type - vertical */
         MENU_TYPE_GRID = 0x4,   /**< An enum constant representing the menu type - grid */
         MENU_TYPE_POWER = 0x8,  /**< An enum constant representing the menu type - half circle for power selection*/
         MENU_TYPE_CHOOSE = 0x10,        /**< An enum constant representing the menu - same as power, but used to differ the menu operations */
         MENU_TYPE_MAX = 0x20
 
 }menu_type_t;

Function Documentation

menu_t* FindFreeMenu ( )

Searches for the first free menu slot in gMenus, used for loading new menus.

Returns: null if it fails, else the found free menu.

Author: Anthony Rios

Date: 3/30/2016

Definition at line 659 of file menu.c.

References gMenus, and MAX_MENUS.

Referenced by LoadMenu().

 {
         int i, *menuCmp;
         if(!gMenus)
         {
                 printf("Menu System not initialized");
                 return NULL;
         }
         menuCmp = (int*) malloc(sizeof(menu_t));
         memset(menuCmp, 0, sizeof(menu_t));
         for(i = 0; i < MAX_MENUS; i++)
         {
                 if(!memcmp(menuCmp, &gMenus[i], sizeof(menu_t)))
                 {
                         return &gMenus[i];
                 }
         }
         return NULL;
 }

menu_t* FindMenuFromGameState ( GameState curr_state )

Searches for the first menu from game state in gMenus.

Parameters

curr_state State of the curr.

Returns: null if it fails, else the found menu from game state.

Author: Anthony Rios

Date: 3/16/2016

Definition at line 637 of file menu.c.

References gMenus, MAX_MENUS, and Update().

Referenced by LoadMenu().

 {
         int i;
         if(!gMenus)
         {
                 printf("Menu Sys not Initialized");
                 return NULL;
         }
         for(i = 0; i < MAX_MENUS; i++)
         {
                 if(!gMenus[i].Update)
                 {
                         continue;
                 }
                 if(gMenus[i].mCurrentState == curr_state)
                 {
                         return &gMenus[i];
                 }
         }
         return NULL;
 }

menu_item_t* FindMenuItem	(	menu_t *	menu,
		char *	item
	)

Searches for the first menu item, with name of str given.

Parameters

[in,out]	menu	If non-null, the menu.
[in,out]	item	If non-null, the item.

Returns: null if it fails, else the found menu item.

Author: Anthony Rios

Date: 3/30/2016

Definition at line 679 of file menu.c.

References CountMem().

Referenced by LoadMenu().

 {
         int i, items;
         items = CountMem(menu->mItems, sizeof(menu_item_t));
         for(i = 0; i < items; i++)
         {
                 if(!menu->mItems[i].Name)
                 {
                         continue;
                 }
                 if(!strcmp(item, menu->mItems[i].Name))
                 {
                         return &menu->mItems[i];
                 }
         }
         return NULL;
 }

int InitMenuSystem ( )

Allocate memor for menu system, gMenus is the menu list.

Author: Anthony Rios

Date: 3/16/2016

Definition at line 299 of file menu.c.

References gMenus, and MAX_MENUS.

Referenced by LoadMenuData(), and Setup().

 {
         if(gMenus)
         {
                 printf("gMenus already initialized");
                 return -1;
         }
         gMenus = (menu_t*) malloc(sizeof(menu_t)*MAX_MENUS);
         if(!gMenus)
         {
                 printf("Allocate menu error");
                 return -1;
         }
         memset(gMenus, 0, sizeof(menu_t)*MAX_MENUS);
         return 0;
 }

menu_t* LoadMenu	(	object_t *	object,
		char *	g_str,
		GameState	curr_state,
		GameState	previous_state
	)

Loads a menu.

Parameters

[in,out]	object	If non-null, the object menu was parsed to.
[in,out]	g_str	If non-null, the string.
	curr_state	State to assign the menu.
	previous_state	State before this menu.

Returns: 0 if loads correctly, -1 if it doesn't.

Author: Anthony Rios

Date: 3/16/2016

Definition at line 478 of file menu.c.

References CountMem(), CountObjectChildren(), DrawMenuByNum(), DrawMenuByState(), FindFreeMenu(), FindMenuFromGameState(), FindMenuItem(), FindObject(), FindValue(), gSelectedPowerUps, GUESS, LoadSprite(), MENU_BACKGROUND, MENU_ITEM_EXTRA, MENU_ITEM_LINK, MENU_ITEM_MAX, MENU_ITEM_SPRITE, MENU_ITEM_STATE_NOT_SELECTED, MENU_ITEM_STATE_SELECTED, MENU_ITEM_TEXT, MENU_ITEMS, MENU_TYPE, MENU_TYPE_STR_CHOOSE, MENU_TYPE_STR_POWER, MENU_TYPE_STR_V, PLAYING, ProcessMenuItemsByType(), SPLASH, StrToGameState(), StrToMenuType(), UpdatePowerSelectMenu(), UpdatePowerUpMenu(), and UpdateVerticalMenu().

Referenced by LoadMenuData(), and UpdatePowerUpMenu().

 {
         menu_t *menu, *ref_menu;
         menu_item_t *ref_menu_item;
         object_t *temp_obj;
         char *temp_str, *type_str, *bg_str;
         int i, temp_i, choose_i;
 
         //Check Vars given
         if(!object || !g_str)
         {
                 printf("No object / str given to load menu \n");
                 return NULL;
         }
 
         //Look for free menu slot
         menu = FindFreeMenu();
         if(!menu)
         {
                 printf("Could not find free menu \n");
                 return NULL;
         }
 
         menu->mPreviousState = previous_state;
         menu->mCurrentState = curr_state;
 
         temp_obj = FindObject(object, MENU_ITEMS);
         if(!temp_obj)
         {
                 printf("No items in menu %s \n", object->name);
                 return NULL;
         }
 
         //Load Background
         bg_str = FindValue(object, MENU_BACKGROUND, g_str);
         if(!bg_str)
         {
                 printf("No background loaded for menu %s \n", object->name);
         } else 
         {
                 menu->mBackground = LoadSprite(bg_str, 0);
         }
 
         //Check menu type
         type_str = FindValue(object, MENU_TYPE, g_str);
         if(!type_str)
         {
                 printf("Not found menu layout type for %s. Switching to default vertical layout", object->name);
                 type_str = strdup(MENU_TYPE_STR_V);
         }
 
         //Load Items
         temp_i = CountObjectChildren(temp_obj);
         if(temp_i >= MENU_ITEM_MAX)
         {
                 printf("Max menu items for menu %s \n", object->name);
                 temp_i = MENU_ITEM_MAX -1;
         }
 
         menu->mItemCount = temp_i;
         for(i = 0; i < temp_i; i++)
         {
                 menu->mItems[i].State = MENU_ITEM_STATE_NOT_SELECTED;
                 menu->mItems[i].Info = NULL;
 
                 temp_str = FindValue(&temp_obj->children[i], MENU_ITEM_SPRITE, g_str);
                 if(temp_str)
                 {
                         menu->mItems[i].Image = LoadSprite(temp_str, 0);
                 }
 
                 temp_str = FindValue(&temp_obj->children[i], MENU_ITEM_TEXT, g_str);
                 if(temp_str)
                 {
                         menu->mItems[i].Name = temp_str;
                 }
 
                 temp_str = FindValue(&temp_obj->children[i], MENU_ITEM_LINK, g_str);
                 if(temp_str)
                 {
                         menu->mItems[i].NextState = StrToGameState(temp_str);
                         if(temp_str) free(temp_str);
                 } else
                 {
                         menu->mItems[i].NextState = SPLASH;
                 }
 
                 temp_str = FindValue(&temp_obj->children[i], MENU_ITEM_EXTRA, g_str);
                 if(temp_str)
                 {
                         menu->mItems[i].Info = temp_str;
                         if(!menu->mItems[i].Name)
                         {
                                 menu->mItems[i].Name = temp_str;
                         }
                 } else
                 {
                         menu->mItems[i].Info = NULL;
                 }
                 
         }
 
         //Load extra items
         if(!strcmp(type_str, MENU_TYPE_STR_CHOOSE))
         {
                 
                 choose_i = CountMem(gSelectedPowerUps, sizeof(char*));
                 ref_menu = FindMenuFromGameState(GUESS);
                 if(!ref_menu)
                 {
                         printf("Trouble loading choose menu , no GUESS menu found \n");
                 }
                 else
                 {
                         for(i = 0; i < choose_i; i++)
                         {
                                 ref_menu_item = FindMenuItem(ref_menu, gSelectedPowerUps[i]);
                                 if(!ref_menu_item)
                                 {
                                         continue;
                                 }
                                 memcpy(&menu->mItems[menu->mItemCount+i], ref_menu_item, sizeof(menu_item_t));
                                 menu->mItems[menu->mItemCount+i].State = MENU_ITEM_STATE_NOT_SELECTED;
                                 menu->mItems[menu->mItemCount+i].NextState = PLAYING;
                         }
                         menu->mItemCount += choose_i;
                 }
                 
         }
 
         //Calculate Menu Item Positions
         ProcessMenuItemsByType(menu->mItems, (menu_type_t) StrToMenuType(type_str));
         menu->mSelectedItem = menu->mItems;
         menu->mSelectedItem->State = MENU_ITEM_STATE_SELECTED;
         //gCurrentSelectedItem = 0;
 
         //Set Up Different Menu Types
         if(!strcmp(type_str, MENU_TYPE_STR_V))
         {
                 menu->Update = UpdateVerticalMenu;
                 menu->Draw = DrawMenuByNum;
         } else if(!strcmp(type_str, MENU_TYPE_STR_POWER))
         {
                 menu->Update = UpdatePowerUpMenu;
                 menu->Draw = DrawMenuByState;
         } else if (!strcmp(type_str, MENU_TYPE_STR_CHOOSE))
         {
                 menu->Update = UpdatePowerSelectMenu;
                 menu->Draw = DrawMenuByState;
         } else
         {
                 menu->Update = UpdateVerticalMenu;
                 menu->Draw = DrawMenuByNum;
         }
 
         return menu;
 
 }

Variable Documentation

menu_t* gMenus

Definition at line 12 of file menu.c.

Referenced by DrawChoose(), DrawGuess(), DrawStart(), FindFreeMenu(), FindMenuFromGameState(), InitMenuSystem(), LoadMenuData(), and Update().

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation