static bool GetQuantityMenuInfo_Execute(COMMAND_ARGS, UInt32 which)
{
QuantityMenu* menu = (QuantityMenu*)GetMenuByType(kMenuType_Quantity);
if (menu) {
switch (which) {
case kQuantityMenu_Max:
*result = menu->maxQuantity;
DEBUG_PRINT("GetQMMaximum >> %d", menu->maxQuantity);
return true;
case kQuantityMenu_Cur:
{
if (menu->quantity_scroll) {
Tile::Value* val = menu->quantity_scroll->GetValueByType(kTileValue_user7);
if (val) {
*result = val->num;
DEBUG_PRINT("GetQMCurrent >> %.0f", val->num);
}
}
}
return true;
case kQuantityMenu_Item:
{
TESForm* item = NULL;
UInt32* refResult = (UInt32*)result;
*refResult = 0;
if (menu->itemTile) {
Tile::Value* val = menu->itemTile->GetValueByType(kTileValue_user11);
if (val) {
UInt32 idx = val->num;
// are we bartering? and what container is open?
bool bMerchant = false;
TESObjectREFR* container = *g_thePlayer;
if (menu->unk44 == 0x33) {
ContainerMenu* contMenu = (ContainerMenu*)GetMenuByType(kMenuType_Container);
container = contMenu->isContainerContents ? contMenu->refr : container;
bMerchant = contMenu && contMenu->isContainerContents && contMenu->isBarter;
}
item = container->GetInventoryItem(idx, bMerchant);
*refResult = item ? item->refID : 0;
DEBUG_PRINT("GetQMItem >> %s", GetFullName(item));
}
}
}
return true;
}
}
return true;
}
void TextInputMessageBox::Update()
{
std::string text = m_promptText + m_inputText;
MessageMenu* msgBox = (MessageMenu*)GetMenuByType(kMenuType_Message);
if (!msgBox) //original msgBox was closed/overwritten
{
Init(); //so re-display it
msgBox = (MessageMenu*)GetMenuByType(kMenuType_Message);
}
else if (*ShowMessageBox_pScriptRefID != m_scriptRefID || !msgBox->IsScriptMessageBox())
return; // someone else is displaying a messagebox, let's not interfere
msgBox->messageText->SetStringValue(kTileValue_string, text.c_str());
msgBox->messageText->UpdateField(kTileValue_string, 0.0, text.c_str());
}
static bool Cmd_GetMapMarkers_Execute(COMMAND_ARGS)
{
UInt32 inclHidden = 1;
UInt32 markerType = 0;
ArrayID arr = g_ArrayMap.Create(kDataType_Numeric, true, scriptObj->GetModIndex());
*result = arr;
if(ExtractArgs(PASS_EXTRACT_ARGS, &inclHidden, &markerType))
{
std::vector<TESObjectREFR*> vec;
MapMenu* mapMenu = (MapMenu*)GetMenuByType(kMenuType_Map);
for (MapMenu::MapMarkerEntry* cur = mapMenu->mapMarkers; cur && cur->mapMarker; cur = cur->next){
ExtraMapMarker* markerExtra = (ExtraMapMarker*)cur->mapMarker->baseExtraList.GetByType(kExtraData_MapMarker);
UInt32 isVisible = markerExtra->IsVisible();
UInt32 canTravel = markerExtra->CanTravelTo();
if(!markerType || markerType == markerExtra->data->type){
if ((inclHidden == 0 && isVisible && canTravel) || (inclHidden == 1 && isVisible) || inclHidden == 2){
//It seems that disabled mapmarkers are considered visible so an extra check is needed
if(!cur->mapMarker->IsDisabled() || inclHidden == 2){
vec.push_back(cur->mapMarker);
}
}
}
}
//We wanna reverse the array to make it easier to combine with the GetMenuChildXXXValue functions
std::reverse(vec.begin(), vec.end());
for (UInt32 i = 0; i < vec.size(); i++) {
g_ArrayMap.SetElementFormID(arr, (double)i, vec[i]->refID);
}
}
return true;
}
bool TextInputJournal::IsOpen() const
{
BookMenu* bookMenu = (BookMenu*)GetMenuByType(kMenuType_Book);
if (bookMenu && bookMenu->book == m_dummyBook)
return true;
else
return false;
}
static bool Cmd_IsGameMessageBox_Execute(COMMAND_ARGS)
{
*result = 0;
MessageMenu* menu = (MessageMenu*)GetMenuByType(kMenuType_Message);
if (menu) // if not game generated, expression is true
*result = (menu->buttonCallback == ShowMessageBox_Callback) ? 0 : 1;
return true;
}
TextInputMessageBox::~TextInputMessageBox()
{
ToggleMenuShortcutKeys(true);
MessageMenu* menu = (MessageMenu*)GetMenuByType(kMenuType_Message);
if (menu)
menu->HandleClick(menu->kButtonID_Close, 0); //closes the menu
delete[] m_fmtString;
}
TextInputJournal::~TextInputJournal()
{
ToggleMenuShortcutKeys(true);
BookMenu* menu = (BookMenu*)GetMenuByType(kMenuType_Book);
if (menu)
menu->HandleClick(menu->kButtonID_Exit, 0); //closes the menu
m_dummyBook->Destroy(false);
}
void TextInputJournal::Init()
{
//TODO: Turn creation of menus into a template function?
InterfaceManager* intfc = InterfaceManager::GetSingleton();
// Is BookMenu already open?
BookMenu* bookMenu = (BookMenu*)GetMenuByType(kMenuType_Book);
if (bookMenu) // open, so get rid of it first
bookMenu->Destructor(1);
// create new book menu
Tile* tile = intfc->menuRoot->ReadXML("data\\menus\\book_menu.xml");
if (tile)
{
Tile* bookRoot = tile->GetRoot();
if (bookRoot)
{
TileMenu* bookMenuTile = tile_cast <TileMenu>(bookRoot);
if (bookMenuTile)
{
BookMenu* bookMenu = (BookMenu*)(bookMenuTile->menu);
if (bookMenu)
{
bookMenu->book = m_dummyBook;
bookMenu->bookRef = NULL;
ToggleMenuShortcutKeys(false, bookMenu);
bookMenu->RegisterTile(bookMenuTile);
// update depth
Tile* backgroundTile = NULL;
if (m_dummyBook->IsScroll())
backgroundTile = bookMenu->tile->GetChildByName("book_background_scroll");
else
backgroundTile = bookMenu->tile->GetChildByName("book_background");
Tile::Value* depthVal = backgroundTile->GetValueByType(kTileValue_depth);
if (depthVal)
{
backgroundTile->UpdateFloat(kTileValue_depth, depthVal->num + intfc->GetDepth());
depthVal->num += intfc->GetDepth();
}
if (!m_dummyBook->IsScroll())
bookMenu->tile->UpdateFloat(BookMenu::kBookValue_IsBook, 2.0);
bookMenu->EnableMenu(false);
bookMenu->UpdateText(m_inputText.c_str());
}
}
}
}
}
static bool Cmd_GetMapMenuMarkerName_Execute(COMMAND_ARGS)
{
const char* name = "";
MapMenu* mapMenu = (MapMenu*)GetMenuByType(kMenuType_Map);
if (mapMenu)
name = mapMenu->GetSelectedMarkerName();
AssignToStringVar(PASS_COMMAND_ARGS, name);
return true;
}
static bool Cmd_SetButtonPressed_Execute(COMMAND_ARGS)
{
UInt32 button = 0;
if (ExtractArgs(PASS_EXTRACT_ARGS, &button))
{
MessageMenu* menu = (MessageMenu*)GetMenuByType(kMenuType_Message);
if (menu)
menu->HandleClick(menu->kButtonID_Button1 + button, 0);
}
return true;
}
static Tile* ExtractMenuComponent(COMMAND_ARGS, const char* componentNameBuffer)
{
UInt32 menuType = 0;
Tile* tile = NULL;
if (ExtractArgs(PASS_EXTRACT_ARGS, componentNameBuffer, &menuType))
{
Menu* menu = GetMenuByType(menuType);
if (menu)
tile = menu->GetComponentByName(componentNameBuffer);
}
return tile;
}
static bool Cmd_GetBarterItem_Execute(COMMAND_ARGS)
{
UInt32* refResult = (UInt32*)result;
*refResult = 0;
ContainerMenu* contMenu = (ContainerMenu*)GetMenuByType(kMenuType_Container);
if (contMenu) {
TESForm* item = contMenu->GetItem();
if (item) {
*refResult = item->refID;
}
}
return true;
}
static bool Cmd_GetEnchMenuBaseItem_Execute(COMMAND_ARGS)
{
UInt32* refResult = (UInt32*)result;
*refResult = 0;
EnchantmentMenu* theMenu = (EnchantmentMenu*)GetMenuByType(kMenuType_Enchantment);
if (theMenu && theMenu->enchantableInfo){
TESForm* item = theMenu->enchantableInfo->form;
if(item){
*refResult = item->refID;
}
}
if(IsConsoleMode())
Console_Print("GetEnchMenuBaseItem >> (%08x)", *refResult);
return true;
}
static bool Cmd_GetClassMenuSelectedClass_Execute(COMMAND_ARGS)
{
UInt32* refResult = (UInt32*)result;
*refResult = 0;
ClassMenu* theMenu = (ClassMenu*)GetMenuByType(kMenuType_Class);
if (theMenu){
TESClass* theClass = theMenu->selectedClass;
if (theClass) {
*refResult = theClass->refID;
}
}
if(IsConsoleMode())
Console_Print("GetSelectedClass >> (%08X)", *refResult);
return true;
}
static bool Cmd_GetMapMenuMarkerRef_Execute(COMMAND_ARGS)
{
UInt32* refResult = (UInt32*)result;
*refResult = 0;
MapMenu* mapMenu = (MapMenu*)GetMenuByType(kMenuType_Map);
if (mapMenu)
{
TESObjectREFR* markerRef = mapMenu->GetSelectedMarker();
if (markerRef)
{
*refResult = markerRef->refID;
if (IsConsoleMode())
Console_Print("GetMapMenuMarkerRef >> %s (%08X)", GetFullName(markerRef), markerRef->refID);
}
}
return true;
}
static bool Cmd_ClickMenuButton_Execute(COMMAND_ARGS)
{
UInt32 menuType;
char name[kMaxMessageLength] = { 0 };
if (ExtractFormatStringArgs(0, name, paramInfo, arg1, opcodeOffsetPtr, scriptObj, eventList, kCommandInfo_GetMenuFloatValue.numParams, &menuType))
{
Menu* menu = GetMenuByType(menuType);
if (menu && name)
{
UInt32 buttonID = 0;
Tile* parentTile = NULL;
if (name[0] == '#') // component specified by ID rather than name
{
buttonID = atoi(name + 1);
parentTile = menu->tile->GetChildByIDTrait(buttonID);
}
else // roundabout way of getting a button tile - look up the <id> trait then take the parent tile
{
UInt32 nameLen = strlen(name);
name[nameLen] = '\\';
name[nameLen+1] = 'i';
name[nameLen+2] = 'd';
name[nameLen+3] = '\0';
Tile::Value* val = menu->tile->GetValueByName(name);
if (val)
{
buttonID = val->num;
parentTile = val->parentTile;
}
}
//DEBUG_PRINT("Parent Tile: %08x, ID: %d", parentTile, buttonID);
if (parentTile)
menu->HandleClick(buttonID, parentTile);
}
}
return true;
}
void TextInputMessageBox::Init()
{
char* buttons[10] = { NULL };
UInt32 numButtons = 0;
UInt32 fmtStringLen = strlen(m_fmtString);
char* fmtString = new char[fmtStringLen + 1];
strcpy_s(fmtString, fmtStringLen + 1, m_fmtString);
//separate prompt text and button text
for (UInt32 strPos = 0; strPos < fmtStringLen && numButtons < 10; strPos++)
{
if (fmtString[strPos] == GetSeparatorChar(m_script) && (strPos + 1 < fmtStringLen))
{
fmtString[strPos] = '\0';
buttons[numButtons++] = fmtString + strPos + 1;
}
}
m_promptText = fmtString;
if (!buttons[0]) //supply default button if none specified
buttons[0] = "Finished";
//now display the messagebox
ShowMessageBox(fmtString, ShowMessageBox_Callback, 0, buttons[0], buttons[1], buttons[2], buttons[3], buttons[4],
buttons[5], buttons[6], buttons[7], buttons[8], buttons[9], 0);
//Register it with the game so scripts can pick up button pressed
*ShowMessageBox_pScriptRefID = m_scriptRefID;
*ShowMessageBox_button = -1;
//Disable menu shortcut keys so they don't interfere with typing
if (!m_bShortcutsDisabled)
{
m_bShortcutsDisabled = true;
ToggleMenuShortcutKeys(false, GetMenuByType(kMenuType_Message));
}
}
void TextInputJournal::Update()
{
BookMenu* bookMenu = (BookMenu*)GetMenuByType(kMenuType_Book);
if (bookMenu && bookMenu->book == m_dummyBook)
bookMenu->UpdateText((m_promptText + m_inputText).c_str());
}
static bool Cmd_GetClassMenuHighlightedClass_Execute(COMMAND_ARGS)
{
UInt32* refResult = (UInt32*)result;
*refResult = 0;
// make sure the user is actually doing class selection
ClassMenu* theMenu = (ClassMenu*)GetMenuByType(kMenuType_Class);
if (!theMenu){
if(IsConsoleMode())
Console_Print("GetHighlightedClass >> Class menu not open");
return true;
}
Tile* tile = NULL;
tile = InterfaceManager::GetSingleton()->activeTile;
if (!tile){
if(IsConsoleMode())
Console_Print("GetHighlightedClass >> Not selecting a class");
return true;
}
if (strcmp(tile->parent->GetQualifiedName().c_str(), "class_background\\class_list_window\\class_list_pane")){
if(IsConsoleMode())
Console_Print("GetHighlightedClass >> Not selecting a class");
return true;
}
// get the name of the highlighted class
const char* className;
tile->GetStringValue(kTileValue_user1, &className);
// ClassMenu doesn't have a convenient pointer to the highlighted class?
// So grab the class info from the menu.
float specialization;
theMenu->tile->GetFloatValue(kTileValue_user18, &specialization);
float attributes[2];
theMenu->tile->GetFloatValue(kTileValue_user19, &attributes[0]);
theMenu->tile->GetFloatValue(kTileValue_user20, &attributes[1]);
float skills[7];
theMenu->tile->GetFloatValue(kTileValue_user11, &skills[0]);
theMenu->tile->GetFloatValue(kTileValue_user12, &skills[1]);
theMenu->tile->GetFloatValue(kTileValue_user13, &skills[2]);
theMenu->tile->GetFloatValue(kTileValue_user14, &skills[3]);
theMenu->tile->GetFloatValue(kTileValue_user15, &skills[4]);
theMenu->tile->GetFloatValue(kTileValue_user16, &skills[5]);
theMenu->tile->GetFloatValue(kTileValue_user17, &skills[6]);
// iterate over all classes in the game to find one that matches
DataHandler::Node<TESClass> *classNode = &(*g_dataHandler)->classes;
TESClass* theClass = NULL;
while(classNode && classNode->data){
theClass = classNode->data;
if(theClass->IsPlayable()){
if(!strcmp(theClass->GetFullName()->name.m_data, className)){
if(theClass->specialization == (UInt32)specialization){
if(theClass->attributes[0] == (UInt32)attributes[0] && theClass->attributes[1] == (UInt32)attributes[1]){
bool bAttributesMatch = true;
for (UInt32 i = 0; i < 7; i++) {
if (theClass->majorSkills[i] != skills[i]) {
bAttributesMatch = false;
break;
}
}
if (bAttributesMatch) {
*refResult = theClass->refID;
break;
}
}
}
}
}
classNode = classNode->next;
}
if(IsConsoleMode())
Console_Print("GetHighlightedClass >> (%08X)", *refResult);
return true;
}
static bool GetSetMenuValue_Execute(COMMAND_ARGS, UInt32 mode)
{
const char* separatorChar = GetSeparatorChars(scriptObj);
char stringArg[kMaxMessageLength] = { 0 };
UInt32 menuType = 0;
float newFloatVal = 0;
char* newStringVal = NULL;
char* componentPath = stringArg;
bool bExtracted = false;
switch (mode)
{
case kGetFloat:
case kGetString:
case kExists:
bExtracted = ExtractFormatStringArgs(0, stringArg, paramInfo, arg1, opcodeOffsetPtr, scriptObj, eventList, kCommandInfo_GetMenuFloatValue.numParams, &menuType);
break;
case kSetFloat:
bExtracted = ExtractFormatStringArgs(0, stringArg, paramInfo, arg1, opcodeOffsetPtr, scriptObj, eventList, kCommandInfo_SetMenuFloatValue.numParams, &menuType, &newFloatVal);
break;
case kSetString:
{
bExtracted = ExtractFormatStringArgs(0, stringArg, paramInfo, arg1, opcodeOffsetPtr, scriptObj, eventList, kCommandInfo_GetMenuFloatValue.numParams, &menuType);
// extract new value from format string
char* context = NULL;
componentPath = strtok_s(stringArg, separatorChar, &context);
newStringVal = strtok_s(NULL, separatorChar, &context);
bExtracted = (bExtracted && componentPath && newStringVal);
}
break;
}
char* strToAssign = "";
if (bExtracted)
{
Menu* menu = GetMenuByType(menuType);
if (menu && menu->tile)
{
Tile::Value* val = menu->tile->GetValueByName(componentPath);
if (val)
{
#if _DEBUG && 0
val->DumpExpressionList();
#endif
switch (mode)
{
case kExists:
*result = 1;
break;
case kGetFloat:
if (val->IsNum())
*result = val->num;
break;
case kSetFloat:
val->bIsNum = 1;
val->parentTile->UpdateFloat(val->id, newFloatVal);
break;
case kGetString:
if (val->IsString())
strToAssign = val->str.m_data;
break;
case kSetString:
val->bIsNum = 0;
val->parentTile->UpdateString(val->id, newStringVal);
val->parentTile->SetStringValue(val->id, newStringVal);
val->parentTile->UpdateField(val->id, 0, newStringVal);
break;
}
}
}
}
if (mode == kGetString) // need to assign even if errors occur during arg extraction/value retrieval
AssignToStringVar(PASS_COMMAND_ARGS, strToAssign);
return true;
}
static bool Cmd_GetMessageBoxType_Execute(COMMAND_ARGS)
{
*result = kMsgBox_Unknown;
MessageMenu* menu = (MessageMenu*)GetMenuByType(kMenuType_Message);
if (!menu || !menu->buttonCallback || !menu->messageText)
return true;
const char* msg = NULL;
if (!menu->messageText->GetStringValue(kTileValue_string, &msg) || !msg)
return true;
std::string msgText(msg);
SettingInfo* setting = NULL;
if (menu->buttonCallback == NULL)
{
if (GetGameSetting("sNoRepairMagic", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_NoRepairMagic;
}
else if (menu->buttonCallback == ShowMessageBox_Callback)
{
*result = kMsgBox_Script;
}
else if (menu->buttonCallback == ContainerMenuCallback)
{
if (GetGameSetting("sBuy", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_BuyItem;
else if (GetGameSetting("sSell", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_SellItem;
else if (GetGameSetting("sGiveAway", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_GiveItem;
}
else if (menu->buttonCallback == SpellPurchaseCallback)
{
if (GetGameSetting("sConfirmBuySpell", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_BuySpell;
}
else if (menu->buttonCallback == PoisonConfirmCallback)
{
if (GetGameSetting("sPoisonConfirmMessage", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_PoisonWeapon;
else if (GetGameSetting("sPoisonBowConfirmMessage", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_PoisonWeapon;
}
else if (menu->buttonCallback == OverwriteSaveGameCallback)
{
if (GetGameSetting("sSaveOverSaveGame", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_OverwriteGame;
}
else if (menu->buttonCallback == LoadGameCallback)
{
if (GetGameSetting("sLoadFromMainMenu", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_LoadGame;
else if (GetGameSetting("sLoadWhilePlaying", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_LoadGame;
}
else if (menu->buttonCallback == MissingContentCallback)
{
if (GetGameSetting("sSaveGameContentIsMissing", &setting) && msgText.find(setting->s) == 0)
*result = kMsgBox_MissingContent;
}
if (IsConsoleMode())
Console_Print("GetMessageBoxType >> %.0f", *result);
return true;
}
static bool GetActiveMenuElement(COMMAND_ARGS, eMenuValue whichValue, MenuInfo* out, UInt32 whichMenu = 0)
{
InterfaceManager* intfc = InterfaceManager::GetSingleton();
Menu* activeMenu = intfc->activeMenu;
Tile* activeTile = intfc->activeTile;
if (!activeTile) {
// theoretically this is active tile if user is navigating by keyboard - for this to work user must pass whichMenu arg
activeTile = intfc->altActiveTile;
}
bool gotValue = false;
UInt32 intArg = -1;
//Extract arguments
if (whichValue < kMenu_Ingredient && whichValue >= kMenu_Selection) //optional int param specifies menu type
{
ExtractArgs(EXTRACT_ARGS, &intArg);
if (intArg != -1)
activeMenu = GetMenuByType(intArg);
}
else if (whichValue >= kMenu_Ingredient)
{
ExtractArgs(EXTRACT_ARGS, &intArg);
if (intArg == -1)
return false;
}
if (whichMenu) //specific menu, so look it up directly
activeMenu = GetMenuByType(whichMenu);
if (!activeMenu)
return false;
//get element based on menu type
switch (activeMenu->id)
{
case kMenuType_Message:
{
MessageMenu* msgMenu = (MessageMenu*)activeMenu;
switch (whichValue)
{
case kMenu_Object:
if (ShowMessageBox_pScriptRefID && msgMenu->IsScriptMessageBox())
{
out->form = LookupFormByID(*ShowMessageBox_pScriptRefID);
gotValue = true;
}
else
out->form = 0;
default:
break;
}
}
break;
case kMenuType_Alchemy:
{
AlchemyMenu* menu = (AlchemyMenu*)activeMenu;
switch (whichValue)
{
case kMenu_Object:
out->form = menu->potion;
gotValue = true;
break;
case kMenu_Ingredient:
out->form = menu->GetIngredientItem(intArg);
gotValue = true;
break;
case kMenu_IngredientCount:
out->integer = menu->GetIngredientCount(intArg);
gotValue = true;
break;
case kMenu_Apparatus:
out->form = menu->GetApparatus(intArg);
gotValue = true;
break;
default:
break;
}
}
break;
case kMenuType_Container:
{
ContainerMenu* menu = (ContainerMenu*)activeMenu;
switch (whichValue)
{
case kMenu_ContainerView:
if (menu->isContainerContents)
out->integer = 0;
else
out->integer = 1;
gotValue = true;
break;
case kMenu_Ref:
{
out->form = menu->refr;
gotValue = true;
break;
}
case kMenu_Filter:
out->integer = menu->filterType;
gotValue = true;
break;
case kMenu_Selection:
{
if (activeTile)
{
float fIndex;
if (activeTile->GetFloatValue(kTileValue_user11, &fIndex))
{
UInt32 index = fIndex;
if (menu->isContainerContents)
out->form = menu->refr->GetInventoryItem(index, menu->isBarter);
else
out->form = (*g_thePlayer)->GetInventoryItem(index, 0);
gotValue = true;
}
}
}
break;
case kMenu_Barter:
out->integer = menu->isBarter;
gotValue = true;
break;
default:
break;
}
break;
}
case kMenuType_Magic:
{
MagicMenu* menu = (MagicMenu*)activeMenu;
switch (whichValue)
{
case kMenu_Selection:
{
if (activeTile && menu->filterType != MagicMenu::kFilter_ActiveEffects)
{
float fIndex;
if (activeTile->GetFloatValue(kTileValue_user13, &fIndex)) {
DEBUG_PRINT("Index of active magic item: %.0f", fIndex);
UInt32 index = fIndex;
float fObjType;
if (activeTile->GetFloatValue(kTileValue_user7, &fObjType)) {
if (fObjType == 8) { // a scroll
TESForm* form = menu->GetMagicItemForIndex(index);
if (form) {
out->form = form;
gotValue = true;
}
}
else { // a spell
out->form = MenuSpellListVisitor(&menu->spells).GetNthInfo(index-1);
gotValue = true;
}
}
}
}
}
break;
case kMenu_Filter:
out->integer = menu->filterType;
gotValue = true;
break;
default:
break;
}
break;
}
case kMenuType_SpellPurchase:
{
SpellPurchaseMenu* menu = (SpellPurchaseMenu*)activeMenu;
switch (whichValue)
{
case kMenu_Selection:
{
if (activeTile)
{
float fIndex;
//if (activeTile->GetFloatValue(kTileValue_user11, &fIndex))
if (activeTile->GetFloatValue(kTileValue_user0, &fIndex))
{
UInt32 index = fIndex;
out->form = MenuSpellListVisitor(&menu->spells).GetNthInfo(index);
gotValue = true;
}
}
break;
}
case kMenu_Ref:
{
out->form = menu->spellMerchant;
gotValue = true;
break;
}
default:
break;
}
}
break;
case kMenuType_Enchantment:
{
EnchantmentMenu* menu = (EnchantmentMenu*)activeMenu;
switch (whichValue)
{
case kMenu_Soulgem:
if (menu->soulGemInfo)
{
out->form = menu->soulGemInfo->form;
gotValue = true;
}
break;
case kMenu_EnchantItem:
out->form = menu->enchantItem;
gotValue = true;
break;
default:
break;
}
}
break;
case kMenuType_Book:
{
BookMenu* menu = (BookMenu*)activeMenu;
switch (whichValue)
{
case kMenu_Ref:
out->form = menu->bookRef;
gotValue = true;
break;
case kMenu_Object:
out->form = menu->book;
gotValue = true;
break;
default:
break;
}
}
break;
case kMenuType_Inventory:
{
InventoryMenu* menu = (InventoryMenu*)activeMenu;
switch (whichValue)
{
case kMenu_Selection:
{
if (activeTile)
{
float fIndex;
if (activeTile->GetFloatValue(kTileValue_user11, &fIndex))
{
UInt32 index = fIndex;
out->form = (*g_thePlayer)->GetInventoryItem(index, 0);
gotValue = true;
}
}
}
break;
case kMenu_Filter:
out->integer = menu->filterType;
gotValue = true;
break;
default:
break;
}
}
break;
case kMenuType_Dialog:
{
DialogMenu* menu = (DialogMenu*)activeMenu;
switch (whichValue)
{
case kMenu_Ref:
out->form = menu->speaker;
gotValue = true;
break;
default:
break;
}
}
break;
default:
break;
}
return gotValue;
}
