bool CClient::r_Verb(CScript &s, CTextConsole *pSrc) // Execute command from script
{
ADDTOCALLSTACK("CClient::r_Verb");
EXC_TRY("Verb");
// NOTE: This can be called directly from a RES_WEBPAGE script.
// So do not assume we are a game client !
// NOTE: Mostly called from CChar::r_Verb
// NOTE: Little security here so watch out for dangerous scripts !
ASSERT(pSrc);
LPCTSTR pszKey = s.GetKey();
// Old ver
if ( s.IsKeyHead("SET", 3) && !g_Cfg.m_Functions.ContainsKey(pszKey) )
{
PLEVEL_TYPE ilevel = g_Cfg.GetPrivCommandLevel("SET");
if ( ilevel > GetPrivLevel() )
return false;
ASSERT(m_pChar);
addTargetVerb(pszKey + 3, s.GetArgRaw());
return true;
}
if ( (toupper(pszKey[0]) == 'X') && !g_Cfg.m_Functions.ContainsKey(pszKey) )
{
PLEVEL_TYPE ilevel = g_Cfg.GetPrivCommandLevel("SET");
if ( ilevel > GetPrivLevel() )
return false;
// Target this command verb on some other object.
ASSERT(m_pChar);
addTargetVerb(pszKey + 1, s.GetArgRaw());
return true;
}
int index = FindTableSorted(s.GetKey(), sm_szVerbKeys, COUNTOF(sm_szVerbKeys) - 1);
switch ( index )
{
case CV_ADD:
{
if ( s.HasArgs() )
{
TCHAR *ppArgs[2];
size_t iArgQty = Str_ParseCmds(s.GetArgStr(), ppArgs, COUNTOF(ppArgs));
if ( !IsValidGameObjDef(static_cast<LPCTSTR>(ppArgs[0])) )
{
g_Log.EventWarn("Invalid ADD argument '%s'\n", ppArgs[0]);
SysMessageDefault(DEFMSG_CMD_INVALID);
return true;
}
RESOURCE_ID rid = g_Cfg.ResourceGetID(RES_QTY, const_cast<LPCTSTR &>(ppArgs[0]));
m_tmAdd.m_id = rid.GetResIndex();
m_tmAdd.m_amount = (iArgQty > 1) ? static_cast<WORD>(maximum(ATOI(ppArgs[1]), 1)) : 1;
if ( (rid.GetResType() == RES_CHARDEF) || (rid.GetResType() == RES_SPAWN) )
{
m_Targ_PrvUID.InitUID();
return addTargetChars(CLIMODE_TARG_ADDCHAR, static_cast<CREID_TYPE>(m_tmAdd.m_id), false);
}
else
return addTargetItems(CLIMODE_TARG_ADDITEM, static_cast<ITEMID_TYPE>(m_tmAdd.m_id));
break;
}
if ( IsValidDef("d_add") )
Dialog_Setup(CLIMODE_DIALOG, g_Cfg.ResourceGetIDType(RES_DIALOG, "d_add"), 0, m_pChar);
else
Menu_Setup(g_Cfg.ResourceGetIDType(RES_MENU, "MENU_ADDITEM"));
break;
}
case CV_ADDBUFF:
{
TCHAR *ppArgs[11];
Str_ParseCmds(s.GetArgStr(), ppArgs, COUNTOF(ppArgs));
int iArgs[4];
for ( int i = 0; i < 4; ++i )
{
if ( !IsStrNumeric(ppArgs[i]) )
{
DEBUG_ERR(("Invalid AddBuff argument number %u\n", i + 1));
return true;
}
iArgs[i] = Exp_GetVal(ppArgs[i]);
}
if ( (iArgs[0] < 0) || (iArgs[0] > USHRT_MAX) )
{
DEBUG_ERR(("Invalid AddBuff icon ID\n"));
break;
}
LPCTSTR pszArgs[7];
size_t iArgQty = 0;
for ( int i = 0; i < 7; ++i )
{
pszArgs[i] = ppArgs[i + 4];
if ( pszArgs[i] != NULL )
++iArgQty;
}
addBuff(static_cast<BUFF_ICONS>(iArgs[0]), static_cast<DWORD>(iArgs[1]), static_cast<DWORD>(iArgs[2]), static_cast<WORD>(iArgs[3]), pszArgs, iArgQty);
break;
}
case CV_REMOVEBUFF:
{
BUFF_ICONS IconId = static_cast<BUFF_ICONS>(s.GetArgVal());
if ( (IconId < 0) || (IconId > USHRT_MAX) )
{
DEBUG_ERR(("Invalid RemoveBuff icon ID\n"));
break;
}
removeBuff(IconId);
break;
}
case CV_ADDCLILOC:
{
// Add cliloc in @ClientTooltip trigger
TCHAR *ppArgs[256];
size_t iArgQty = Str_ParseCmds(s.GetArgRaw(), ppArgs, COUNTOF(ppArgs), ",");
DWORD dwClilocId = static_cast<DWORD>(Exp_GetLLVal(ppArgs[0]));
CGString sVal;
for ( size_t i = 1; i < iArgQty; ++i )
{
if ( sVal.GetLength() )
sVal += "\t";
sVal += !strcmp(ppArgs[i], "NULL") ? " " : ppArgs[i];
}
if ( g_Cfg.m_wDebugFlags & DEBUGF_SCRIPTS )
g_Log.EventDebug("SCRIPT: addcliloc(%lu,'%s')\n", dwClilocId, static_cast<LPCTSTR>(sVal));
m_TooltipData.Add(new CClientTooltip(dwClilocId, sVal));
break;
}
case CV_ADDCONTEXTENTRY:
{
TCHAR *ppArgs[20];
if ( Str_ParseCmds(s.GetArgRaw(), ppArgs, COUNTOF(ppArgs), ",") > 4 )
{
DEBUG_ERR(("Bad AddContextEntry usage: Function takes maximum of 4 arguments!\n"));
return true;
}
if ( !m_pPopupPacket )
{
DEBUG_ERR(("Bad AddContextEntry usage: Not used under a @ContextMenuRequest/@itemContextMenuRequest trigger!\n"));
return true;
}
for ( int i = 0; i < 4; ++i )
{
if ( (i > 1) && IsStrEmpty(ppArgs[i]) )
continue;
if ( !IsStrNumeric(ppArgs[i]) )
{
DEBUG_ERR(("Bad AddContextEntry usage: Argument %d must be a number!\n", i + 1));
return true;
}
}
int iTextEntry = Exp_GetVal(ppArgs[0]);
if ( iTextEntry < 100 )
{
DEBUG_ERR(("Bad AddContextEntry usage: TextEntry < 100 is reserved for server usage!\n"));
return true;
}
m_pPopupPacket->addOption(static_cast<WORD>(iTextEntry), static_cast<DWORD>(Exp_GetLLVal(ppArgs[1])), static_cast<WORD>(Exp_GetLLVal(ppArgs[2])), static_cast<WORD>(Exp_GetLLVal(ppArgs[3])));
break;
}
case CV_ARROWQUEST:
{
INT64 piVal[3];
Str_ParseCmds(s.GetArgRaw(), piVal, COUNTOF(piVal));
addArrowQuest(static_cast<WORD>(piVal[0]), static_cast<WORD>(piVal[1]), static_cast<DWORD>(piVal[2]));
break;
}
case CV_BADSPAWN:
{
// Loop the world searching for bad spawns
bool fFound = false;
CItem *pItem = NULL;
CSector *pSector = NULL;
CResourceDef *pSpawnDef = NULL;
for ( int m = 0; (m < 256) && !fFound; ++m )
{
if ( !g_MapList.m_maps[m] )
continue;
for ( int s = 0; (s < g_MapList.GetSectorQty(m)) && !fFound; ++s )
{
pSector = g_World.GetSector(m, s);
if ( !pSector )
continue;
for ( pItem = static_cast<CItem *>(pSector->m_Items_Timer.GetHead()); (pItem != NULL) && !fFound; pItem = pItem->GetNext() )
{
if ( pItem->IsType(IT_SPAWN_ITEM) || pItem->IsType(IT_SPAWN_CHAR) )
{
pSpawnDef = static_cast<CItemSpawn *>(pItem)->FixDef();
if ( !pSpawnDef )
{
RESOURCE_ID_BASE rid = pItem->IsType(IT_SPAWN_ITEM) ? pItem->m_itSpawnItem.m_ItemID : pItem->m_itSpawnChar.m_CharID;
CPointMap pt = pItem->GetTopPoint();
m_pChar->Spell_Teleport(pt, true, false);
m_pChar->m_Act_Targ = pItem->GetUID();
SysMessagef("Bad spawn (0%lx, id=%s). Set as ACT", static_cast<DWORD>(pItem->GetUID()), g_Cfg.ResourceGetName(rid));
fFound = true;
}
}
}
}
}
if ( !fFound )
SysMessage(g_Cfg.GetDefaultMsg(DEFMSG_NO_BAD_SPAWNS));
break;
}
case CV_BANKSELF:
{
addBankOpen(m_pChar, LAYER_BANKBOX);
break;
}
case CV_CAST:
{
SPELL_TYPE spell = static_cast<SPELL_TYPE>(g_Cfg.ResourceGetIndexType(RES_SPELL, s.GetArgStr()));
const CSpellDef *pSpellDef = g_Cfg.GetSpellDef(spell);
if ( !pSpellDef )
return true;
CObjBase *pObjSrc = dynamic_cast<CObjBase *>(pSrc);
if ( IsSetMagicFlags(MAGICF_PRECAST) && !pSpellDef->IsSpellType(SPELLFLAG_NOPRECAST) )
{
int iSkill;
if ( !pSpellDef->GetPrimarySkill(&iSkill, NULL) )
return true;
m_tmSkillMagery.m_Spell = spell; // m_atMagery.m_Spell
m_pChar->m_atMagery.m_Spell = spell;
if ( pObjSrc )
{
m_Targ_UID = pObjSrc->GetUID(); // default target.
m_Targ_PrvUID = pObjSrc->GetUID();
}
else
{
m_Targ_UID.ClearUID();
m_Targ_PrvUID.ClearUID();
}
m_pChar->Skill_Start(static_cast<SKILL_TYPE>(iSkill));
break;
}
else
Cmd_Skill_Magery(spell, pObjSrc);
break;
}
case CV_CHANGEFACE: // open 'face selection' dialog (enhanced clients only)
{
addGumpDialog(CLIMODE_DIALOG, NULL, 0, NULL, 0, 0, 0, m_pChar, CLIMODE_DIALOG_FACESELECTION);
break;
}
case CV_CHARLIST: // usually just a gm command
{
if ( !PacketChangeCharacter::CanSendTo(m_NetState) )
break;
new PacketChangeCharacter(this);
CharDisconnect(); // since there is no undoing this in the client.
SetTargMode(CLIMODE_SETUP_CHARLIST);
break;
}
case CV_CTAGLIST:
{
if ( !strcmpi(s.GetArgStr(), "log") )
pSrc = &g_Serv;
m_TagDefs.DumpKeys(pSrc, "CTAG.");
break;
}
case CV_CLEARCTAGS:
{
if ( s.HasArgs() )
{
LPCTSTR pszArgs = s.GetArgStr();
SKIP_SEPARATORS(pszArgs);
m_TagDefs.ClearKeys(pszArgs);
}
else
m_TagDefs.ClearKeys();
break;
}
case CV_CLOSEPAPERDOLL:
{
const CChar *pChar = s.HasArgs() ? static_cast<CGrayUID>(s.GetArgVal()).CharFind() : m_pChar;
if ( pChar )
closeUIWindow(pChar, 0x1);
break;
}
case CV_CLOSEPROFILE:
{
const CChar *pChar = s.HasArgs() ? static_cast<CGrayUID>(s.GetArgVal()).CharFind() : m_pChar;
if ( pChar )
closeUIWindow(pChar, 0x8);
break;
}
case CV_CLOSESTATUS:
{
const CChar *pChar = s.HasArgs() ? static_cast<CGrayUID>(s.GetArgVal()).CharFind() : m_pChar;
if ( pChar )
closeUIWindow(pChar, 0x2);
break;
}
case CV_CODEXOFWISDOM:
{
INT64 piArgs[2];
size_t iArgQty = Str_ParseCmds(s.GetArgStr(), piArgs, COUNTOF(piArgs));
if ( iArgQty < 1 )
{
SysMessage("Usage: CODEXOFWISDOM TopicID [ForceOpen]");
break;
}
addCodexOfWisdom(static_cast<DWORD>(piArgs[0]), static_cast<bool>(piArgs[1]));
break;
}
case CV_DYE:
{
const CObjBase *pObj = s.HasArgs() ? static_cast<CGrayUID>(s.GetArgVal()).ObjFind() : NULL;
if ( pObj )
addDyeOption(pObj);
break;
}
case CV_EVERBTARG:
{
m_Prompt_Text = s.GetArgStr();
addPromptConsole(CLIMODE_PROMPT_TARG_VERB, m_Targ_Text.IsEmpty() ? "Enter the verb" : "Enter the text", m_Targ_UID);
break;
}
case CV_EXTRACT:
{
// sort of like EXPORT but for statics.
// Opposite of the "UNEXTRACT" command
TCHAR *ppArgs[2];
size_t iArgQty = Str_ParseCmds(s.GetArgStr(), ppArgs, COUNTOF(ppArgs));
if ( iArgQty < 2 )
{
SysMessage(g_Cfg.GetDefaultMsg(DEFMSG_EXTRACT_USAGE));
break;
}
m_Targ_Text = ppArgs[0]; // point at the options (if any)
m_tmTile.m_ptFirst.InitPoint(); // clear this first
m_tmTile.m_Code = CV_EXTRACT; // set extract code
m_tmTile.m_id = Exp_GetVal(ppArgs[1]); // extract id
addTarget(CLIMODE_TARG_TILE, g_Cfg.GetDefaultMsg(DEFMSG_SELECT_EXTRACT_AREA), true);
break;
}
case CV_UNEXTRACT:
{
// Create item from script.
// Opposite of the "EXTRACT" command
TCHAR *ppArgs[2];
size_t iArgQty = Str_ParseCmds(s.GetArgStr(), ppArgs, COUNTOF(ppArgs));
if ( iArgQty < 2 )
{
SysMessage(g_Cfg.GetDefaultMsg(DEFMSG_UNEXTRACT_USAGE));
break;
}
m_Targ_Text = ppArgs[0]; // point at the options (if any)
m_tmTile.m_ptFirst.InitPoint(); // clear this first
m_tmTile.m_Code = CV_UNEXTRACT; // set extract code
m_tmTile.m_id = Exp_GetVal(ppArgs[1]); // extract id
addTarget(CLIMODE_TARG_UNEXTRACT, g_Cfg.GetDefaultMsg(DEFMSG_SELECT_MULTI_POS), true);
break;
}
case CV_GMPAGE:
{
m_Targ_Text = s.GetArgStr();
if ( !m_Targ_Text.IsEmpty() && !strnicmp(m_Targ_Text, "ADD ", 4) )
{
Cmd_GM_Page(m_Targ_Text + 4);
break;
}
addPromptConsole(CLIMODE_PROMPT_GM_PAGE_TEXT, g_Cfg.GetDefaultMsg(DEFMSG_GMPAGE_PROMPT));
break;
}
case CV_GOTARG: // go to my (preselected) target.
{
ASSERT(m_pChar);
CObjBase *pObj = m_Targ_UID.ObjFind();
if ( pObj )
{
CPointMap pt = pObj->GetTopLevelObj()->GetTopPoint();
m_pChar->m_dirFace = m_pChar->GetDir(pObj, m_pChar->m_dirFace);
m_pChar->Spell_Teleport(pt, true, false);
}
break;
}
case CV_INFO:
{
// We could also get ground tile info.
addTarget(CLIMODE_TARG_OBJ_INFO, g_Cfg.GetDefaultMsg(DEFMSG_SELECT_ITEM_INFO), true, false);
break;
}
case CV_INFORMATION:
{
SysMessage(g_Serv.GetStatusString(0x22));
SysMessage(g_Serv.GetStatusString(0x24));
break;
}
case CV_LAST: // fake previous target
{
if ( GetTargMode() >= CLIMODE_MOUSE_TYPE )
{
ASSERT(m_pChar);
CObjBase *pObj = m_pChar->m_Act_Targ.ObjFind();
if ( pObj )
{
Event_Target(GetTargMode(), pObj->GetUID(), pObj->GetTopPoint());
addTargetCancel();
}
break;
}
return false;
}
case CV_LINK: // link doors
{
m_Targ_UID.InitUID();
addTarget(CLIMODE_TARG_LINK, g_Cfg.GetDefaultMsg(DEFMSG_SELECT_LINK_ITEM));
break;
}
case CV_MAPWAYPOINT:
{
INT64 piVal[2];
size_t iArgQty = Str_ParseCmds(s.GetArgRaw(), piVal, COUNTOF(piVal));
if ( iArgQty < 2 )
{
SysMessage("Usage: MAPWAYPOINT uid type");
break;
}
CObjBase *pObj = static_cast<CGrayUID>(piVal[0]).ObjFind();
addMapWaypoint(pObj, static_cast<MAPWAYPOINT_TYPE>(piVal[1]));
break;
}
case CV_MENU:
{
Menu_Setup(g_Cfg.ResourceGetIDType(RES_MENU, s.GetArgStr()));
break;
}
case CV_MIDILIST:
{
INT64 piMidi[64];
size_t iArgQty = Str_ParseCmds(s.GetArgStr(), piMidi, COUNTOF(piMidi));
if ( iArgQty > 0 )
addMusic(static_cast<MIDI_TYPE>(piMidi[Calc_GetRandVal(iArgQty)]));
break;
}
case CV_NUDGE:
{
if ( !s.HasArgs() )
{
SysMessage("Usage: NUDGE dx dy dz");
break;
}
m_Targ_Text = s.GetArgRaw();
m_tmTile.m_ptFirst.InitPoint(); // clear this first
m_tmTile.m_Code = CV_NUDGE;
addTarget(CLIMODE_TARG_TILE, g_Cfg.GetDefaultMsg(DEFMSG_SELECT_NUDGE_AREA), true);
break;
}
case CV_NUKE:
{
m_Targ_Text = s.GetArgRaw();
m_tmTile.m_ptFirst.InitPoint(); // clear this first
m_tmTile.m_Code = CV_NUKE; // set nuke code
addTarget(CLIMODE_TARG_TILE, g_Cfg.GetDefaultMsg(DEFMSG_SELECT_NUKE_AREA), true);
break;
}
case CV_NUKECHAR:
{
m_Targ_Text = s.GetArgRaw();
m_tmTile.m_ptFirst.InitPoint(); // clear this first
m_tmTile.m_Code = CV_NUKECHAR; // set nuke code
addTarget(CLIMODE_TARG_TILE, g_Cfg.GetDefaultMsg(DEFMSG_SELECT_NUKE_CHAR_AREA), true);
break;
}
case CV_OPENPAPERDOLL:
{
const CChar *pChar = s.HasArgs() ? static_cast<CGrayUID>(s.GetArgVal()).CharFind() : m_pChar;
if ( pChar )
addCharPaperdoll(pChar);
break;
}
case CV_OPENTRADEWINDOW:
{
TCHAR *ppArgs[2];
Str_ParseCmds(s.GetArgStr(), ppArgs, COUNTOF(ppArgs));
CChar *pChar = ppArgs[0] ? static_cast<CGrayUID>(Exp_GetLLVal(ppArgs[0])).CharFind() : NULL;
if ( pChar )
{
CItem *pItem = ppArgs[1] ? static_cast<CGrayUID>(Exp_GetLLVal(ppArgs[1])).ItemFind() : NULL;
Cmd_SecureTrade(pChar, pItem);
}
break;
}
case CV_PAGE:
Cmd_GM_PageCmd(s.GetArgStr());
break;
case CV_REPAIR:
addTarget(CLIMODE_TARG_REPAIR, g_Cfg.GetDefaultMsg(DEFMSG_SELECT_ITEM_REPAIR));
break;
case CV_FLUSH:
#ifndef _MTNETWORK
g_NetworkOut.flush(this);
#else
g_NetworkManager.flush(m_NetState);
#endif
break;
case CV_RESEND:
addReSync();
break;
case CV_SAVE:
g_World.Save(s.GetArgVal() != 0);
break;
case CV_SCROLL:
// put a scroll up.
addScrollResource(s.GetArgStr(), SCROLL_TYPE_UPDATES);
break;
case CV_SENDPACKET:
SendPacket(s.GetArgStr());
break;
case CV_SELF: // fake self target
if ( GetTargMode() >= CLIMODE_MOUSE_TYPE )
{
ASSERT(m_pChar);
Event_Target(GetTargMode(), m_pChar->GetUID(), m_pChar->GetTopPoint());
addTargetCancel();
break;
}
return false;
case CV_SHOWSKILLS:
addSkillWindow(static_cast<SKILL_TYPE>(g_Cfg.m_iMaxSkill)); // reload the real skills
break;
case CV_SKILLMENU:
Cmd_Skill_Menu(g_Cfg.ResourceGetIDType(RES_SKILLMENU, s.GetArgStr()));
break;
case CV_SKILLSELECT:
Event_Skill_Use(g_Cfg.FindSkillKey(s.GetArgStr()));
break;
case CV_SUMMON:
{
ASSERT(m_pChar);
const CSpellDef *pSpellDef = g_Cfg.GetSpellDef(SPELL_Summon);
if ( !pSpellDef )
return false;
m_pChar->m_Act_Targ = m_pChar->GetUID();
m_pChar->m_Act_TargPrv = m_pChar->GetUID();
if ( pSpellDef->IsSpellType(SPELLFLAG_TARG_OBJ|SPELLFLAG_TARG_XYZ) )
{
m_tmSkillMagery.m_Spell = SPELL_Summon;
m_tmSkillMagery.m_SummonID = static_cast<CREID_TYPE>(g_Cfg.ResourceGetIndexType(RES_CHARDEF, s.GetArgStr()));
LPCTSTR pszPrompt = g_Cfg.GetDefaultMsg(DEFMSG_SELECT_MAGIC_TARGET);
if ( !pSpellDef->m_sTargetPrompt.IsEmpty() )
pszPrompt = pSpellDef->m_sTargetPrompt;
int iSpellTimeout = static_cast<int>(GetDefNum("SPELLTIMEOUT"));
if ( !iSpellTimeout )
iSpellTimeout = g_Cfg.m_iSpellTimeout * TICK_PER_SEC;
addTarget(CLIMODE_TARG_SKILL_MAGERY, pszPrompt, pSpellDef->IsSpellType(SPELLFLAG_TARG_XYZ), pSpellDef->IsSpellType(SPELLFLAG_HARM), iSpellTimeout);
break;
}
else
{
m_pChar->m_atMagery.m_Spell = SPELL_Summon;
m_pChar->m_atMagery.m_SummonID = static_cast<CREID_TYPE>(g_Cfg.ResourceGetIndexType(RES_CHARDEF, s.GetArgStr()));
if ( IsSetMagicFlags(MAGICF_PRECAST) && !pSpellDef->IsSpellType(SPELLFLAG_NOPRECAST) )
{
m_pChar->Spell_CastDone();
break;
}
else
{
int iSkill;
if ( !pSpellDef->GetPrimarySkill(&iSkill, NULL) )
return false;
m_pChar->Skill_Start(static_cast<SKILL_TYPE>(iSkill));
}
}
break;
}
case CV_SMSG:
case CV_SYSMESSAGE:
SysMessage(s.GetArgStr());
break;
case CV_SYSMESSAGEF: // there is still an issue with numbers not resolving properly when %i,%d,or other numeric format code is in use
{
TCHAR *ppArgs[4];
size_t iArgQty = Str_ParseCmds(s.GetArgRaw(), ppArgs, COUNTOF(ppArgs));
if ( iArgQty < 2 )
{
g_Log.EventError("SysMessagef with less than 1 args for the given text\n");
return false;
}
if ( iArgQty > 4 )
{
g_Log.EventError("Too many arguments given to SysMessagef (max = text + 3\n");
return false;
}
if ( *ppArgs[0] == '"' ) // skip quotes
++ppArgs[0];
for ( TCHAR *pEnd = ppArgs[0] + strlen(ppArgs[0]) - 1; pEnd >= ppArgs[0]; --pEnd )
{
if ( *pEnd == '"' ) // skip quotes
{
*pEnd = '\0';
break;
}
}
SysMessagef(ppArgs[0], ppArgs[1], ppArgs[2] ? ppArgs[2] : 0, ppArgs[3] ? ppArgs[3] : 0);
break;
}
case CV_SMSGU:
case CV_SYSMESSAGEUA:
{
TCHAR *ppArgs[5];
size_t iArgQty = Str_ParseCmds(s.GetArgRaw(), ppArgs, COUNTOF(ppArgs));
if ( iArgQty > 4 )
{
// Font and mode are actually ignored here, but they never made a difference anyway.. I'd like to keep the syntax similar to SAYUA
NCHAR szBuffer[MAX_TALK_BUFFER];
CvtSystemToNUNICODE(szBuffer, COUNTOF(szBuffer), ppArgs[4], -1);
addBarkUNICODE(szBuffer, NULL, static_cast<HUE_TYPE>(Exp_GetLLVal(ppArgs[0])), TALKMODE_SYSTEM, FONT_NORMAL, ppArgs[3]);
}
break;
}
case CV_SMSGL:
case CV_SYSMESSAGELOC:
{
TCHAR *ppArgs[256];
size_t iArgQty = Str_ParseCmds(s.GetArgRaw(), ppArgs, COUNTOF(ppArgs), ",");
if ( iArgQty > 1 )
{
HUE_TYPE hue = HUE_TEXT_DEF;
if ( ATOI(ppArgs[0]) > 0 )
hue = static_cast<HUE_TYPE>(Exp_GetLLVal(ppArgs[0]));
DWORD dwClilocId = static_cast<DWORD>(Exp_GetLLVal(ppArgs[1]));
CGString sVal;
for ( size_t i = 2; i < iArgQty; ++i )
{
if ( sVal.GetLength() )
sVal += "\t";
sVal += !strcmp(ppArgs[i], "NULL") ? " " : ppArgs[i];
}
addBarkLocalized(dwClilocId, NULL, hue, TALKMODE_SYSTEM, FONT_NORMAL, sVal.GetPtr());
}
break;
}
case CV_SMSGLEX:
case CV_SYSMESSAGELOCEX:
{
TCHAR *ppArgs[256];
size_t iArgQty = Str_ParseCmds(s.GetArgRaw(), ppArgs, COUNTOF(ppArgs), ",");
if ( iArgQty > 2 )
{
HUE_TYPE hue = HUE_TEXT_DEF;
AFFIX_TYPE affix = AFFIX_APPEND;
if ( ATOI(ppArgs[0]) > 0 )
hue = static_cast<HUE_TYPE>(Exp_GetLLVal(ppArgs[0]));
DWORD dwClilocId = static_cast<DWORD>(Exp_GetLLVal(ppArgs[1]));
if ( ppArgs[2] )
affix = static_cast<AFFIX_TYPE>(Exp_GetLLVal(ppArgs[2]));
CGString sVal;
for ( size_t i = 4; i < iArgQty; ++i )
{
if ( sVal.GetLength() )
sVal += "\t";
sVal += !strcmp(ppArgs[i], "NULL") ? " " : ppArgs[i];
}
addBarkLocalizedEx(dwClilocId, NULL, hue, TALKMODE_SYSTEM, FONT_NORMAL, affix, ppArgs[3], sVal.GetPtr());
}
break;
}
case CV_TELE:
Cmd_Skill_Magery(SPELL_Teleport, dynamic_cast<CObjBase *>(pSrc));
break;
case CV_TILE:
if ( !s.HasArgs() )
{
SysMessage("Usage: TILE z-height item1 item2 itemX");
break;
}
m_Targ_Text = s.GetArgStr(); // point at the options
m_tmTile.m_ptFirst.InitPoint(); // clear this first
m_tmTile.m_Code = CV_TILE;
addTarget(CLIMODE_TARG_TILE, "Pick 1st corner:", true);
break;
case CV_VERSION:
SysMessage(g_szServerDescription);
break;
case CV_WEBLINK:
addWebLaunch(s.GetArgStr());
break;
default:
if ( r_LoadVal(s) )
{
CGString sVal;
if ( r_WriteVal(s.GetKey(), sVal, pSrc) )
return true;
}
return CScriptObj::r_Verb(s, pSrc); // used in the case of web pages to access server level things
}
return true;
EXC_CATCH;
EXC_DEBUG_START;
EXC_ADD_SCRIPTSRC;
EXC_DEBUG_END;
return false;
}
/*------------------------------------------------------*/
void ListToPc (char *s)
{
int i;
lib *l;
command *c;
#ifndef WIN32
void heap_start(void);
static long *p;
char cc[32];
#endif
uchar r[LINK_LEN],rr[16];
switch(*s) {
case 'l': l=Ln;
do {
l->check=null;
l=l->next;
} while(l != Ln);
c=CP;
if(c)
do {
c->chk=null;
c=c->next;
} while(c != CP);
SetTask(CheckScreen,0,RTC_task);
SetTask(CheckLib,0,RTC_task);
break;
case 's': CheckScr=null;
if(!CheckTask(CheckScreen,RTC_task))
CheckScreen();
else
SetTask(CheckScreen,0,RTC_task);
break;
case 'o': sprintf(r,"=o %s,%d\r\n>",LinkAddrText(LinkAddr(OBP),rr),targets_xn(OBP));
puts_pc(r);
break;
case 'p': puts_pc("=p ");
putsLLA(OBP);
puts_pc("\r\n");
break;
case 'm': for(i=0; _MenuCode[i]; ++i)
{
sprintf(r,"=m[%d] ",i);
for(s=_MenuCode[i]; *s; ++s)
if(*s == ' ')
sprintf(strchr(r,0)," ");
else
{
/* if(*s < ENTER)
sprintf(strchr(r,0),"%c",*s);
else
*/ sprintf(strchr(r,0),"%02X",*s);
}
sprintf(strchr(r,0),"\r\n");
puts_pc(r);
}
break;
case 't': for(i=0; _TextCode[i]; ++i)
{
sprintf(r,"=t[%d] ",i);
for(s=_TextCode[i]; *s; ++s)
sprintf(strchr(r,0),"%02X",*s);
sprintf(strchr(r,0),"\r\n");
puts_pc(r);
}
break;
case 'h': for(i=0; _MenuHead[i]; ++i)
{
sprintf(r,"=h[%d] ",i);
for(s=_MenuHead[i]; *s; ++s)
sprintf(strchr(r,0),"%02X",*s);
sprintf(strchr(r,0),"\r\n");
puts_pc(r);
}
break;
#ifndef WIN32
case 'H': for(p=(long *)heap_start; *p; p=(long *)labs(*p))
{
if(*p>0)
sprintf(cc,"=H %08lX,%08lX,!\r\n",p,*p);
else
sprintf(cc,"=H %08lX,%08lX,-\r\n",p,-(*p));
puts_pc(cc);
}
break;
#endif
case 'f': ListPar();
break;
case 'z': ListZone(NULL);
break;
case 'v': puts_pc(">=v");
SysMessage(CHPC);
break;
case 'G': WriteGunData(Guns,NULL);
break;
case 'D': ListDatum();
break;
case 'e': shaft_enable();
break;
default: ReadLib(s);
break;
}
}
void netError() {
ClosePlugins();
SysMessage(_("Connection closed!\n"));
SysRunGui();
}
void ReleasePlugins() {
s32 ret;
#if 0 // TEMP!!!
if (Config.UseNet) {
ret = NET_close();
if (ret < 0) Config.UseNet = FALSE;
}
#endif
NetOpened = FALSE;
ret = CDR_close();
if (ret < 0) {
SysMessage("Error Closing CDR Plugin");
}
ret = SPU_close();
if (ret < 0) {
SysMessage("Error Closing SPU Plugin");
}
ret = PAD1_close();
if (ret < 0) {
SysMessage("Error Closing PAD1 Plugin");
}
ret = PAD2_close();
if (ret < 0) {
SysMessage("Error Closing PAD2 Plugin");
}
ret = GPU_close();
if (ret < 0) {
SysMessage("Error Closing GPU Plugin");
}
#ifdef ENABLE_SIO1API
ret = SIO1_close();
if (ret < 0) {
SysMessage("Error Closing SIO1 Plugin");
}
#endif
CDR_shutdown();
GPU_shutdown();
SPU_shutdown();
PAD1_shutdown();
PAD2_shutdown();
#ifdef ENABLE_SIO1API
SIO1_shutdown();
#endif
#if 0
if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();
if (hGPUDriver != NULL) GPU_shutdown();
if (hSPUDriver != NULL) SPU_shutdown();
if (hPAD1Driver != NULL) PAD1_shutdown();
if (hPAD2Driver != NULL) PAD2_shutdown();
if (Config.UseNet && hNETDriver != NULL) NET_shutdown();
if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver);
hCDRDriver = NULL;
if (hGPUDriver != NULL) SysCloseLibrary(hGPUDriver);
hGPUDriver = NULL;
if (hSPUDriver != NULL) SysCloseLibrary(hSPUDriver);
hSPUDriver = NULL;
if (hPAD1Driver != NULL) SysCloseLibrary(hPAD1Driver);
hPAD1Driver = NULL;
if (hPAD2Driver != NULL) SysCloseLibrary(hPAD2Driver);
hPAD2Driver = NULL;
if (Config.UseNet && hNETDriver != NULL) {
SysCloseLibrary(hNETDriver);
hNETDriver = NULL;
}
#ifdef ENABLE_SIO1API
if (hSIO1Driver != NULL) {
SIO1_shutdown();
SysCloseLibrary(hSIO1Driver);
hSIO1Driver = NULL;
}
#endif
#endif
}
int main(int argc, char *argv[])
{
char file[MAXPATHLEN] = "";
char path[MAXPATHLEN];
const char *cdfile = NULL;
const char *loadst_f = NULL;
int psxout = 0;
int loadst = 0;
int i;
emu_core_preinit();
// read command line options
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-psxout")) psxout = 1;
else if (!strcmp(argv[i], "-load")) loadst = atol(argv[++i]);
else if (!strcmp(argv[i], "-cfg")) {
if (i+1 >= argc) break;
strncpy(cfgfile_basename, argv[++i], MAXPATHLEN-100); /* TODO buffer overruns */
SysPrintf("Using config file %s.\n", cfgfile_basename);
}
else if (!strcmp(argv[i], "-cdfile")) {
char isofilename[MAXPATHLEN];
if (i+1 >= argc) break;
strncpy(isofilename, argv[++i], MAXPATHLEN);
if (isofilename[0] != '/') {
getcwd(path, MAXPATHLEN);
if (strlen(path) + strlen(isofilename) + 1 < MAXPATHLEN) {
strcat(path, "/");
strcat(path, isofilename);
strcpy(isofilename, path);
} else
isofilename[0] = 0;
}
cdfile = isofilename;
}
else if (!strcmp(argv[i], "-loadf")) {
if (i+1 >= argc) break;
loadst_f = argv[++i];
}
else if (!strcmp(argv[i], "-h") ||
!strcmp(argv[i], "-help") ||
!strcmp(argv[i], "--help")) {
printf("PCSX-ReARMed " REV "\n");
printf("%s\n", _(
" pcsx [options] [file]\n"
"\toptions:\n"
"\t-cdfile FILE\tRuns a CD image file\n"
"\t-cfg FILE\tLoads desired configuration file (default: ~/.pcsx/pcsx.cfg)\n"
"\t-psxout\t\tEnable PSX output\n"
"\t-load STATENUM\tLoads savestate STATENUM (1-5)\n"
"\t-h -help\tDisplay this message\n"
"\tfile\t\tLoads a PSX EXE file\n"));
return 0;
} else {
strncpy(file, argv[i], MAXPATHLEN);
if (file[0] != '/') {
getcwd(path, MAXPATHLEN);
if (strlen(path) + strlen(file) + 1 < MAXPATHLEN) {
strcat(path, "/");
strcat(path, file);
strcpy(file, path);
} else
file[0] = 0;
}
}
}
if (cdfile)
set_cd_image(cdfile);
// frontend stuff
// init input but leave probing to platform code,
// they add input drivers and may need to modify them after probe
in_init();
pl_init();
plat_init();
menu_init(); // loads config
if (emu_core_init() != 0)
return 1;
if (psxout)
Config.PsxOut = 1;
if (LoadPlugins() == -1) {
// FIXME: this recovery doesn't work, just delete bad config and bail out
// SysMessage("could not load plugins, retrying with defaults\n");
set_default_paths();
snprintf(path, sizeof(path), "." PCSX_DOT_DIR "%s", cfgfile_basename);
remove(path);
SysMessage("Failed loading plugins!");
return 1;
}
pcnt_hook_plugins();
if (OpenPlugins() == -1) {
return 1;
}
plugin_call_rearmed_cbs();
CheckCdrom();
SysReset();
if (file[0] != '\0') {
if (Load(file) != -1)
ready_to_go = 1;
} else {
if (cdfile) {
if (LoadCdrom() == -1) {
ClosePlugins();
SysPrintf(_("Could not load CD-ROM!\n"));
return -1;
}
emu_on_new_cd(!loadst);
ready_to_go = 1;
}
}
if (loadst_f) {
int ret = LoadState(loadst_f);
SysPrintf("%s state file: %s\n",
ret ? "failed to load" : "loaded", loadst_f);
ready_to_go |= ret == 0;
}
if (ready_to_go) {
menu_prepare_emu();
// If a state has been specified, then load that
if (loadst) {
int ret = emu_load_state(loadst - 1);
SysPrintf("%s state %d\n",
ret ? "failed to load" : "loaded", loadst);
}
}
else
menu_loop();
pl_start_watchdog();
while (!g_emu_want_quit)
{
stop = 0;
emu_action = SACTION_NONE;
psxCpu->Execute();
if (emu_action != SACTION_NONE)
do_emu_action();
}
printf("Exit..\n");
ClosePlugins();
SysClose();
menu_finish();
plat_finish();
return 0;
}
EXPORT_C_(void) CDVDconfigure()
{
SysMessage("Nothing to Configure");
}
s32 Init()
{
numBuffers = Config_WaveOut.NumBuffers;
MMRESULT woores;
if (Test())
return -1;
// TODO : Use dsound to determine the speaker configuration, and expand audio from there.
#if 0
int speakerConfig;
//if( StereoExpansionEnabled )
speakerConfig = 2; // better not mess with this in wavout :p (rama)
// Any windows driver should support stereo at the software level, I should think!
pxAssume( speakerConfig > 1 );
LPTHREAD_START_ROUTINE threadproc;
switch( speakerConfig )
{
case 2:
ConLog( "* SPU2 > Using normal 2 speaker stereo output.\n" );
threadproc = (LPTHREAD_START_ROUTINE)&RThread<StereoOut16>;
speakerConfig = 2;
break;
case 4:
ConLog( "* SPU2 > 4 speaker expansion enabled [quadraphenia]\n" );
threadproc = (LPTHREAD_START_ROUTINE)&RThread<StereoQuadOut16>;
speakerConfig = 4;
break;
case 6:
case 7:
ConLog( "* SPU2 > 5.1 speaker expansion enabled.\n" );
threadproc = (LPTHREAD_START_ROUTINE)&RThread<Stereo51Out16>;
speakerConfig = 6;
break;
default:
ConLog( "* SPU2 > 7.1 speaker expansion enabled.\n" );
threadproc = (LPTHREAD_START_ROUTINE)&RThread<Stereo51Out16>;
speakerConfig = 8;
break;
}
#endif
wformat.wFormatTag = WAVE_FORMAT_PCM;
wformat.nSamplesPerSec = SampleRate;
wformat.wBitsPerSample = 16;
wformat.nChannels = 2;
wformat.nBlockAlign = ((wformat.wBitsPerSample * wformat.nChannels) / 8);
wformat.nAvgBytesPerSec = (wformat.nSamplesPerSec * wformat.nBlockAlign);
wformat.cbSize = 0;
qbuffer = new StereoOut16[BufferSize * numBuffers];
woores = waveOutOpen(&hwodevice, WAVE_MAPPER, &wformat, 0, 0, 0);
if (woores != MMSYSERR_NOERROR) {
waveOutGetErrorText(woores, (wchar_t *)&ErrText, 255);
SysMessage("WaveOut Error: %s", ErrText);
return -1;
}
const int BufferSizeBytes = wformat.nBlockAlign * BufferSize;
for (u32 i = 0; i < numBuffers; i++) {
whbuffer[i].dwBufferLength = BufferSizeBytes;
whbuffer[i].dwBytesRecorded = BufferSizeBytes;
whbuffer[i].dwFlags = 0;
whbuffer[i].dwLoops = 0;
whbuffer[i].dwUser = 0;
whbuffer[i].lpData = (LPSTR)QBUFFER(i);
whbuffer[i].lpNext = 0;
whbuffer[i].reserved = 0;
waveOutPrepareHeader(hwodevice, whbuffer + i, sizeof(WAVEHDR));
whbuffer[i].dwFlags |= WHDR_DONE; //avoid deadlock
}
// Start Thread
// [Air]: The waveout code does not use wait objects, so setting a time critical
// priority level is a bad idea. Standard priority will do fine. The buffer will get the
// love it needs and won't suck resources idling pointlessly. Just don't try to
// run it in uber-low-latency mode.
waveout_running = true;
thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)RThread<StereoOut16>, this, 0, &tid);
return 0;
}
int _OpenPlugins(HWND hWnd) {
int ret;
GPU_clearDynarec(clearDynarec);
ret = CDR_open();
if (ret < 0) { SysMessage (_("Error Opening CDR Plugin")); return -1; }
SetCurrentDirectory(PcsxDir);
if (Config.UseNet && NetOpened == 0) {
netInfo info;
char path[256];
strcpy(info.EmuName, "PCSX " PACKAGE_VERSION);
strncpy(info.CdromID, CdromId, 9);
strncpy(info.CdromLabel, CdromLabel, 9);
info.psxMem = psxM;
info.GPU_showScreenPic = GPU_showScreenPic;
info.GPU_displayText = GPU_displayText;
info.GPU_showScreenPic = GPU_showScreenPic;
info.PAD_setSensitive = PAD1_setSensitive;
sprintf(path, "%s%s", Config.BiosDir, Config.Bios);
strcpy(info.BIOSpath, path);
strcpy(info.MCD1path, Config.Mcd1);
strcpy(info.MCD2path, Config.Mcd2);
sprintf(path, "%s%s", Config.PluginsDir, Config.Gpu);
strcpy(info.GPUpath, path);
sprintf(path, "%s%s", Config.PluginsDir, Config.Spu);
strcpy(info.SPUpath, path);
sprintf(path, "%s%s", Config.PluginsDir, Config.Cdr);
strcpy(info.CDRpath, path);
NET_setInfo(&info);
ret = NET_open(hWnd);
if (ret < 0) {
if (ret == -2) {
// -2 is returned when something in the info
// changed and needs to be synced
char *ptr;
PARSEPATH(Config.Bios, info.BIOSpath);
PARSEPATH(Config.Gpu, info.GPUpath);
PARSEPATH(Config.Spu, info.SPUpath);
PARSEPATH(Config.Cdr, info.CDRpath);
strcpy(Config.Mcd1, info.MCD1path);
strcpy(Config.Mcd2, info.MCD2path);
return -2;
} else {
Config.UseNet = 0;
}
} else {
HWND hW = CreateDialog(gApp.hInstance, MAKEINTRESOURCE(IDD_CONNECT), gApp.hWnd, ConnectDlgProc);
ShowWindow(hW, SW_SHOW);
if (NET_queryPlayer() == 1) {
if (SendPcsxInfo() == -1) Config.UseNet = 0;
} else {
if (RecvPcsxInfo() == -1) Config.UseNet = 0;
}
DestroyWindow(hW);
}
NetOpened = 1;
} else if (Config.UseNet) {
NET_resume();
}
ret = GPU_open(hWnd);
if (ret < 0) { SysMessage (_("Error Opening GPU Plugin (%d)"), ret); return -1; }
ret = SPU_open(hWnd);
if (ret < 0) { SysMessage (_("Error Opening SPU Plugin (%d)"), ret); return -1; }
SPU_registerCallback(SPUirq);
ret = PAD1_open(hWnd);
if (ret < 0) { SysMessage (_("Error Opening PAD1 Plugin (%d)"), ret); return -1; }
ret = PAD2_open(hWnd);
if (ret < 0) { SysMessage (_("Error Opening PAD2 Plugin (%d)"), ret); return -1; }
SetCurrentDirectory(PcsxDir);
ShowCursor(FALSE);
return 0;
}
int pcap_io_init(char *adapter)
{
int dlt;
char *dlt_name;
emu_printf("Opening adapter '%s'...",adapter);
u16 checksum;
GetMACAddress(adapter,&host_mac);
//Near copy of the host mac, butchered slightly, should be pretty good!
eeprom[0] = host_mac.bytes[0];
eeprom[1] = host_mac.bytes[1];
eeprom[2] = host_mac.bytes[2];
eeprom[3] = host_mac.bytes[2];
eeprom[4] = host_mac.bytes[5];
eeprom[5] = host_mac.bytes[4];
//The checksum seems to be all the values of the mac added up in 16bit chunks
checksum = dev9.eeprom[0] + dev9.eeprom[1] + dev9.eeprom[2] & 0xffff;
dev9.eeprom[3] = checksum;
//emu_printf("eeprom Mac set to %x %x %x %x %x %x", eeprom[0], eeprom[1], eeprom[2], eeprom[3], eeprom[4], eeprom[5]);
//emu_printf("Checksum %x %x", eeprom[6], eeprom[7]);
/* Open the adapter */
if ((adhandle= pcap_open_live(adapter, // name of the device
65536, // portion of the packet to capture.
// 65536 grants that the whole packet will be captured on all the MACs.
pcap_mode==switched?1:0, // promiscuous mode (nonzero means promiscuous)
1, // read timeout
errbuf // error buffer
)) == NULL)
{
fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", adapter);
return -1;
}
dlt = pcap_datalink(adhandle);
dlt_name = (char*)pcap_datalink_val_to_name(dlt);
fprintf(stderr,"Device uses DLT %d: %s\n",dlt,dlt_name);
switch(dlt)
{
case DLT_EN10MB :
//case DLT_IEEE802_11:
break;
default:
SysMessage("ERROR: Unsupported DataLink Type (%d): %s",dlt,dlt_name);
pcap_close(adhandle);
return -1;
}
if(pcap_setnonblock(adhandle,1,errbuf)==-1)
{
fprintf(stderr,"WARNING: Error setting non-blocking mode. Default mode will be used.\n");
}
//Changing the LogSetting might not affect logging
//directory of winPcap logs if done after Open()
const std::string pfile(s_strLogPath + "/packet.log");
packet_log = fopen(pfile.c_str(), "w");
const std::string plfile(s_strLogPath + "/pkt_log.pcap");
dump_pcap = pcap_dump_open(adhandle, plfile.c_str());
pcap_io_running=1;
emu_printf("Ok.\n");
return 0;
}
int CTextConsole::OnConsoleKey( CSString & sText, tchar nChar, bool fEcho )
{
ADDTOCALLSTACK("CTextConsole::OnConsoleKey");
// eventaully we should call OnConsoleCmd
// RETURN:
// 0 = dump this connection.
// 1 = keep processing.
// 2 = process this.
if ( sText.GetLength() >= SCRIPT_MAX_LINE_LEN )
{
commandtoolong:
SysMessage( "Command too long\n" );
sText.Empty();
return 0;
}
if ( nChar == '\r' || nChar == '\n' )
{
// Ignore the character if we have no text stored
if (!sText.GetLength())
return 1;
if ( fEcho )
{
SysMessage("\n");
}
return 2;
}
else if ( nChar == 9 ) // TAB (auto-completion)
{
lpctstr p = nullptr;
lpctstr tmp = nullptr;
size_t inputLen = 0;
bool matched(false);
// extract up to start of the word
p = sText.GetPtr() + sText.GetLength();
while (( p >= sText.GetPtr() ) && ( *p != '.' ) && ( *p != ' ' ) && ( *p != '/' ) && ( *p != '=' )) p--;
p++;
inputLen = strlen(p);
// search in the auto-complete list for starting on P, and save coords of 1st and Last matched
CSStringListRec *firstmatch = nullptr, *lastmatch = nullptr;
CSStringListRec *curmatch = nullptr, *nextmatch = nullptr; // the one that should be set
for ( curmatch = g_AutoComplete.GetHead(); curmatch != nullptr; curmatch = nextmatch )
{
nextmatch = curmatch->GetNext();
if ( !strnicmp(curmatch->GetPtr(), p, inputLen) ) // matched
{
if ( firstmatch == nullptr )
firstmatch = lastmatch = curmatch;
else
lastmatch = curmatch;
}
else if ( lastmatch ) // if no longer matches - save time by instant quit
break;
}
if (( firstmatch != nullptr ) && ( firstmatch == lastmatch )) // there IS a match and the ONLY
{
tmp = firstmatch->GetPtr() + inputLen;
matched = true;
}
else if ( firstmatch != nullptr ) // also make SE (if SERV/SERVER in dic) to become SERV
{
p = tmp = firstmatch->GetPtr();
tmp += inputLen;
inputLen = strlen(p);
matched = true;
for ( curmatch = firstmatch->GetNext(); curmatch != lastmatch->GetNext(); curmatch = curmatch->GetNext() )
{
if (strnicmp(curmatch->GetPtr(), p, inputLen) != 0) // mismatched
{
matched = false;
break;
}
}
}
if ( matched )
{
if ( fEcho )
SysMessage(tmp);
sText += tmp;
if ( sText.GetLength() > SCRIPT_MAX_LINE_LEN )
goto commandtoolong;
}
return 1;
}
if ( fEcho )
{
// Echo
tchar szTmp[2];
szTmp[0] = nChar;
szTmp[1] = '\0';
SysMessage( szTmp );
}
if ( nChar == 8 )
{
if ( sText.GetLength()) // back key
{
sText.SetLength( sText.GetLength() - 1 );
}
return 1;
}
sText += nChar;
return 1;
}
int maemo_main(int argc, char **argv)
{
ChangeWorkingDirectory("c");
char file[MAXPATHLEN] = "";
char path[MAXPATHLEN];
const char *cdfile = NULL;
int loadst = 0;
int i;
strcpy(Config.BiosDir, "/home/user/MyDocs");
strcpy(Config.PluginsDir, "/opt/maemo/usr/games/plugins");
snprintf(Config.PatchesDir, sizeof(Config.PatchesDir), "/opt/maemo/usr/games" PATCHES_DIR);
Config.PsxAuto = 1;
// read command line options
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-psxout")) Config.PsxOut = 1;
else if (!strcmp(argv[i], "-load")) loadst = atol(argv[++i]);
else if (!strcmp(argv[i], "-cdfile")) {
char isofilename[MAXPATHLEN];
if (i+1 >= argc) break;
strncpy(isofilename, argv[++i], MAXPATHLEN);
if (isofilename[0] != '/') {
getcwd(path, MAXPATHLEN);
if (strlen(path) + strlen(isofilename) + 1 < MAXPATHLEN) {
strcat(path, "/");
strcat(path, isofilename);
strcpy(isofilename, path);
} else
isofilename[0] = 0;
}
cdfile = isofilename;
}
else if (!strcmp(argv[i],"-frameskip")){
int tv_reg=atol(argv[++i]);
if (tv_reg>0){
UseFrameSkip=1;
fFrameRateHz = (tv_reg==1)?50.0f: 59.94f;
dwFrameRateTicks = (100000*100 / (unsigned long)(fFrameRateHz*100));
}
}
else if (!strcmp(argv[i],"-sputhreaded")){
iUseTimer=1;
}
else if (!strcmp(argv[i],"-nosound")){
strcpy(Config.Spu, "spunull.so");
}
else if(!strcmp(argv[i], "-bdir")) sprintf(Config.BiosDir, "%s", argv[++i]);
else if(!strcmp(argv[i], "-bios")) sprintf(Config.Bios, "%s", argv[++i]);
else if (!strcmp(argv[i],"-gles")){
strcpy(Config.Gpu, "gpuGLES.so");
}
else if (!strcmp(argv[i], "-cdda")) Config.Cdda = 1;
else if (!strcmp(argv[i], "-xa")) Config.Xa = 1;
else if (!strcmp(argv[i], "-rcnt")) Config.RCntFix = 1 ;
else if (!strcmp(argv[i], "-sio")) Config.Sio = 1;
else if (!strcmp(argv[i], "-spuirq")) Config.SpuIrq = 1;
else if (!strcmp(argv[i], "-vsync")) Config.VSyncWA = 1;
else if (!strcmp(argv[i], "-h") ||
!strcmp(argv[i], "-help") ||
!strcmp(argv[i], "--help")) {
printf(PACKAGE_NAME " " PACKAGE_VERSION "\n");
printf("%s\n", _(
" pcsx [options] [file]\n"
"\toptions:\n"
"\t-cdfile FILE\tRuns a CD image file\n"
"\t-psxout\t\tEnable PSX output\n"
"\t-nosound\t\tDisable sound using spunull plugin\n"
"\t-sputhreaded\t\tMove sound to separate thread\n"
"\t-frameskip\t\tEnable frameskip\n"
"\t-load STATENUM\tLoads savestate STATENUM (1-5)\n"
"\t-h -help\tDisplay this message\n"
"\tfile\t\tLoads file\n"));
return 0;
} else {
strncpy(file, argv[i], MAXPATHLEN);
if (file[0] != '/') {
getcwd(path, MAXPATHLEN);
if (strlen(path) + strlen(file) + 1 < MAXPATHLEN) {
strcat(path, "/");
strcat(path, file);
strcpy(file, path);
} else
file[0] = 0;
}
}
}
hildon_init(&argc, &argv);
if (cdfile)
set_cd_image(cdfile);
if (SysInit() == -1)
return 1;
if (LoadPlugins() == -1) {
SysMessage("Failed loading plugins!");
return 1;
}
if (OpenPlugins() == -1) {
return 1;
}
plugin_call_rearmed_cbs();
CheckCdrom();
SysReset();
if (file[0] != '\0') {
if (Load(file) != -1)
ready_to_go = 1;
} else {
if (cdfile) {
if (LoadCdrom() == -1) {
ClosePlugins();
printf(_("Could not load CD-ROM!\n"));
return -1;
}
ready_to_go = 1;
}
}
// If a state has been specified, then load that
if (loadst) {
int ret = emu_load_state(loadst - 1);
printf("%s state %d\n", ret ? "failed to load" : "loaded", loadst);
}
if (ready_to_go)
maemo_init();
else
{
printf ("somethings goes wrong, maybe you forgot -cdfile ? \n");
return 0;
}
while (1)
{
stop = 0;
emu_action = SACTION_NONE;
psxCpu->Execute();
if (emu_action != SACTION_NONE)
do_emu_action();
}
return 0;
}
bool CClient::Cmd_Use_Item( CItem * pItem, bool fTestTouch, bool fScript )
{
ADDTOCALLSTACK("CClient::Cmd_Use_Item");
// Assume we can see the target.
// called from Event_DoubleClick
if ( pItem == NULL )
return false;
if (pItem->m_Can & CAN_I_FORCEDC)
fTestTouch = false;
if ( fTestTouch )
{
if( !fScript )
{
CItemContainer * container = (dynamic_cast <CItemContainer*>(pItem->GetParent()));
if( container != NULL )
{
// protect from ,snoop - disallow picking from not opened containers
bool isInOpenedContainer = false;
IT_TYPE type = container->GetType();
if ( type == IT_EQ_TRADE_WINDOW)
{
isInOpenedContainer = true;
} else {
CClient::OpenedContainerMap_t::iterator itContainerFound = m_openedContainers.find( container->GetUID().GetPrivateUID() );
if ( itContainerFound != m_openedContainers.end() )
{
DWORD dwTopContainerUID = (((*itContainerFound).second).first).first;
DWORD dwTopMostContainerUID = (((*itContainerFound).second).first).second;
CPointMap ptOpenedContainerPosition = ((*itContainerFound).second).second;
const CObjBaseTemplate * pObjTop = pItem->GetTopLevelObj();
DWORD dwTopContainerUID_ToCheck = 0;
if ( container->GetContainer() )
dwTopContainerUID_ToCheck = container->GetContainer()->GetUID().GetPrivateUID();
else
dwTopContainerUID_ToCheck = pObjTop->GetUID().GetPrivateUID();
if ( ( dwTopMostContainerUID == pObjTop->GetUID().GetPrivateUID() ) && ( dwTopContainerUID == dwTopContainerUID_ToCheck ) )
{
if ( pObjTop->IsChar() )
{
isInOpenedContainer = true;
// probably a pickup check from pack if pCharTop != this?
}
else
{
const CItem * pItemTop = dynamic_cast<const CItem *>(pObjTop);
if ( pItemTop && (pItemTop->IsType(IT_SHIP_HOLD) || pItemTop->IsType(IT_SHIP_HOLD_LOCK)) && (pItemTop->GetTopPoint().GetRegion(REGION_TYPE_MULTI) == m_pChar->GetTopPoint().GetRegion(REGION_TYPE_MULTI)) )
{
isInOpenedContainer = true;
}
else if ( ptOpenedContainerPosition.GetDist( pObjTop->GetTopPoint() ) <= 3 )
{
isInOpenedContainer = true;
}
}
}
}
}
if( !isInOpenedContainer )
{
SysMessageDefault(DEFMSG_REACH_UNABLE);
return false;
}
}
}
// CanTouch handles priv level compares for chars
if ( ! m_pChar->CanUse( pItem, false ))
{
if ( ! m_pChar->CanTouch( pItem ))
{
SysMessage(( m_pChar->IsStatFlag( STATF_DEAD )) ?
g_Cfg.GetDefaultMsg( DEFMSG_REACH_GHOST ) :
g_Cfg.GetDefaultMsg( DEFMSG_REACH_FAIL ) );
}
else
{
SysMessageDefault( DEFMSG_REACH_UNABLE );
}
return false;
}
}
CItemBase * pItemDef = pItem->Item_GetDef();
bool fWasEquipped = pItem->IsItemEquipped();
if (( IsTrigUsed(TRIGGER_DCLICK) ) || ( IsTrigUsed(TRIGGER_ITEMDCLICK) ))
{
if ( pItem->OnTrigger( ITRIG_DCLICK, m_pChar ) == TRIGRET_RET_TRUE )
return true;
}
if ( pItemDef->IsTypeEquippable() && ! pItem->IsItemEquipped() && pItemDef->GetEquipLayer() )
{
if ( pItem->IsType(IT_LIGHT_OUT) && pItem->IsItemInContainer())
{
if ( ! Cmd_Use_Item_MustEquip( pItem ) )
return false;
}
else if ( ! pItem->IsType(IT_LIGHT_OUT) && ! pItem->IsType(IT_LIGHT_LIT) &&
! pItem->IsTypeSpellbook() )
{
if ( ! Cmd_Use_Item_MustEquip( pItem ) )
return false;
}
}
CItemSpawn * pSpawn = static_cast<CItemSpawn*>(pItem->m_uidSpawnItem.ItemFind()); //Removing this item from it's spawn when players DClick it from ground, no other way to take it out.
if ( pSpawn )
pSpawn->DelObj(pItem->GetUID());
SetTargMode();
m_Targ_UID = pItem->GetUID(); // probably already set anyhow.
m_tmUseItem.m_pParent = pItem->GetParent(); // Cheat Verify.
// Use types of items. (specific to client)
switch ( pItem->GetType() )
{
case IT_TRACKER:
{
DIR_TYPE dir = static_cast<DIR_TYPE>(DIR_QTY + 1); // invalid value.
if ( ! m_pChar->Skill_Tracking( pItem->m_uidLink, dir ))
{
if ( pItem->m_uidLink.IsValidUID())
{
SysMessageDefault( DEFMSG_TRACKING_UNABLE );
}
m_Targ_UID = pItem->GetUID();
addTarget( CLIMODE_TARG_LINK, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_TRACKER_ATTUNE ) );
}
}
return true;
case IT_TRACK_ITEM: // 109 - track a id or type of item.
case IT_TRACK_CHAR: // 110 = track a char or range of char id's
// Track a type of item or creature.
{
// Look in the local area for this item or char.
}
break;
case IT_SHAFT:
case IT_FEATHER:
{
if ( IsTrigUsed(TRIGGER_SKILLMENU) )
{
CScriptTriggerArgs args("sm_bolts");
if ( m_pChar->OnTrigger("@SkillMenu", m_pChar, &args) == TRIGRET_RET_TRUE )
return true;
}
return Cmd_Skill_Menu( g_Cfg.ResourceGetIDType( RES_SKILLMENU, "sm_bolts" ) );
}
case IT_FISH_POLE: // Just be near water ?
m_pChar->m_atResource.m_ridType = RESOURCE_ID( RES_TYPEDEF, IT_WATER );
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_FISHING_PROMT ), true );
return true;
case IT_DEED:
addTargetDeed( pItem );
return true;
case IT_EQ_BANK_BOX:
case IT_EQ_VENDOR_BOX:
if ( !fScript )
g_Log.Event( LOGL_WARN|LOGM_CHEAT,
"%lx:Cheater '%s' is using 3rd party tools to open bank box\n",
GetSocketID(), static_cast<LPCTSTR>(GetAccount()->GetName()));
return false;
case IT_CONTAINER_LOCKED:
case IT_SHIP_HOLD_LOCK:
if ( ! m_pChar->GetPackSafe()->ContentFindKeyFor( pItem ))
{
SysMessageDefault( DEFMSG_ITEMUSE_LOCKED );
if ( ! IsPriv( PRIV_GM ))
return false;
}
case IT_CORPSE:
case IT_SHIP_HOLD:
case IT_CONTAINER:
case IT_TRASH_CAN:
{
CItemContainer * pPack = dynamic_cast <CItemContainer *>(pItem);
if (!pPack)
return false;
if ( ! m_pChar->Skill_Snoop_Check( pPack ))
{
if( !addContainerSetup(pPack) ) {
return false;
}
}
const CItemCorpse * pCorpseItem = dynamic_cast <const CItemCorpse *>(pPack);
if ( m_pChar->CheckCorpseCrime( pCorpseItem, true, true ) )
SysMessageDefault(DEFMSG_LOOT_CRIMINAL_ACT);
}
return true;
case IT_GAME_BOARD:
if ( ! pItem->IsTopLevel())
{
SysMessageDefault( DEFMSG_ITEMUSE_GAMEBOARD_FAIL );
return false;
}
{
CItemContainer* pBoard = dynamic_cast <CItemContainer *>(pItem);
ASSERT(pBoard);
pBoard->Game_Create();
addContainerSetup( pBoard );
}
return true;
case IT_BBOARD:
addBulletinBoard( dynamic_cast<CItemContainer *>(pItem));
return true;
case IT_SIGN_GUMP:
// Things like grave stones and sign plaques.
// Need custom gumps.
{
GUMP_TYPE gumpid = pItemDef->m_ttContainer.m_gumpid;
if ( ! gumpid )
{
return false;
}
addGumpTextDisp( pItem, gumpid, pItem->GetName(),
( pItem->IsIndividualName()) ? pItem->GetName() : NULL );
}
return true;
case IT_BOOK:
case IT_MESSAGE:
if ( ! addBookOpen( pItem ))
{
SysMessageDefault( DEFMSG_ITEMUSE_BOOK_FAIL );
}
return true;
case IT_STONE_GUILD:
case IT_STONE_TOWN:
// Guild and town stones.
return true;
case IT_POTION:
if ( !m_pChar->CanMove(pItem) )
{
SysMessageDefault( DEFMSG_ITEMUSE_POTION_FAIL );
return false;
}
if ( RES_GET_INDEX(pItem->m_itPotion.m_Type) == SPELL_Poison )
{
// If we click directly on poison potion, we will drink poison and get ill.
// To use it on Poisoning skill, the skill will request to target the potion.
m_pChar->OnSpellEffect(SPELL_Poison, m_pChar, pItem->m_itSpell.m_spelllevel, NULL);
return true;
}
else if ( RES_GET_INDEX(pItem->m_itPotion.m_Type) == SPELL_Explosion )
{
// Throw explode potion.
if ( !m_pChar->ItemPickup(pItem, 1) )
return false;
m_tmUseItem.m_pParent = pItem->GetParent(); // put the potion in our hand
addTarget(CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg(DEFMSG_SELECT_POTION_TARGET), true, true, 5*TICK_PER_SEC);
pItem->m_itPotion.m_tick = 4; // countdown to explode
pItem->m_itPotion.m_ignited = 1; // ignite it
pItem->SetTimeout(TICK_PER_SEC);
pItem->m_uidLink = m_pChar->GetUID();
return true;
}
m_pChar->Use_Drink(pItem);
return true;
case IT_ANIM_ACTIVE:
SysMessage( g_Cfg.GetDefaultMsg( DEFMSG_ITEM_IN_USE ) );
return false;
case IT_CLOCK:
addObjMessage( m_pChar->GetTopSector()->GetLocalGameTime(), pItem );
return true;
case IT_SPAWN_CHAR:
{
bool fReset = false;
if ( pItem->m_itSpawnChar.m_current )
SysMessageDefault( DEFMSG_ITEMUSE_SPAWNCHAR_NEG );
else
{
SysMessageDefault( DEFMSG_ITEMUSE_SPAWNCHAR_RSET );
fReset = true;
}
static_cast<CItemSpawn*>(pItem)->KillChildren();
if ( fReset )
pItem->SetTimeout( TICK_PER_SEC );
}
return true;
case IT_SPAWN_ITEM:
{
SysMessageDefault(DEFMSG_ITEMUSE_SPAWNITEM_TRIG);
//CItemSpawn *pSpawn = static_cast<CItemSpawn*>(pItem);
pSpawn->OnTick(true);
}
return true;
case IT_SHRINE:
if ( m_pChar->OnSpellEffect( SPELL_Resurrection, m_pChar, 1000, pItem ))
return true;
SysMessageDefault( DEFMSG_ITEMUSE_SHRINE );
return true;
case IT_SHIP_TILLER:
// dclick on tiller man.
pItem->Speak( g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_TILLERMAN ), HUE_TEXT_DEF, TALKMODE_SAY, FONT_NORMAL );
return true;
// A menu or such other action ( not instantanious)
case IT_WAND:
case IT_SCROLL: // activate the scroll.
{
SPELL_TYPE spell = static_cast<SPELL_TYPE>(RES_GET_INDEX(pItem->m_itWeapon.m_spell));
const CSpellDef* pSpellDef = g_Cfg.GetSpellDef(spell);
if (pSpellDef == NULL)
return false;
if ( IsSetMagicFlags( MAGICF_PRECAST ) && !pSpellDef->IsSpellType( SPELLFLAG_NOPRECAST ) )
{
int skill;
if (!pSpellDef->GetPrimarySkill(&skill, NULL))
return false;
m_tmSkillMagery.m_Spell = spell; // m_atMagery.m_Spell
m_pChar->m_atMagery.m_Spell = spell;
m_Targ_UID = pItem->GetUID(); // default target.
m_Targ_PrvUID = pItem->GetUID();
m_pChar->Skill_Start(static_cast<SKILL_TYPE>(skill));
return true;
}
return Cmd_Skill_Magery( spell, pItem );
}
case IT_RUNE:
// name the rune.
if ( ! m_pChar->CanMove( pItem, true ))
{
return false;
}
addPromptConsole( CLIMODE_PROMPT_NAME_RUNE, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_RUNE_NAME ), pItem->GetUID() );
return true;
case IT_CARPENTRY:
// Carpentry type tool
{
if ( IsTrigUsed(TRIGGER_SKILLMENU) )
{
CScriptTriggerArgs args("sm_carpentry");
if ( m_pChar->OnTrigger("@SkillMenu", m_pChar, &args) == TRIGRET_RET_TRUE )
return true;
}
return Cmd_Skill_Menu( g_Cfg.ResourceGetIDType( RES_SKILLMENU, "sm_carpentry" ) );
}
// Solve for the combination of this item with another.
case IT_FORGE:
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg ( DEFMSG_ITEMUSE_FORGE ) );
return true;
case IT_ORE:
// just use the nearest forge.
return m_pChar->Skill_Mining_Smelt( pItem, NULL );
case IT_INGOT:
return Cmd_Skill_Smith( pItem );
case IT_KEY:
case IT_KEYRING:
if ( pItem->GetTopLevelObj() != m_pChar && ! m_pChar->IsPriv(PRIV_GM))
{
SysMessageDefault( DEFMSG_ITEMUSE_KEY_FAIL );
return false;
}
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_KEY_PROMT ), false, true );
return true;
case IT_BANDAGE: // SKILL_HEALING, or SKILL_VETERINARY
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_BANDAGE_PROMT ), false, false );
return true;
case IT_BANDAGE_BLOOD: // Clean the bandages.
case IT_COTTON: // use on a spinning wheel.
case IT_WOOL: // use on a spinning wheel.
case IT_YARN: // Use this on a loom.
case IT_THREAD: // Use this on a loom.
case IT_COMM_CRYSTAL:
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_TARGET_PROMT ), false, false );
return true;
case IT_CARPENTRY_CHOP:
case IT_LOCKPICK: // Use on a locked thing.
case IT_SCISSORS:
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_TARGET_PROMT ), false, true );
return true;
case IT_WEAPON_MACE_SHARP: // war axe can be used to cut/chop trees.
case IT_WEAPON_SWORD: // 23 =
case IT_WEAPON_FENCE: // 24 = can't be used to chop trees.
case IT_WEAPON_AXE:
// set resource to trees
m_pChar->m_atResource.m_ridType = RESOURCE_ID( RES_TYPEDEF, IT_TREE );
case IT_WEAPON_MACE_STAFF:
case IT_WEAPON_MACE_SMITH: // Can be used for smithing ?
{
if (fWasEquipped || !IsSetOF(OF_NoDClickTarget))
addTarget(CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg(DEFMSG_ITEMUSE_WEAPON_PROMT), false, true);
}
return true;
case IT_FISH:
SysMessageDefault( DEFMSG_ITEMUSE_FISH_FAIL );
return true;
case IT_TELESCOPE:
// Big telescope.
SysMessageDefault( DEFMSG_ITEMUSE_TELESCOPE );
return true;
case IT_MAP:
addDrawMap(dynamic_cast<CItemMap*>(pItem));
return true;
case IT_CANNON_BALL:
{
TCHAR *pszTemp = Str_GetTemp();
sprintf(pszTemp, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_CBALL_PROMT ), static_cast<LPCTSTR>(pItem->GetName()));
addTarget(CLIMODE_TARG_USE_ITEM, pszTemp);
}
return true;
case IT_CANNON_MUZZLE:
// Make sure the cannon is loaded.
if ( ! m_pChar->CanUse( pItem, false ))
return( false );
if ( ! ( pItem->m_itCannon.m_Load & 1 ))
{
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_CANNON_POWDER ) );
return true;
}
if ( ! ( pItem->m_itCannon.m_Load & 2 ))
{
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_CANNON_SHOT ) );
return true;
}
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_CANNON_TARG ), false, true );
return true;
case IT_CRYSTAL_BALL:
// Gaze into the crystal ball.
return true;
case IT_WEAPON_MACE_CROOK:
if (fWasEquipped || !IsSetOF(OF_NoDClickTarget))
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_CROOK_PROMT ), false, true );
return true;
case IT_SEED:
case IT_PITCHER_EMPTY:
{ // not a crime.
TCHAR *pszTemp = Str_GetTemp();
sprintf(pszTemp, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_PITCHER_TARG ), static_cast<LPCTSTR>(pItem->GetName()));
addTarget(CLIMODE_TARG_USE_ITEM, pszTemp, true);
}
return true;
case IT_WEAPON_MACE_PICK:
if (fWasEquipped || !IsSetOF(OF_NoDClickTarget))
{ // Mine at the location. (possible crime?)
TCHAR *pszTemp = Str_GetTemp();
sprintf(pszTemp, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_MACEPICK_TARG ), static_cast<LPCTSTR>(pItem->GetName()));
m_pChar->m_atResource.m_ridType = RESOURCE_ID(RES_TYPEDEF, IT_ROCK);
addTarget(CLIMODE_TARG_USE_ITEM, pszTemp, true, true);
}
return true;
case IT_SPELLBOOK:
addSpellbookOpen( pItem );
return true;
case IT_SPELLBOOK_NECRO:
addSpellbookOpen( pItem, 101 );
return true;
case IT_SPELLBOOK_PALA:
addSpellbookOpen( pItem, 201 );
return true;
case IT_SPELLBOOK_BUSHIDO:
addSpellbookOpen( pItem, 401 );
return true;
case IT_SPELLBOOK_NINJITSU:
addSpellbookOpen( pItem, 501 );
return true;
case IT_SPELLBOOK_ARCANIST:
addSpellbookOpen( pItem, 601 );
return true;
case IT_SPELLBOOK_MYSTIC:
addSpellbookOpen( pItem, 678 );
return true;
case IT_SPELLBOOK_BARD:
addSpellbookOpen( pItem, 701 );
return true;
case IT_HAIR_DYE:
if (!m_pChar->LayerFind( LAYER_BEARD ) && !m_pChar->LayerFind( LAYER_HAIR ))
{
SysMessageDefault( DEFMSG_ITEMUSE_DYE_NOHAIR );
return true;
}
Dialog_Setup(CLIMODE_DIALOG, g_Cfg.ResourceGetIDType( RES_DIALOG, "d_HAIR_DYE" ), 0, pItem );
return true;
case IT_DYE:
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_DYE_VAT ) );
return true;
case IT_DYE_VAT:
addTarget( CLIMODE_TARG_USE_ITEM, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_DYE_TARG ), false, true );
return true;
case IT_MORTAR:
{
if ( IsTrigUsed(TRIGGER_SKILLMENU) )
{
CScriptTriggerArgs args("sm_alchemy");
if ( m_pChar->OnTrigger("@SkillMenu", m_pChar, &args) == TRIGRET_RET_TRUE )
return true;
}
return Cmd_Skill_Menu( g_Cfg.ResourceGetIDType( RES_SKILLMENU, "sm_alchemy" ) );
}
case IT_CARTOGRAPHY:
{
if ( IsTrigUsed(TRIGGER_SKILLMENU) )
{
CScriptTriggerArgs args("sm_cartography");
if ( m_pChar->OnTrigger("@SkillMenu", m_pChar, &args) == TRIGRET_RET_TRUE )
return true;
}
return Cmd_Skill_Menu( g_Cfg.ResourceGetIDType( RES_SKILLMENU, "sm_cartography" ) );
}
case IT_COOKING:
{
if ( IsTrigUsed(TRIGGER_SKILLMENU) )
{
CScriptTriggerArgs args("sm_cooking");
if ( m_pChar->OnTrigger("@SkillMenu", m_pChar, &args) == TRIGRET_RET_TRUE )
return true;
}
return Cmd_Skill_Menu( g_Cfg.ResourceGetIDType( RES_SKILLMENU, "sm_cooking" ) );
}
case IT_TINKER_TOOLS:
{
if ( IsTrigUsed(TRIGGER_SKILLMENU) )
{
CScriptTriggerArgs args("sm_tinker");
if ( m_pChar->OnTrigger("@SkillMenu", m_pChar, &args) == TRIGRET_RET_TRUE )
return true;
}
return Cmd_Skill_Menu( g_Cfg.ResourceGetIDType( RES_SKILLMENU, "sm_tinker" ) );
}
case IT_SEWING_KIT: // IT_SEWING_KIT Sew with materials we have on hand.
{
TCHAR *pszTemp = Str_GetTemp();
sprintf(pszTemp, g_Cfg.GetDefaultMsg( DEFMSG_ITEMUSE_SEWKIT_PROMT ), static_cast<LPCTSTR>(pItem->GetName()));
addTarget(CLIMODE_TARG_USE_ITEM, pszTemp);
}
return true;
case IT_SCROLL_BLANK:
Cmd_Skill_Inscription();
return true;
default:
// An NPC could use it this way.
if ( m_pChar->Use_Item( pItem ))
return( true );
break;
}
SysMessageDefault( DEFMSG_ITEMUSE_CANTTHINK );
return( false );
}
bool CClient::Cmd_Skill_Tracking( unsigned int track_sel, bool fExec )
{
ADDTOCALLSTACK("CClient::Cmd_Skill_Tracking");
// look around for stuff.
ASSERT(m_pChar);
if ( track_sel == UINT_MAX )
{
// Tacking (unlike other skills) is used during menu setup.
m_pChar->Skill_Cleanup(); // clean up current skill.
CMenuItem item[6];
item[0].m_sText = g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_SKILLMENU_TITLE );
item[1].m_id = ITEMID_TRACK_HORSE;
item[1].m_color = 0;
item[1].m_sText = g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_SKILLMENU_ANIMALS );
item[2].m_id = ITEMID_TRACK_OGRE;
item[2].m_color = 0;
item[2].m_sText = g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_SKILLMENU_MONSTERS );
item[3].m_id = ITEMID_TRACK_MAN;
item[3].m_color = 0;
item[3].m_sText = g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_SKILLMENU_HUMANS );
item[4].m_id = ITEMID_TRACK_WOMAN;
item[4].m_color = 0;
item[4].m_sText = g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_SKILLMENU_PLAYERS );
m_tmMenu.m_Item[0] = 0;
addItemMenu( CLIMODE_MENU_SKILL_TRACK_SETUP, item, 4 );
return( true );
}
if ( track_sel > 0 ) // Not Cancelled
{
ASSERT( track_sel < COUNTOF( m_tmMenu.m_Item ));
if ( fExec )
{
// Tracking menu got us here. Start tracking the selected creature.
m_pChar->SetTimeout( 1*TICK_PER_SEC );
m_pChar->m_Act_Targ = m_tmMenu.m_Item[track_sel]; // selected UID
m_pChar->Skill_Start( SKILL_TRACKING );
return true;
}
static const NPCBRAIN_TYPE sm_Track_Brain[] =
{
NPCBRAIN_QTY, // not used here.
NPCBRAIN_ANIMAL,
NPCBRAIN_MONSTER,
NPCBRAIN_HUMAN,
NPCBRAIN_NONE // players
};
if ( track_sel >= COUNTOF(sm_Track_Brain))
track_sel = COUNTOF(sm_Track_Brain)-1;
NPCBRAIN_TYPE track_type = sm_Track_Brain[ track_sel ];
CMenuItem item[ minimum( MAX_MENU_ITEMS, COUNTOF( m_tmMenu.m_Item )) ];
size_t count = 0;
item[0].m_sText = g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_SKILLMENU_TITLE );
m_tmMenu.m_Item[0] = track_sel;
CWorldSearch AreaChars( m_pChar->GetTopPoint(), m_pChar->Skill_GetBase(SKILL_TRACKING)/10 + 10 );
for (;;)
{
CChar * pChar = AreaChars.GetChar();
if ( pChar == NULL )
break;
if ( m_pChar == pChar )
continue;
if ( GetPrivLevel() < pChar->GetPrivLevel() && pChar->IsStatFlag(STATF_Insubstantial) )
continue;
CCharBase * pCharDef = pChar->Char_GetDef();
NPCBRAIN_TYPE basic_type = pChar->GetNPCBrain();
if ( basic_type == NPCBRAIN_DRAGON )
basic_type = NPCBRAIN_MONSTER;
if ( track_type != basic_type && track_type != NPCBRAIN_QTY )
{
if ( track_type != NPCBRAIN_NONE ) // no match.
continue;
if ( pChar->IsStatFlag( STATF_DEAD )) // can't track ghosts
continue;
if ( ! pChar->m_pPlayer )
continue;
// Check action difficulty when trying to track players
int tracking = m_pChar->Skill_GetBase( SKILL_TRACKING );
int detectHidden = m_pChar->Skill_GetBase( SKILL_DETECTINGHIDDEN );
if ( (g_Cfg.m_iRacialFlags & RACIALF_ELF_DIFFTRACK) && pChar->IsElf() )
tracking /= 2; // elves are more difficult to track (Difficult to Track racial trait)
int hiding = pChar->Skill_GetBase( SKILL_HIDING );
int stealth = pChar->Skill_GetBase( SKILL_STEALTH );
int divisor = maximum(hiding + stealth, 1);
int chance;
if ( g_Cfg.m_iFeatureSE & FEATURE_SE_UPDATE )
chance = 50 * (tracking * 2 + detectHidden) / divisor;
else
chance = 50 * (tracking + detectHidden + 10 * Calc_GetRandVal(20) ) / divisor;
if ( Calc_GetRandVal(100) > chance )
continue;
}
count ++;
item[count].m_id = static_cast<WORD>(pCharDef->m_trackID);
item[count].m_color = 0;
item[count].m_sText = pChar->GetName();
m_tmMenu.m_Item[count] = pChar->GetUID();
if ( count >= (COUNTOF( item )-1) )
break;
}
// Some credit for trying.
if ( count > 0 )
{
m_pChar->Skill_UseQuick( SKILL_TRACKING, 20 + Calc_GetRandLLVal( 30 ));
ASSERT(count < COUNTOF(item));
addItemMenu( CLIMODE_MENU_SKILL_TRACK, item, count );
return( true );
}
else
{
m_pChar->Skill_UseQuick( SKILL_TRACKING, 10 + Calc_GetRandLLVal( 30 ));
}
}
// Tracking failed or was cancelled.
static LPCTSTR const sm_Track_FailMsg[] =
{
g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_CANCEL ),
g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_FAIL_ANIMAL ),
g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_FAIL_MONSTER ),
g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_FAIL_HUMAN ),
g_Cfg.GetDefaultMsg( DEFMSG_TRACKING_FAIL_HUMAN )
};
if (track_sel >= COUNTOF(sm_Track_FailMsg))
track_sel = COUNTOF(sm_Track_FailMsg) - 1;
SysMessage( sm_Track_FailMsg[track_sel] );
return( false );
}
static int _OpenPlugins(void) {
int ret;
#ifndef NO_FRONTEND
signal(SIGINT, SignalExit);
signal(SIGPIPE, SignalExit);
#endif
GPU_clearDynarec(clearDynarec);
ret = CDR_open();
if (ret < 0) { SysMessage(_("Error opening CD-ROM plugin!")); return -1; }
ret = SPU_open();
if (ret < 0) { SysMessage(_("Error opening SPU plugin!")); return -1; }
SPU_registerCallback(SPUirq);
SPU_registerScheduleCb(SPUschedule);
// pcsx-rearmed: we handle gpu elsewhere
//ret = GPU_open(&gpuDisp, "PCSX", NULL);
//if (ret < 0) { SysMessage(_("Error opening GPU plugin!")); return -1; }
ret = PAD1_open(&gpuDisp);
if (ret < 0) { SysMessage(_("Error opening Controller 1 plugin!")); return -1; }
ret = PAD2_open(&gpuDisp);
if (ret < 0) { SysMessage(_("Error opening Controller 2 plugin!")); return -1; }
if (Config.UseNet && !NetOpened) {
netInfo info;
char path[MAXPATHLEN];
char dotdir[MAXPATHLEN];
MAKE_PATH(dotdir, "/.pcsx/plugins/", NULL);
strcpy(info.EmuName, "PCSX");
strncpy(info.CdromID, CdromId, 9);
strncpy(info.CdromLabel, CdromLabel, 9);
info.psxMem = psxM;
info.GPU_showScreenPic = GPU_showScreenPic;
info.GPU_displayText = GPU_displayText;
info.GPU_showScreenPic = GPU_showScreenPic;
info.PAD_setSensitive = PAD1_setSensitive;
sprintf(path, "%s%s", Config.BiosDir, Config.Bios);
strcpy(info.BIOSpath, path);
strcpy(info.MCD1path, Config.Mcd1);
strcpy(info.MCD2path, Config.Mcd2);
sprintf(path, "%s%s", dotdir, Config.Gpu);
strcpy(info.GPUpath, path);
sprintf(path, "%s%s", dotdir, Config.Spu);
strcpy(info.SPUpath, path);
sprintf(path, "%s%s", dotdir, Config.Cdr);
strcpy(info.CDRpath, path);
NET_setInfo(&info);
ret = NET_open(&gpuDisp);
if (ret < 0) {
if (ret == -2) {
// -2 is returned when something in the info
// changed and needs to be synced
char *ptr;
PARSEPATH(Config.Bios, info.BIOSpath);
PARSEPATH(Config.Gpu, info.GPUpath);
PARSEPATH(Config.Spu, info.SPUpath);
PARSEPATH(Config.Cdr, info.CDRpath);
strcpy(Config.Mcd1, info.MCD1path);
strcpy(Config.Mcd2, info.MCD2path);
return -2;
} else {
Config.UseNet = FALSE;
}
} else {
if (NET_queryPlayer() == 1) {
if (SendPcsxInfo() == -1) Config.UseNet = FALSE;
} else {
if (RecvPcsxInfo() == -1) Config.UseNet = FALSE;
}
}
NetOpened = TRUE;
} else if (Config.UseNet) {
NET_resume();
}
return 0;
}
bool CChar::Use_Eat( CItem * pItemFood, short iQty )
{
ADDTOCALLSTACK("CChar::Use_Eat");
// What we can eat should depend on body type.
// How much we can eat should depend on body size and current fullness.
//
// ??? monsters should be able to eat corpses / raw meat
// IT_FOOD or IT_FOOD_RAW
// NOTE: Some foods like apples are stackable !
if ( !CanMove(pItemFood) )
{
SysMessageDefault(DEFMSG_FOOD_CANTMOVE);
return false;
}
if ( Stat_GetMax(STAT_FOOD) == 0 )
{
SysMessageDefault(DEFMSG_FOOD_CANTEAT);
return false;
}
// Is this edible by me ?
if ( !Food_CanEat(pItemFood) )
{
SysMessageDefault(DEFMSG_FOOD_RCANTEAT);
return false;
}
if ( Stat_GetVal(STAT_FOOD) >= Stat_GetMax(STAT_FOOD) )
{
SysMessageDefault(DEFMSG_FOOD_CANTEATF);
return false;
}
Use_EatQty(pItemFood, iQty);
LPCTSTR pMsg;
int index = IMULDIV(Stat_GetVal(STAT_FOOD), 5, Stat_GetMax(STAT_FOOD));
switch ( index )
{
case 0:
pMsg = g_Cfg.GetDefaultMsg(DEFMSG_FOOD_FULL_1);
break;
case 1:
pMsg = g_Cfg.GetDefaultMsg(DEFMSG_FOOD_FULL_2);
break;
case 2:
pMsg = g_Cfg.GetDefaultMsg(DEFMSG_FOOD_FULL_3);
break;
case 3:
pMsg = g_Cfg.GetDefaultMsg(DEFMSG_FOOD_FULL_4);
break;
case 4:
pMsg = g_Cfg.GetDefaultMsg(DEFMSG_FOOD_FULL_5);
break;
case 5:
default:
pMsg = g_Cfg.GetDefaultMsg(DEFMSG_FOOD_FULL_6);
break;
}
SysMessage(pMsg);
return true;
}
EXPORT_C_(void) CDVDabout()
{
SysMessage("%s %d.%d", "CDVDnull Driver", revision, build);
}
int main(int argc, char **argv)
{
if (argc == 1 || (argc == 2 && (!strcmp(argv[1], "--help") || !strcmp(argv[1], "-help") || !strcmp(argv[1], "-h")))) {
PrintHelp();
return 0;
}
emu_core_preinit();
ChangeWorkingDirectory("c");
char file[MAXPATHLEN] = "";
char path[MAXPATHLEN];
const char *cdfile = NULL;
int loadst = 0;
int i;
int getst = -1;
int discNumber = 0;
g_menuscreen_w = 800;
g_menuscreen_h = 480;
strcpy(Config.Gpu, "builtin_gpu");
strcpy(Config.Spu, "builtin_spu");
strcpy(Config.BiosDir, "/home/user/MyDocs");
strcpy(Config.PluginsDir, "/opt/maemo/usr/games/plugins");
snprintf(Config.PatchesDir, sizeof(Config.PatchesDir), "/opt/maemo/usr/games" PATCHES_DIR);
Config.PsxAuto = 1;
pl_rearmed_cbs.frameskip = -1;
strcpy(Config.Bios, "HLE");
iUseReverb = 0;
iUseInterpolation = 0;
in_type1 = PSE_PAD_TYPE_STANDARD;
in_type2 = PSE_PAD_TYPE_STANDARD;
accelOptions.sens = 150;
accelOptions.y_def = 500;
accelOptions.maxValue = 500.0;
// read command line options
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-psxout")) Config.PsxOut = 1;
else if (!strcmp(argv[i], "-load")) loadst = atol(argv[++i]);
else if (!strcmp(argv[i], "-cdfile")) {
char isofilename[MAXPATHLEN];
if (i+1 >= argc) break;
strncpy(isofilename, argv[++i], MAXPATHLEN);
if (isofilename[0] != '/') {
getcwd(path, MAXPATHLEN);
if (strlen(path) + strlen(isofilename) + 1 < MAXPATHLEN) {
strcat(path, "/");
strcat(path, isofilename);
strcpy(isofilename, path);
} else
isofilename[0] = 0;
}
cdfile = isofilename;
}
else if (!strcmp(argv[i],"-frameskip")) {
int tv_reg = atol(argv[++i]);
if (tv_reg < -1)
pl_rearmed_cbs.frameskip = -1;
else
pl_rearmed_cbs.frameskip = tv_reg;
}
else if (!strcmp(argv[i],"-region")) {
int psx_reg = atol(argv[++i]);
if (psx_reg == 0 || psx_reg == 1){
Config.PsxAuto = 0;
Config.PsxType = psx_reg;
}
}
else if (!strcmp(argv[i],"-get_sstatename")) getst = atol(argv[++i]);
else if (!strcmp(argv[i], "-fullscreen")) g_maemo_opts |= 2;
else if (!strcmp(argv[i], "-accel")) g_maemo_opts |= 4;
else if (!strcmp(argv[i], "-nosound")) strcpy(Config.Spu, "spunull.so");
else if (!strcmp(argv[i], "-bdir")) sprintf(Config.BiosDir, "%s", argv[++i]);
else if (!strcmp(argv[i], "-pdir")) sprintf(Config.PluginsDir, "%s", argv[++i]);
else if (!strcmp(argv[i], "-bios")) sprintf(Config.Bios, "%s", argv[++i]);
else if (!strcmp(argv[i], "-gles")) { strcpy(Config.Gpu, "gpu_gles.so"); g_maemo_opts |= 8 ;}
else if (!strcmp(argv[i], "-oldgpu")) strcpy(Config.Gpu, "gpu_peops.so");
else if (!strcmp(argv[i], "-unai")) strcpy(Config.Gpu, "gpu_unai.so");
else if (!strcmp(argv[i], "-cdda")) Config.Cdda = 1;
else if (!strcmp(argv[i], "-xa")) Config.Xa = 1;
else if (!strcmp(argv[i], "-rcnt")) Config.RCntFix = 1 ;
else if (!strcmp(argv[i], "-sio")) Config.Sio = 1;
else if (!strcmp(argv[i], "-spuirq")) Config.SpuIrq = 1;
else if (!strcmp(argv[i], "-vsync")) Config.VSyncWA = 1;
else if (!strcmp(argv[i], "-fps")) g_opts |=OPT_SHOWFPS;
else if (!strcmp(argv[i], "-cpu")) g_opts |=OPT_SHOWCPU;
else if (!strcmp(argv[i], "-spu")) g_opts |=OPT_SHOWSPU;
else if (!strcmp(argv[i], "-nofl")) g_opts |=OPT_NO_FRAMELIM;
else if (!strcmp(argv[i], "-mcd1")) sprintf(Config.Mcd1, "%s", argv[++i]);
else if (!strcmp(argv[i], "-mcd2")) sprintf(Config.Mcd2, "%s", argv[++i]);
else if (!strcmp(argv[i], "-cpuclock")) cycle_multiplier = 10000 / atol(argv[++i]);
else if (!strcmp(argv[i], "-guncon")) in_type1 = PSE_PAD_TYPE_GUNCON;
else if (!strcmp(argv[i], "-gunnotrigger")) g_opts |= OPT_TSGUN_NOTRIGGER;
else if (!strcmp(argv[i], "-analog")) in_type1 = PSE_PAD_TYPE_ANALOGPAD;
else if (!strcmp(argv[i], "-vibration")) { in_type1 = PSE_PAD_TYPE_ANALOGPAD; in_enable_vibration = 1; }
else if (!strcmp(argv[i], "-sens")) accelOptions.sens = atol(argv[++i]);
else if (!strcmp(argv[i], "-ydef")) accelOptions.y_def = atol(argv[++i]);
else if (!strcmp(argv[i], "-max")) accelOptions.maxValue = atol(argv[++i]);
else if (!strcmp(argv[i], "-displayon")) bKeepDisplayOn = TRUE;
else if (!strcmp(argv[i], "-keys")) sprintf(keys_config_file, "%s", argv[++i]);
else if (!strcmp(argv[i], "-autosave")) bAutosaveOnExit = TRUE;
else if (!strcmp(argv[i], "-disc")) discNumber = atol(argv[++i]);
else if (!strcmp(argv[i], "-corners")){
int j = 0;
i++;
char num[2];
for (j=0; j<strlen(argv[i]); j++){
strncpy(num, argv[i] + j, 1);
cornerActions[j] = atoi(num);
}
}
else if (!strcmp(argv[i], "-spu_reverb")) { if (atol(argv[++i]) > 0) iUseReverb = 2; }
else if (!strcmp(argv[i], "-spu_interpolation")) iUseInterpolation = atol(argv[++i]);
else if (!strcmp(argv[i], "-enhance")) pl_rearmed_cbs.gpu_neon.enhancement_enable = 1;
else if (!strcmp(argv[i], "-enhancehack")) pl_rearmed_cbs.gpu_neon.enhancement_no_main = 1;
else if (!strcmp(argv[i], "-gles_dithering")) pl_rearmed_cbs.gpu_peopsgl.bDrawDither = atol(argv[++i]);
else if (!strcmp(argv[i], "-gles_mask")) pl_rearmed_cbs.gpu_peopsgl.iUseMask = atol(argv[++i]);
else if (!strcmp(argv[i], "-gles_filtering")) pl_rearmed_cbs.gpu_peopsgl.iFilterType = atol(argv[++i]);
else if (!strcmp(argv[i], "-gles_fbtex")) pl_rearmed_cbs.gpu_peopsgl.iFrameTexType = atol(argv[++i]);
else if (!strcmp(argv[i], "-gles_vram")) pl_rearmed_cbs.gpu_peopsgl.iVRamSize = atol(argv[++i]);
else if (!strcmp(argv[i], "-gles_fastmdec")) pl_rearmed_cbs.gpu_peopsgl.bUseFastMdec = atol(argv[++i]);
else if (!strcmp(argv[i], "-gles_advblend")) pl_rearmed_cbs.gpu_peopsgl.bAdvancedBlend = atol(argv[++i]);
else if (!strcmp(argv[i], "-gles_opaque")) pl_rearmed_cbs.gpu_peopsgl.bOpaquePass = atol(argv[++i]);
else {
fprintf(stderr, "Unknown option: %s\n", argv[i]);
return 1;
}
}
pl_init();
if (emu_core_init() == -1)
return 1;
if (cdfile) {
set_cd_image(cdfile);
strcpy(file_name, strrchr(cdfile,'/'));
}
if (LoadPlugins() == -1) {
SysMessage("Failed loading plugins!");
return 1;
}
if (discNumber > 0)
cdrIsoMultidiskSelect = discNumber - 1;
if (OpenPlugins() == -1) {
return 1;
}
plugin_call_rearmed_cbs();
CheckCdrom();
if (getst >= 0){
char fname[MAXPATHLEN];
get_state_filename(fname, sizeof(fname), getst);
printf("SAVESTATE: %s\n", fname);
if (cdrIsoMultidiskCount > 1){
int i = 0;
for (i=1; i<cdrIsoMultidiskCount; i++){
cdrIsoMultidiskSelect = i;
CdromId[0] = '\0';
CdromLabel[0] = '\0';
CDR_close();
if (CDR_open() == 0){
CheckCdrom();
get_state_filename(fname, sizeof(fname), getst);
printf("SAVESTATE: %s\n", fname);
}
}
}
return 0;
}
SysReset();
if (file[0] != '\0') {
if (Load(file) != -1)
ready_to_go = 1;
} else {
if (cdfile) {
if (LoadCdrom() == -1) {
ClosePlugins();
printf(_("Could not load CD-ROM!\n"));
return -1;
}
emu_on_new_cd(0);
ready_to_go = 1;
}
}
if (!ready_to_go) {
printf ("something goes wrong, maybe you forgot -cdfile ? \n");
return 1;
}
if (cdrIsoMultidiskCount > 1)
printf ("Loaded a multidisc image: %i discs.\n", cdrIsoMultidiskCount);
// If a state has been specified, then load that
if (loadst) {
int ret = emu_load_state(loadst - 1);
printf("%s state %d\n", ret ? "Failed to load" : "Loaded", loadst);
state_slot = loadst - 1;
}
if (maemo_init(&argc, &argv))
return 1;
if (GPU_open != NULL) {
int ret = GPU_open(&gpuDisp, "PCSX", NULL);
if (ret){
fprintf(stderr, "Warning: GPU_open returned %d\n", ret);
gpuDisp=ret;
}
}
if (Config.HLE)
printf("Note: running without BIOS, expect compatibility problems\n");
dfinput_activate();
pl_timing_prepare(Config.PsxType);
while (1)
{
stop = 0;
emu_action = SACTION_NONE;
psxCpu->Execute();
if (emu_action != SACTION_NONE)
do_emu_action();
}
maemo_finish();
return 0;
}
long CALLBACK NETopen(unsigned long *gpuDisp) {
int ret = sockOpen();
struct sockaddr_in address;
if (ret == -1) return -1;
if (conf.PlayerNum == 1) {
int listen_sock, reuse_addr = 1;
int ret;
memset((char *)&address, 0, sizeof (address));
address.sin_family = AF_INET;
address.sin_port = htons(conf.PortNum);
address.sin_addr.s_addr = INADDR_ANY;
listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if (listen_sock == -1)
return -1;
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuse_addr, sizeof(reuse_addr));
if (bind(listen_sock,(struct sockaddr *) &address, sizeof(address)) == -1)
return -1;
if (listen(listen_sock, 1) != 0)
return -1;
sock = -1;
WaitCancel = 0;
sockCreateWaitDlg();
while (sock < 0) {
FD_ZERO(&rset);
FD_SET(listen_sock, &rset);
ret = select(listen_sock + 1, &rset, NULL, NULL, &tm);
if (FD_ISSET(listen_sock, &rset)) {
sock = accept(listen_sock, NULL, NULL);
}
if (WaitCancel) break;
sockDlgUpdate();
}
close(listen_sock);
sockDestroyWaitDlg();
if (WaitCancel == 1) return -1;
} else {
memset((char *)&address, 0, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(conf.PortNum);
address.sin_addr.s_addr = inet_addr(conf.ipAddress);
sock = socket(AF_INET, SOCK_STREAM, 0);
if (connect(sock, (struct sockaddr *)&address, sizeof(address))!=0) {
SysMessage(_("error connecting to %s: %s\n"), conf.ipAddress, strerror(errno));
return -1;
}
}
PadInit = 0;
PadCount = 0;
PadSize[0] = -1;
PadSize[1] = -1;
PadRecvSize = -1;
PadSendSize = -1;
Ping = sockPing();
Ping = (sockPing() + Ping) / 2;
Ping = (sockPing() + Ping) / 2;
if (conf.PlayerNum == 1) {
PadCountMax = (int)(((double)Ping / 1000.0) * 60.0);
if (PadCountMax <= 0) PadCountMax = 1;
SEND(&PadCountMax, 4, PSE_NET_BLOCKING);
} else {
RECV(&PadCountMax, 4, PSE_NET_BLOCKING);
}
PadSendData = (char *)malloc(PadCountMax * 128);
if (PadSendData == NULL) {
SysMessage(_("Error allocating memory!\n")); return -1;
}
memset(PadSendData, 0xff, PadCountMax);
return ret;
}
EXPORT_C_(void) CDVDabout()
{
SysMessage("%s %d.%d", LibName, revision, build);
}
bool CClient::OnRxConsole( const BYTE * pData, size_t iLen )
{
ADDTOCALLSTACK("CClient::OnRxConsole");
// A special console version of the client. (Not game protocol)
if ( !iLen || ( GetConnectType() != CONNECT_TELNET ))
return false;
if ( IsSetEF( EF_AllowTelnetPacketFilter ) )
{
bool fFiltered = xPacketFilter(pData, iLen);
if ( fFiltered )
return fFiltered;
}
while ( iLen -- )
{
int iRet = OnConsoleKey( m_Targ_Text, *pData++, m_pAccount != NULL );
if ( ! iRet )
return( false );
if ( iRet == 2 )
{
if ( !m_pAccount )
{
if ( !m_zLogin[0] )
{
if ( static_cast<size_t>(m_Targ_Text.GetLength()) > COUNTOF(m_zLogin) - 1 )
{
SysMessage("Login:\n");
}
else
{
strcpy(m_zLogin, m_Targ_Text);
SysMessage("Password:\n");
}
m_Targ_Text.Empty();
}
else
{
CGString sMsg;
CAccountRef pAccount = g_Accounts.Account_Find(m_zLogin);
if (( pAccount == NULL ) || ( pAccount->GetPrivLevel() < PLEVEL_Admin ))
{
SysMessagef("%s\n", g_Cfg.GetDefaultMsg(DEFMSG_CONSOLE_NOT_PRIV));
m_Targ_Text.Empty();
return false;
}
if ( LogIn(m_zLogin, m_Targ_Text, sMsg ) == PacketLoginError::Success )
{
m_Targ_Text.Empty();
return OnRxConsoleLoginComplete();
}
else if ( ! sMsg.IsEmpty())
{
SysMessage( sMsg );
return false;
}
m_Targ_Text.Empty();
}
return true;
}
else
{
iRet = g_Serv.OnConsoleCmd( m_Targ_Text, this );
if (g_Cfg.m_fTelnetLog && GetPrivLevel() >= g_Cfg.m_iCommandLog)
g_Log.Event(LOGM_GM_CMDS, "%lx:'%s' commands '%s'=%d\n", GetSocketID(), GetName(), static_cast<LPCTSTR>(m_Targ_Text), iRet);
}
}
}
return true;
}
EXPORT_C_(void) PADabout()
{
SysMessage("OnePad is a rewrite of Zerofrog's ZeroPad, done by arcum42.");
}
bool CClient::OnRxPing( const BYTE * pData, size_t iLen )
{
ADDTOCALLSTACK("CClient::OnRxPing");
// packet iLen < 5
// UOMon should work like this.
// RETURN: true = keep the connection open.
if ( GetConnectType() != CONNECT_UNK )
return false;
if ( !iLen || iLen > 4 )
return false;
switch ( pData[0] )
{
// Remote Admin Console
case '\x1':
case ' ':
{
if ( (iLen > 1) &&
(iLen != 2 || pData[1] != '\n') &&
(iLen != 3 || pData[1] != '\r' || pData[2] != '\n') &&
(iLen != 3 || pData[1] != '\n' || pData[2] != '\0') )
break;
// enter into remote admin mode. (look for password).
SetConnectType( CONNECT_TELNET );
m_zLogin[0] = 0;
SysMessagef("%s %s Admin Telnet\n", g_Cfg.GetDefaultMsg(DEFMSG_CONSOLE_WELCOME_1), g_Serv.GetName());
if ( g_Cfg.m_fLocalIPAdmin )
{
// don't bother logging in if local.
if ( GetPeer().IsLocalAddr() )
{
CAccountRef pAccount = g_Accounts.Account_Find("Administrator");
if ( !pAccount )
pAccount = g_Accounts.Account_Find("RemoteAdmin");
if ( pAccount )
{
CGString sMsg;
BYTE lErr = LogIn( pAccount, sMsg );
if ( lErr != PacketLoginError::Success )
{
if ( lErr != PacketLoginError::Invalid )
SysMessage( sMsg );
return( false );
}
return OnRxConsoleLoginComplete();
}
}
}
SysMessage("Login:\n");
return true;
}
//Axis Connection
case '@':
{
if ( (iLen > 1) &&
(iLen != 2 || pData[1] != '\n') &&
(iLen != 3 || pData[1] != '\r' || pData[2] != '\n') &&
(iLen != 3 || pData[1] != '\n' || pData[2] != '\0') )
break;
// enter into Axis mode. (look for password).
SetConnectType( CONNECT_AXIS );
m_zLogin[0] = 0;
time_t dateChange;
DWORD dwSize = 0;
CFileList::ReadFileInfo( "Axis.db", dateChange, dwSize );
SysMessagef("%lu",dwSize);
return true;
}
// ConnectUO Status
case 0xF1:
{
// ConnectUO sends a 4-byte packet when requesting status info
// BYTE Cmd (0xF1)
// WORD Unk (0x04)
// BYTE SubCmd (0xFF)
if ( iLen != MAKEWORD( pData[2], pData[1] ) )
break;
if ( pData[3] != 0xFF )
break;
if ( g_Cfg.m_fCUOStatus == false )
{
g_Log.Event( LOGM_CLIENTS_LOG|LOGL_EVENT, "%lx:CUO Status request from %s has been rejected.\n", GetSocketID(), GetPeerStr());
return false;
}
// enter 'remote admin mode'
SetConnectType( CONNECT_TELNET );
g_Log.Event( LOGM_CLIENTS_LOG|LOGL_EVENT, "%lx:CUO Status request from %s\n", GetSocketID(), GetPeerStr());
SysMessage( g_Serv.GetStatusString( 0x25 ) );
// exit 'remote admin mode'
SetConnectType( CONNECT_UNK );
return false;
}
// UOGateway Status
case 0xFF:
case 0x7F:
case 0x22:
{
if ( iLen > 1 )
break;
if ( g_Cfg.m_fUOGStatus == false )
{
g_Log.Event( LOGM_CLIENTS_LOG|LOGL_EVENT, "%lx:UOG Status request from %s has been rejected.\n", GetSocketID(), GetPeerStr());
return false;
}
// enter 'remote admin mode'
SetConnectType( CONNECT_TELNET );
g_Log.Event( LOGM_CLIENTS_LOG|LOGL_EVENT, "%lx:UOG Status request from %s\n", GetSocketID(), GetPeerStr());
if (pData[0] == 0x7F)
SetConnectType( CONNECT_UOG );
SysMessage( g_Serv.GetStatusString( 0x22 ) );
// exit 'remote admin mode'
SetConnectType( CONNECT_UNK );
return false;
}
}
g_Log.Event( LOGM_CLIENTS_LOG|LOGL_EVENT, "%lx:Unknown/invalid ping data '0x%x' from %s (Len: %" FMTSIZE_T ")\n", GetSocketID(), pData[0], GetPeerStr(), iLen);
return false;
}
int LoadPlugins() {
int ret;
char Plugin[MAXPATHLEN];
//ReleasePlugins();
cdrIsoInit();
#if 0
if (UsingIso()) {
LoadCDRplugin(NULL);
} else {
sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);
if (LoadCDRplugin(Plugin) == -1) return -1;
}
sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Gpu);
if (LoadGPUplugin(Plugin) == -1) return -1;
sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Spu);
if (LoadSPUplugin(Plugin) == -1) return -1;
sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad1);
if (LoadPAD1plugin(Plugin) == -1) return -1;
sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad2);
if (LoadPAD2plugin(Plugin) == -1) return -1;
if (strcmp("Disabled", Config.Net) == 0 || strcmp("", Config.Net) == 0)
Config.UseNet = FALSE;
else {
Config.UseNet = TRUE;
sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Net);
if (LoadNETplugin(Plugin) == -1) Config.UseNet = FALSE;
}
#ifdef ENABLE_SIO1API
sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Sio1);
if (LoadSIO1plugin(Plugin) == -1) return -1;
#endif
#endif
ret = CDR_init();
if (ret < 0) {
SysMessage (_("Error initializing CD-ROM plugin: %d"), ret);
return -1;
}
ret = GPU_init();
if (ret < 0) {
SysMessage (_("Error initializing GPU plugin: %d"), ret);
return -1;
}
ret = SPU_init();
if (ret < 0) {
SysMessage (_("Error initializing SPU plugin: %d"), ret);
return -1;
}
ret = PAD1_init(1);
if (ret < 0) {
SysMessage (_("Error initializing Controller 1 plugin: %d"), ret);
return -1;
}
ret = PAD2_init(2);
if (ret < 0) {
SysMessage (_("Error initializing Controller 2 plugin: %d"), ret);
return -1;
}
#if 0 // TEMP!!!
if (Config.UseNet) {
ret = NET_init();
if (ret < 0) {
SysMessage (_("Error initializing NetPlay plugin: %d"), ret);
return -1;
}
}
#endif
#ifdef ENABLE_SIO1API
ret = SIO1_init();
if (ret < 0) {
SysMessage (_("Error initializing SIO1 plugin: %d"), ret);
return -1;
}
#endif
ret = CDR_open();
if (ret < 0) {
SysMessage (_("Error open CD-ROM plugin: %d"), ret);
return -1;
}
ret = GPU_open(NULL, NULL, NULL);
if (ret < 0) {
SysMessage (_("Error open GPU plugin: %d"), ret);
return -1;
}
ret = SPU_open();
if (ret < 0) {
SysMessage (_("Error open SPU plugin: %d"), ret);
return -1;
}
SPU_registerCallback(SPUirq);
ret = PAD1_open();
if (ret < 0) {
SysMessage (_("Error open Controller 1 plugin: %d"), ret);
return -1;
}
ret = PAD2_open();
if (ret < 0) {
SysMessage (_("Error open Controller 2 plugin: %d"), ret);
return -1;
}
#if 0 // TEMP!!!
if (Config.UseNet) {
ret = NET_open(NULL);
if (ret < 0) {
SysMessage (_("Error open plugin: %d"), ret);
return -1;
}
}
#endif
#ifdef ENABLE_SIO1API
ret = SIO1_open();
if (ret < 0) {
SysMessage (_("Error open SIO1 plugin: %d"), ret);
return -1;
}
#endif
SysPrintf(_("Plugins loaded.\n"));
return 0;
}
void do_emu_action(void)
{
int ret;
emu_action_old = emu_action;
switch (emu_action) {
case SACTION_LOAD_STATE:
ret = emu_load_state(state_slot);
snprintf(hud_msg, sizeof(hud_msg), ret == 0 ? "LOADED" : "FAIL!");
break;
case SACTION_SAVE_STATE:
ret = emu_save_state(state_slot);
snprintf(hud_msg, sizeof(hud_msg), ret == 0 ? "SAVED" : "FAIL!");
break;
#ifndef NO_FRONTEND
case SACTION_ENTER_MENU:
toggle_fast_forward(1);
menu_loop();
return;
case SACTION_NEXT_SSLOT:
state_slot++;
if (state_slot > 9)
state_slot = 0;
goto do_state_slot;
case SACTION_PREV_SSLOT:
state_slot--;
if (state_slot < 0)
state_slot = 9;
do_state_slot:
snprintf(hud_msg, sizeof(hud_msg), "STATE SLOT %d [%s]", state_slot,
emu_check_state(state_slot) == 0 ? "USED" : "FREE");
hud_new_msg = 3;
SysPrintf("* %s\n", hud_msg);
break;
case SACTION_TOGGLE_FSKIP:
pl_rearmed_cbs.fskip_advice = 0;
pl_rearmed_cbs.frameskip++;
if (pl_rearmed_cbs.frameskip > 1)
pl_rearmed_cbs.frameskip = -1;
snprintf(hud_msg, sizeof(hud_msg), "FRAMESKIP: %s",
pl_rearmed_cbs.frameskip == -1 ? "AUTO" :
pl_rearmed_cbs.frameskip == 0 ? "OFF" : "1" );
plugin_call_rearmed_cbs();
break;
case SACTION_SWITCH_DISPMODE:
pl_switch_dispmode();
plugin_call_rearmed_cbs();
if (GPU_open != NULL && GPU_close != NULL) {
GPU_close();
GPU_open(&gpuDisp, "PCSX", NULL);
}
break;
case SACTION_FAST_FORWARD:
toggle_fast_forward(0);
plugin_call_rearmed_cbs();
break;
case SACTION_TOGGLE_FPS:
if ((g_opts & (OPT_SHOWFPS|OPT_SHOWCPU))
== (OPT_SHOWFPS|OPT_SHOWCPU))
g_opts &= ~(OPT_SHOWFPS|OPT_SHOWCPU);
else if (g_opts & OPT_SHOWFPS)
g_opts |= OPT_SHOWCPU;
else
g_opts |= OPT_SHOWFPS;
break;
case SACTION_TOGGLE_FULLSCREEN:
plat_target.vout_fullscreen = !plat_target.vout_fullscreen;
if (GPU_open != NULL && GPU_close != NULL) {
GPU_close();
GPU_open(&gpuDisp, "PCSX", NULL);
}
break;
case SACTION_SCREENSHOT:
{
char buf[MAXPATHLEN];
void *scrbuf;
int w, h, bpp;
time_t t = time(NULL);
struct tm *tb = localtime(&t);
int ti = tb->tm_yday * 1000000 + tb->tm_hour * 10000 +
tb->tm_min * 100 + tb->tm_sec;
scrbuf = pl_prepare_screenshot(&w, &h, &bpp);
get_gameid_filename(buf, sizeof(buf),
"screenshots/%.32s-%.9s.%d.png", ti);
ret = -1;
if (scrbuf != 0 && bpp == 16)
ret = writepng(buf, scrbuf, w, h);
if (ret == 0)
snprintf(hud_msg, sizeof(hud_msg), "SCREENSHOT TAKEN");
break;
}
case SACTION_VOLUME_UP:
case SACTION_VOLUME_DOWN:
{
static int volume;
plat_target_step_volume(&volume,
emu_action == SACTION_VOLUME_UP ? 1 : -1);
}
return;
case SACTION_MINIMIZE:
if (GPU_close != NULL)
GPU_close();
plat_minimize();
if (GPU_open != NULL) {
ret = GPU_open(&gpuDisp, "PCSX", NULL);
if (ret)
SysMessage("GPU_open returned %d", ret);
}
return;
#endif
default:
return;
}
hud_new_msg = 3;
}
