764 lines
22 KiB
Plaintext
764 lines
22 KiB
Plaintext
// Props to ExJam for this code :D Ported to OSpRose by Drakia
|
|
#include "../WorldServer.h"
|
|
|
|
//Check Quest
|
|
QUESTCOND(000)
|
|
{
|
|
GETCONDDATA(000);
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Check quest: %i", data->iQuestSN);
|
|
for(dword i = 0; i < 10; i++)
|
|
{
|
|
if(client->quest.quests[i].QuestID == data->iQuestSN)
|
|
{
|
|
client->CheckQuest = i;
|
|
client->ActiveQuest = data->iQuestSN;
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Check Quest # %i Found!", data->iQuestSN);
|
|
return QUEST_SUCCESS;
|
|
}
|
|
}
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Check Quest - Not Found!");
|
|
return QUEST_FAILURE;
|
|
}
|
|
|
|
//Check Quest Variable
|
|
QUESTCOND(001)
|
|
{
|
|
// int iDataCnt pos 0x00
|
|
// dword iType pos 0x02
|
|
// short m_wVarNO pos 0x02
|
|
// word m_wVarTYPE pos 0x04
|
|
// word nValue pos 0x06
|
|
// byte btOp pos 0x08
|
|
GETCONDDATA(001);
|
|
int retVal = 1;
|
|
if( client->questdebug )server->SendPM(client, "Data Count for this quest %i",data->iDataCnt);
|
|
for(int i = 0; i < data->iDataCnt; i++)
|
|
{
|
|
dword address = i * sizeof(STR_QUEST_DATA);
|
|
address += (dword)data;
|
|
address += 4;
|
|
STR_QUEST_DATA* curQst = (STR_QUEST_DATA*)address;
|
|
word nValue = curQst->nValue;
|
|
word tempValue = client->GetQuestVar(curQst->m_wVarTYPE, curQst->m_wVarNO);
|
|
//word tempValue = client->quest.quests[curQst->m_wVarTYPE].Variables[curQst->m_wVarNO];
|
|
//retVal = OperateValues<word>(curQst->btOp, &tempValue, curQst->nValue);
|
|
switch(curQst->btOp)
|
|
{
|
|
case 0:
|
|
retVal = (tempValue == curQst->nValue);
|
|
break;
|
|
case 1:
|
|
retVal = (tempValue > curQst->nValue);
|
|
break;
|
|
case 2:
|
|
retVal = (tempValue >= curQst->nValue);
|
|
break;
|
|
case 3:
|
|
retVal = (tempValue < curQst->nValue);
|
|
break;
|
|
case 4:
|
|
retVal = (tempValue <= curQst->nValue);
|
|
break;
|
|
case 10:
|
|
retVal = (tempValue != curQst->nValue);
|
|
break;
|
|
default:
|
|
retVal = 0;
|
|
Log( MSG_DEBUG, "QuestCond 001 bad value for btOp %i",curQst->btOp );
|
|
break;
|
|
}
|
|
if( client->questdebug )
|
|
{
|
|
server->SendPM(client, "is %i < %i ? retval %i",tempValue, curQst->nValue, retVal);
|
|
server->SendPM(client, "Check Quest Var[%04x][%i] - %i (Op: %i)", curQst->m_wVarTYPE, curQst->m_wVarNO, curQst->nValue, curQst->btOp);
|
|
}
|
|
if(retVal == 0) return QUEST_FAILURE;
|
|
}
|
|
return (retVal == 0)?QUEST_FAILURE:QUEST_SUCCESS;
|
|
}
|
|
|
|
//Check Quest Variable
|
|
QUESTCOND(002)
|
|
{
|
|
return QUEST_COND_001(server, client, raw);
|
|
}
|
|
|
|
//Check Stats
|
|
QUESTCOND(003)
|
|
{
|
|
//dword iDataCnt; pos 0x00
|
|
//dword iType; pos 0x04
|
|
//dword iValue; pos 0x08
|
|
//byte btOp; pos 0x0c
|
|
GETCONDDATA(003);
|
|
for(int i = 0; i < data->iDataCnt; i++)
|
|
{
|
|
dword address = i * 0x0C;
|
|
address += (dword)data;
|
|
address += 4;
|
|
STR_ABIL_DATA* curAbil = (STR_ABIL_DATA*)address;
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Check Stat[%i] %i (Op: %i)", curAbil->iType, curAbil->iValue, curAbil->btOp);
|
|
int tempValue;
|
|
switch( curAbil->iType )
|
|
{
|
|
case sGender:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->CharInfo->Sex, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sJob:
|
|
tempValue = client->CharInfo->Job / 100;
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Job Tempvalue = %i", tempValue);
|
|
//if(!OperateValues<int>(curAbil->btOp, (int*)&tempValue, curAbil->iValue))
|
|
if(!OperateValues<int>(curAbil->btOp, &tempValue, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sUnion: // Unions aren't implemented? - Drakia
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->Union_s->unionvar[0], curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sStrength:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->Attr->Str, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sDexterity:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->Attr->Dex, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sIntelligence:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->Attr->Int, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sConcentration:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->Attr->Con, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sCharm:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->Attr->Cha, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sSensibility:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->Attr->Sen, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sLevel:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->Stats->Level, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sStatPoints:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->CharInfo->StatPoints, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sMoney:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->CharInfo->Zulies, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
case sEXPRate:
|
|
if(!OperateValues<int>(curAbil->btOp, (int*)&client->Stats->xprate, curAbil->iValue))
|
|
return QUEST_FAILURE;
|
|
break;
|
|
default:
|
|
Log(MSG_WARNING, "QuestCond 003: Type Unknown: '%i'", curAbil->iType);
|
|
break;
|
|
}
|
|
}
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Check Items
|
|
QUESTCOND(004)
|
|
{
|
|
GETCONDDATA(004);
|
|
for(int i = 0; i < data->iDataCnt; i++)
|
|
{
|
|
dword address = i * 0x10;
|
|
address += (dword)data;
|
|
address += 4;
|
|
STR_ITEM_DATA* curItem = (STR_ITEM_DATA*)address;
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Check Item - [Slot:%i][Type:%i]", curItem->iWhere, curItem->uiItemSN);
|
|
// Check quest items for a specific amount
|
|
if (curItem->iWhere == 13) // it's a quest item
|
|
{
|
|
// Ok, check the current Check'd quest.
|
|
if (client->CheckQuest < 0) return QUEST_SUCCESS;
|
|
unsigned int j = client->CheckQuest;
|
|
bool Hasitem = false;
|
|
bool FoundItem = false;
|
|
for (unsigned int k = 0; k < 5; k++) //5 quest item slots
|
|
{
|
|
if (client->quest.quests[j].Items[k].itemnum == (curItem->uiItemSN % 1000))
|
|
{
|
|
FoundItem = true;
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Operate - btOp: %i Val1: %i Val2: %i", curItem->btOp, client->quest.quests[j].Items[k].count, curItem->iRequestCnt);
|
|
if(OperateValues<int>(curItem->btOp, (int*)(&client->quest.quests[j].Items[k].count), curItem->iRequestCnt))
|
|
Hasitem = true;
|
|
}
|
|
}
|
|
if(FoundItem == false) // didn't find any of the item in any of the quest slots
|
|
{
|
|
for (unsigned int k = 0; k < 5; k++) //Find the first empty slot
|
|
{
|
|
if (client->quest.quests[j].Items[k].count == 0 && Hasitem == false)
|
|
{
|
|
// Since the item doesn't exist, treat it as if there's 0 of them.
|
|
int tempInt = 0;
|
|
if(OperateValues<int>(curItem->btOp, &tempInt, curItem->iRequestCnt))
|
|
Hasitem = true;
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Requested item is not found. Comparing first empty slot instead");
|
|
}
|
|
}
|
|
}
|
|
if(Hasitem == false)
|
|
{
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Requested item is not present. Returning quest failure");
|
|
return QUEST_FAILURE;
|
|
}
|
|
}
|
|
else //this needs to be recoded. It doesn't do a damn thing right now WTF?
|
|
{
|
|
//item slot is not 13
|
|
// Check equipped items for a specific item? - Drakia
|
|
if(curItem->uiItemSN == 0 && curItem->iWhere != 0)
|
|
{
|
|
int itemHead = client->items[curItem->iWhere].itemtype;
|
|
if(!OperateValues<int>(curItem->btOp, &itemHead, curItem->uiItemSN))
|
|
return QUEST_FAILURE;
|
|
}
|
|
}
|
|
}
|
|
if( client->questdebug )
|
|
server->SendPM(client, "QuestCond 004 Returning Quest Success");
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Check Party
|
|
QUESTCOND(005)
|
|
{
|
|
//byte btIsLeader pos 0x00
|
|
//int iLevel pos 0x04
|
|
//byte btReversed pos 0x08
|
|
GETCONDDATA(005);
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Near Point
|
|
QUESTCOND(006)
|
|
{
|
|
//int iZoneSN; pos 0x00
|
|
//int iX; pos 0x04
|
|
//int iY; pos 0x08
|
|
//int iZ; pos 0x0c
|
|
//int iRadius; pos 0x10
|
|
GETCONDDATA(006);
|
|
client->UpdatePosition();
|
|
if(data->iZoneSN != 0)
|
|
{
|
|
if(client->Position->Map != data->iZoneSN)
|
|
return QUEST_FAILURE;
|
|
}
|
|
float dx = client->Position->current.x - (float)(data->iX / 100);
|
|
float dy = client->Position->current.y - (float)(data->iY / 100);
|
|
float distance = sqrt((dx*dx) + (dy*dy));
|
|
return (distance < data->iRadius)?QUEST_SUCCESS:QUEST_FAILURE;
|
|
}
|
|
|
|
//World Time
|
|
QUESTCOND(007)
|
|
{
|
|
//dword ulTime pos 0x00
|
|
//dword ulEndTime pos 0x04
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Quest Time
|
|
QUESTCOND(008)
|
|
{
|
|
//dword ulTime pos 0x00
|
|
//byte btOp pos 0x04
|
|
GETCONDDATA(008);
|
|
if( client->questdebug )
|
|
server->SendPM(client, "QuestTime - ulTime: %i btOp: %i", data->ulTime, data->btOp);
|
|
if (client->CheckQuest < 0) return QUEST_FAILURE; // Not checking a quest, don't return success
|
|
long int Time = 0;
|
|
if (server->STB_QUEST.rows[client->quest.quests[client->CheckQuest].QuestID][1] > 0)
|
|
{
|
|
Time += client->quest.quests[client->CheckQuest].StartTime; // Start time
|
|
Time += server->STB_QUEST.rows[client->quest.quests[client->CheckQuest].QuestID][1] * 10; // Time to finish
|
|
Time -= time(NULL); // Current time
|
|
if (Time < 0) Time = 0; // Time is up
|
|
Time /= 10; // Divide to get 10's of seconds
|
|
}
|
|
if (!OperateValues<dword>(data->btOp, (dword*)&Time, data->ulTime))
|
|
return QUEST_FAILURE;
|
|
else
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Check Skill
|
|
QUESTCOND(009)
|
|
{
|
|
//int iSkillSN1 pos 0x00
|
|
//int iSkillSN2 pos 0x02
|
|
//byte btOp pos 0x04
|
|
GETCONDDATA(009);
|
|
// Line not needed, never used - Drakia
|
|
//int checkVal = (data->btOp)?QUEST_SUCCESS:QUEST_FAILURE;
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Check Skill: %i", data->iSkillSN1);
|
|
bool s1 = false;
|
|
bool s2 = false;
|
|
for(dword i = 0; i < 30; i++)
|
|
{
|
|
if(client->bskills[i] == data->iSkillSN1)
|
|
s1 = true;
|
|
if(client->bskills[i] == data->iSkillSN2)
|
|
s2 = true;
|
|
if(client->askill[i] == data->iSkillSN1)
|
|
s1 = true;
|
|
if(client->askill[i] == data->iSkillSN2)
|
|
s2 = true;
|
|
if(client->pskill[i] == data->iSkillSN1)
|
|
s1 = true;
|
|
if(client->pskill[i] == data->iSkillSN2)
|
|
s2 = true;
|
|
}
|
|
if(data->btOp == 0)
|
|
{
|
|
if(s1 == false && s2 == false)
|
|
return QUEST_SUCCESS; //true if player does not have either skill
|
|
else
|
|
return QUEST_FAILURE;
|
|
}
|
|
else
|
|
{
|
|
if(s1 == true || s2 == true)
|
|
return QUEST_SUCCESS; //true if player has either skill
|
|
else
|
|
return QUEST_FAILURE;
|
|
}
|
|
//Log(MSG_DEBUG,"Questcond 009 btOp is neither 0 nor 1.");
|
|
//return QUEST_FAILURE;
|
|
}
|
|
|
|
//random number in range
|
|
QUESTCOND(010)
|
|
{
|
|
GETCONDDATA(010);
|
|
//byte btLowPcnt; pos 0x00
|
|
//byte btHighPcnt; pos 0x01
|
|
int randv = GServer->RandNumber(0,100);
|
|
if(randv >= data->btLowPcnt && randv <= data->btHighPcnt)return QUEST_SUCCESS;
|
|
return QUEST_FAILURE;
|
|
}
|
|
|
|
//Object Variable
|
|
QUESTCOND(011)
|
|
{
|
|
|
|
//byte btWho pos 0x00
|
|
//word nVarNo pos 0x02
|
|
//int iValue pos 0x04
|
|
//byte btOp pos 0x09
|
|
GETCONDDATA(011);
|
|
/*
|
|
if(data->btWho == 0)
|
|
{
|
|
CNpc* thisNpc = reinterpret_cast<CNpc*>(entity);
|
|
thisNpc = thisNpc->SelectedNpc;
|
|
if(thisNpc == NULL) return QUEST_FAILURE;
|
|
|
|
short VarValue = thisNpc->ObjVar.GetVar(data->nVarNo);
|
|
if(OperateValues(data->btOp, &VarValue, (short)data->iValue)) return QUEST_SUCCESS;
|
|
}*/
|
|
if(data->btWho == 0)
|
|
{
|
|
|
|
if(data->nVarNo > 19) return AI_FAILURE;
|
|
int refVal = GServer->ObjVar[client->NPCvar][data->nVarNo];
|
|
int tempval = 0;
|
|
switch( data->btOp )
|
|
{
|
|
case 0:
|
|
if(refVal == data->iValue)return QUEST_SUCCESS;
|
|
break;
|
|
case 1:
|
|
if(refVal > data->iValue)return QUEST_SUCCESS;
|
|
break;
|
|
case 2:
|
|
if(refVal >= data->iValue)return QUEST_SUCCESS;
|
|
break;
|
|
case 3:
|
|
if(refVal < data->iValue)return QUEST_SUCCESS;
|
|
break;
|
|
case 4:
|
|
if(refVal <= data->iValue)return QUEST_SUCCESS;
|
|
break;
|
|
case 10:
|
|
if(refVal != data->iValue)return QUEST_SUCCESS;
|
|
break;
|
|
default:
|
|
Log(MSG_WARNING,"Unknown btOp in QuestCond 011");
|
|
break;
|
|
}
|
|
}
|
|
return QUEST_FAILURE;
|
|
}
|
|
|
|
//select event object
|
|
QUESTCOND(012)
|
|
{
|
|
GETCONDDATA(012);
|
|
//word iZone; pos 0x00
|
|
//dword ulZone; pos 0x00
|
|
//int iX; pos 0x04
|
|
//int iY; pos 0x06
|
|
//int iEventID; pos 0x08
|
|
//dword m_HashEventOBJ; pos 0x08
|
|
//this should be easy enough - PY
|
|
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Select NPC
|
|
QUESTCOND(013)
|
|
{
|
|
//int iNpcNo pos 0x00
|
|
GETCONDDATA(013);
|
|
// dammit!!!! This darn function is set up to use the CCharacter class so I can't use entity (CCharacter)
|
|
// This is going to be a serious pain in the ass
|
|
// OK so we now have a temporary player structure so we shuold be able to do this.
|
|
|
|
//Log(MSG_DEBUG,"Setting NPC ref number AICOND(017). NPC Ref = %i",data->iNpcNo);
|
|
//CMonster* monster = reinterpret_cast<CMonster*>(entity);
|
|
//if(monster == NULL) return AI_FAILURE;
|
|
//monster->thisnpc->refNPC = data->iNpcNo; // sets the reference variable for the correct ObjVar
|
|
//Log(MSG_DEBUG,"Set NPC ref number %i successfully", monster->thisnpc->refNPC);
|
|
//not sure this is going to work properly for an NPC.
|
|
//NPC only exists as a temporary entity so refNPC may be lost after it returns from here.
|
|
|
|
|
|
/*if(entity->_EntityType != ENTITY_NPC) return QUEST_FAILURE;
|
|
|
|
CNpc* thisNpc = reinterpret_cast<CNpc*>(entity);
|
|
std::map<dword, CNpc*>::iterator triggerITR = server->NpcList.find(data->iNpcNo);
|
|
if(triggerITR == server->NpcList.end()){
|
|
thisNpc->SelectedNpc = NULL;
|
|
return QUEST_FAILURE;
|
|
}
|
|
thisNpc->SelectedNpc = triggerITR->second;
|
|
*/
|
|
client->NPCvar = data->iNpcNo;
|
|
//Actually that was kind of easy.. lol - PY
|
|
|
|
//return QUEST_SUCCESS;
|
|
// More NPC specific stuff
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Check Quest Flag
|
|
QUESTCOND(014)
|
|
{
|
|
GETCONDDATA(014);
|
|
//word nSN; pos 0x00
|
|
//byte btOp; pos 0x02
|
|
bool dataOp = (data->btOp)?true:false;
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Check QFlag[%i] == %i", data->nSN, data->btOp);
|
|
if(client->quest.GetFlag(data->nSN) == dataOp)
|
|
{
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Quest cond 014 (check quest flag) returned Success");
|
|
return QUEST_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
if( client->questdebug )
|
|
server->SendPM(client, "Quest cond 014 (check quest flag) returned Failure");
|
|
return QUEST_FAILURE;
|
|
}
|
|
}
|
|
|
|
//Party member count between X and Y - PY
|
|
QUESTCOND(015)
|
|
{
|
|
|
|
//word nNumber1 pos 0x00
|
|
//word nNumber2 pos 0x02
|
|
GETCONDDATA(015);
|
|
|
|
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Zone Time
|
|
QUESTCOND(016)
|
|
{
|
|
|
|
//byte btWho pos 0x00
|
|
//dword ulWho pos 0x00
|
|
//dword ulTime pos 0x04
|
|
//dword ulEndTime pos 0x08
|
|
GETCONDDATA(016);
|
|
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//NPC & Obj Variables?
|
|
QUESTCOND(017)
|
|
{
|
|
//dword iNpcNo pos 0x00
|
|
//word nVarNo pos 0x04
|
|
//word unused pos 0x06
|
|
//dword iNpcNo pos 0x08
|
|
//word nVarNo pos 0x0c
|
|
//word unused pos 0x0e
|
|
//byte btOp pos 0x0f
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Time on Date
|
|
QUESTCOND(018)
|
|
{
|
|
//Returns SUCCESS if the system time of the server is between the defined start and end times. Else returns FAILURE.
|
|
//Allows for time dependent quests
|
|
//byte btDate; pos 0x00
|
|
//byte btHour1; pos 0x01
|
|
//byte btMin1; pos 0x02
|
|
//byte btHour2; pos 0x03
|
|
//byte btMin2; pos 0x04
|
|
GETCONDDATA(018);
|
|
SYSTEMTIME sTIME;
|
|
GetLocalTime(&sTIME);
|
|
|
|
if(data->btDate != 0)
|
|
{
|
|
if(sTIME.wDay != data->btDate)
|
|
return QUEST_FAILURE;
|
|
}
|
|
word wMin = ((sTIME.wHour * 60) + sTIME.wMinute);
|
|
word wFrom = (data->btHour1 * 60) + data->btMin1;
|
|
word wTo = (data->btHour2 * 60) + data->btMin2;
|
|
if(wMin >= wFrom && wMin <= wTo)
|
|
return QUEST_SUCCESS;
|
|
return QUEST_FAILURE;
|
|
}
|
|
|
|
//Time on Day
|
|
QUESTCOND(019)
|
|
{
|
|
//byte btWeekDay; pos 0x00
|
|
//byte btHour1; pos 0x01
|
|
//byte btMin1; pos 0x02
|
|
//byte btHour2; pos 0x03
|
|
//byte btMin2; pos 0x04
|
|
GETCONDDATA(019);
|
|
SYSTEMTIME sTIME;
|
|
GetLocalTime(&sTIME);
|
|
if(data->btWeekDay != 0)
|
|
{
|
|
if(sTIME.wDayOfWeek != data->btWeekDay)
|
|
return QUEST_FAILURE;
|
|
}
|
|
word wMin = ((sTIME.wHour * 60) + sTIME.wMinute);
|
|
word wFrom = (data->btHour1 * 60) + data->btMin1;
|
|
word wTo = (data->btHour2 * 60) + data->btMin2;
|
|
if(wMin >= wFrom && wMin <= wTo)
|
|
return QUEST_SUCCESS;
|
|
return QUEST_FAILURE;
|
|
}
|
|
|
|
//Team number between iNo1 and iNo2
|
|
QUESTCOND(020)
|
|
{
|
|
//int iNo1 pos 0x00
|
|
//int iNo2 pos 0x02
|
|
GETCONDDATA(020);
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Distance check
|
|
QUESTCOND(021)
|
|
{
|
|
// byte btSelObjType pos 0x00
|
|
// byte iRadius pos 0x04
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Check Server/Channel
|
|
QUESTCOND(022)
|
|
{
|
|
//word nX pos 0x00
|
|
//word nY pos 0x02
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//In Clan?
|
|
QUESTCOND(023)
|
|
{
|
|
//byte btReg pos 0x00
|
|
GETCONDDATA(023);
|
|
int Clanid = client->Clan->clanid;
|
|
if(data->btReg == 0)
|
|
{
|
|
if(Clanid == 0)return QUEST_SUCCESS;
|
|
else return QUEST_FAILURE;
|
|
}
|
|
else
|
|
{
|
|
if(Clanid != 0)return QUEST_SUCCESS;
|
|
else return QUEST_FAILURE;
|
|
}
|
|
//btReg should only ever be 1 or 0 but just in case......
|
|
//return QUEST_FAILURE;
|
|
}
|
|
|
|
//Clan Position
|
|
QUESTCOND(024)
|
|
{
|
|
//check my current rank in the clan against data->nPOS using btOP
|
|
GETCONDDATA(024);
|
|
//word nPOS; pos 0x00
|
|
//byte btOP; pos 0x02
|
|
int myRank = client->Clan->clanrank;
|
|
switch(data->btOP)
|
|
{
|
|
case 0:
|
|
if(myRank == data->nPOS)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 1:
|
|
if(myRank > data->nPOS)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 2:
|
|
if(myRank >= data->nPOS)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 3:
|
|
if(myRank < data->nPOS)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 4:
|
|
if(myRank <= data->nPOS)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 10:
|
|
if(myRank != data->nPOS)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
default:
|
|
return QUEST_FAILURE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Clan Contribution
|
|
QUESTCOND(025)
|
|
{
|
|
//word nCONT pos 0x00
|
|
//byte btOP pos 0x02
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Clan Grade
|
|
QUESTCOND(026)
|
|
{
|
|
//possibly compare client's current clan grade with data->nGRD using data->btOp?
|
|
GETCONDDATA(026);
|
|
//word nGRD;
|
|
//byte btOP;
|
|
int myGrade = client->Clan->grade;
|
|
switch(data->btOP)
|
|
{
|
|
case 0:
|
|
if(myGrade == data->nGRD)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 1:
|
|
if(myGrade > data->nGRD)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 2:
|
|
if(myGrade >= data->nGRD)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 3:
|
|
if(myGrade < data->nGRD)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 4:
|
|
if(myGrade <= data->nGRD)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
case 10:
|
|
if(myGrade != data->nGRD)
|
|
return QUEST_SUCCESS;
|
|
break;
|
|
default:
|
|
return QUEST_FAILURE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Clan Points
|
|
QUESTCOND(027)
|
|
{
|
|
//word nPOINT pos 0x00
|
|
//byte btOP pos 0x02
|
|
GETCONDDATA(027);
|
|
if( client->questdebug )
|
|
server->SendPM(client, "QUEST - Clan Points");
|
|
switch(data->btOP)
|
|
{
|
|
case 0x01:
|
|
BEGINPACKET( pak, 0x7e0 );
|
|
ADDBYTE ( pak, 0x5C ); //action to update clan points (charserver)
|
|
ADDWORD ( pak, client->Clan->clanid);
|
|
ADDWORD ( pak, client->clientid );
|
|
ADDDWORD ( pak, client->Clan->CP );
|
|
ADDWORD ( pak, 0x00);
|
|
GServer->SendISCPacket( &pak );
|
|
break;
|
|
//default:
|
|
//break;
|
|
}
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Clan Funds
|
|
QUESTCOND(028)
|
|
{
|
|
//word iMONEY; pos 0x00
|
|
//byte btOP; pos 0x02
|
|
GETCONDDATA(027);
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Clan Members
|
|
QUESTCOND(029)
|
|
{
|
|
//word nMemberCNT; pos 0x00
|
|
//byte btOP; pos 0x02
|
|
return QUEST_SUCCESS;
|
|
}
|
|
|
|
//Clan Skills
|
|
QUESTCOND(030)
|
|
{
|
|
//word nSkill1; pos 0x00
|
|
//word nSkill2; pos 0x02
|
|
//byte btOP; pos 0x05
|
|
GETCONDDATA(030);
|
|
//not sure what to do here. Looks like we compare something with two skill ids
|
|
if( client->questdebug )server->SendPM(client, "Clan skills. Skill1: %i Skill2 %i btOP: %i",data->nSkill1,data->nSkill2,data->btOP);
|
|
return QUEST_SUCCESS;
|
|
}
|