swg-source-1.2/src-1.2
1
0
Fork 0
mirror of https://bitbucket.org/theswgsource/src-1.2.git synced 2026-07-15 00:08:07 -04:00
Code Issues Projects Releases Wiki Activity
Files
73d718ba9e7d7ff8409b487fe25831dc63cfc64b
src-1.2/engine/server/library/serverScript/src/shared/ScriptMethodsQuest.cpp
T

732 lines
31 KiB
C++
Executable File
Raw Blame History

// ======================================================================
//
// ScriptMethodsQuest.cpp
// copyright (c) 2004 Sony Online Entertainment
//
// ======================================================================
#include "serverScript/FirstServerScript.h"
#include "serverScript/JavaLibrary.h"
#include "serverGame/Chat.h"
#include "serverGame/CreatureObject.h"
#include "serverGame/PlayerCreatureController.h"
#include "serverGame/PlayerObject.h"
#include "serverGame/StaticLootItemManager.h"
#include "sharedGame/Quest.h"
#include "sharedGame/QuestManager.h"
#include "sharedGame/QuestTask.h"
#include "sharedGame/SharedStringIds.h"
#include "sharedNetworkMessages/MessageQueueGenericValueType.h"
#include "sharedNetworkMessages/MessageQueueQuestTaskCounterMessage.h"
#include "sharedNetworkMessages/MessageQueueQuestTaskLocationMessage.h"
#include "sharedNetworkMessages/MessageQueueQuestTaskTimerMessage.h"
#include "sharedObject/Controller.h"
#include "sharedNetworkMessages/MessageQueueCyberneticsOpen.h"
#include "UnicodeUtils.h"
using namespace JNIWrappersNamespace;
// ======================================================================
namespace ScriptMethodsQuestNamespace
{
PlayerObject * getPlayerForCharacter(jlong playerCreatureId)
{
CreatureObject * playerCreature = nullptr;
if (JavaLibrary::getObject(playerCreatureId, playerCreature))
{
return PlayerCreatureController::getPlayerObject(playerCreature);
}
else
{
NetworkId id(playerCreatureId);
JAVA_THROW_SCRIPT_EXCEPTION(true, ("Requested player %s, who could not be found.", id.getValueString().c_str()));
return nullptr;
}
}
bool install();
jint JNICALL questGetQuestId(JNIEnv *env, jobject self, jstring questName);
jstring JNICALL questGetQuestName(JNIEnv *env, jobject self, jint questId);
jboolean JNICALL questIsQuestComplete(JNIEnv *env, jobject self, jint questId, jlong playerId);
jint JNICALL questCanActivateQuest(JNIEnv *env, jobject self, jint questId, jlong playerId);
jboolean JNICALL questIsQuestActive(JNIEnv *env, jobject self, jint questId, jlong playerId);
jint JNICALL questActivateQuest(JNIEnv *env, jobject self, jint questId, jlong playerId, jlong questGiver);
jint JNICALL questCompleteQuest(JNIEnv *env, jobject self, jint questId, jlong playerId);
void JNICALL questClearQuest(JNIEnv *env, jobject self, jint questId, jlong playerId);
jboolean JNICALL questIsTaskComplete(JNIEnv *env, jobject self, jint questId, jint taskId, jlong playerId);
jint JNICALL questCanActivateTask(JNIEnv *env, jobject self, jint questId, jint taskId, jlong playerId);
jboolean JNICALL questIsTaskActive(JNIEnv *env, jobject self, jint questId, jint taskId, jlong playerId);
jint JNICALL questActivateTask(JNIEnv *env, jobject self, jint questId, jint taskId, jlong playerId);
jint JNICALL questCompleteTask(JNIEnv *env, jobject self, jint questId, jint taskId, jlong playerId);
jint JNICALL questFailTask(JNIEnv *env, jobject self, jint questId, jint taskId, jlong playerId);
void JNICALL questClearQuestTask(JNIEnv *env, jobject self, jint questId, jint taskId, jlong playerId);
void JNICALL questSetDebugging(JNIEnv *env, jobject self, jboolean debugging);
jboolean JNICALL questGetDebugging(JNIEnv *env, jobject self);
void JNICALL questSetQuestTaskCounter(JNIEnv *env, jobject self, jlong playerId, jstring questName, jint taskId, jstring sourceName, jint counter, jint counterMax);
void JNICALL questSetQuestTaskLocation(JNIEnv *env, jobject self, jlong playerId, jstring questName, jint taskId, jobject taskLocation);
void JNICALL questSetQuestTaskTimer(JNIEnv *env, jobject self, jlong playerId, jstring questName, jint taskId, jstring sourceName, jint timerLength);
jintArray JNICALL questGetAllActiveQuestIds(JNIEnv *env, jobject self, jlong object);
jintArray JNICALL questGetAllCompletedQuestIds(JNIEnv *env, jobject self, jlong object);
bool JNICALL questIsQuestAbandonable(JNIEnv * env, jobject self, jint questCrc);
bool JNICALL questIsQuestForceAccept(JNIEnv * env, jobject self, jint questCrc);
bool JNICALL questDoesUseAcceptanceUI(JNIEnv * env, jobject self, jint questCrc);
void JNICALL requestActivateQuest(JNIEnv * env, jobject self, jint questCrc, jlong playerId, jlong questGiver);
void JNICALL requestCompleteQuest(JNIEnv * env, jobject self, jint questCrc, jlong playerId);
void JNICALL showCyberneticsPage(JNIEnv *env, jobject self, jlong playerId, jlong npcId, jint openType);
void JNICALL sendStaticItemDataToPlayer(JNIEnv *env, jobject self, jlong player, jobjectArray keys, jobjectArray values);
void JNICALL showLootBox(JNIEnv *env, jobject self, jlong player, jlongArray newObjects);
}
using namespace ScriptMethodsQuestNamespace;
//========================================================================
// install
//========================================================================
bool ScriptMethodsQuestNamespace::install()
{
const JNINativeMethod NATIVES[] = {
#define JF(a,b,c) {a,b,(void*)(ScriptMethodsQuestNamespace::c)}
JF("questGetQuestId","(Ljava/lang/String;)I",questGetQuestId),
JF("questGetQuestName", "(I)Ljava/lang/String;",questGetQuestName),
JF("_questIsQuestComplete","(IJ)Z",questIsQuestComplete),
JF("_questCanActivateQuest","(IJ)I",questCanActivateQuest),
JF("_questIsQuestActive","(IJ)Z",questIsQuestActive),
JF("_questActivateQuest","(IJJ)I",questActivateQuest),
JF("_questCompleteQuest","(IJ)I",questCompleteQuest),
JF("_questClearQuest","(IJ)V",questClearQuest),
JF("_questIsTaskComplete","(IIJ)Z",questIsTaskComplete),
JF("_questCanActivateTask","(IIJ)I",questCanActivateTask),
JF("_questIsTaskActive","(IIJ)Z",questIsTaskActive),
JF("_questActivateTask","(IIJ)I",questActivateTask),
JF("_questCompleteTask","(IIJ)I",questCompleteTask),
JF("_questFailTask", "(IIJ)I", questFailTask),
JF("_questClearQuestTask","(IIJ)V",questClearQuestTask),
JF("questSetDebugging", "(Z)V", questSetDebugging),
JF("questGetDebugging", "()Z", questGetDebugging),
JF("_questSetQuestTaskCounter", "(JLjava/lang/String;ILjava/lang/String;II)V", questSetQuestTaskCounter),
JF("_questSetQuestTaskLocation", "(JLjava/lang/String;ILscript/location;)V", questSetQuestTaskLocation),
JF("_questSetQuestTaskTimer", "(JLjava/lang/String;ILjava/lang/String;I)V", questSetQuestTaskTimer),
JF("_questGetAllActiveQuestIds", "(J)[I", questGetAllActiveQuestIds),
JF("_questGetAllCompletedQuestIds", "(J)[I", questGetAllCompletedQuestIds),
JF("_questIsQuestAbandonable", "(I)Z", questIsQuestAbandonable),
JF("_questIsQuestForceAccept", "(I)Z", questIsQuestForceAccept),
JF("_questDoesUseAcceptanceUI", "(I)Z", questDoesUseAcceptanceUI),
JF("_requestActivateQuest", "(IJJ)V", requestActivateQuest),
JF("_requestCompleteQuest", "(IJ)V", requestCompleteQuest),
JF("_showCyberneticsPage", "(JJI)V", showCyberneticsPage),
JF("_sendStaticItemDataToPlayer", "(J[Ljava/lang/String;[Ljava/lang/String;)V", sendStaticItemDataToPlayer),
JF("_showLootBox", "(J[J)V", showLootBox),
};
return JavaLibrary::registerNatives(NATIVES, sizeof(NATIVES)/sizeof(NATIVES[0]));
}
// ======================================================================
// Quest functions
jint JNICALL ScriptMethodsQuestNamespace::questGetQuestId(JNIEnv *, jobject, jstring questName)
{
JavaStringParam jquestName(questName);
std::string questNameString;
if (!JavaLibrary::convert(jquestName, questNameString))
return 0;
Quest const * const quest = QuestManager::getQuest(questNameString);
return quest ? static_cast<int>(quest->getId()) : 0;
}
// ---------------------------------------------------------------------
jstring JNICALL ScriptMethodsQuestNamespace::questGetQuestName(JNIEnv *, jobject, jint questId)
{
std::string const questName = QuestManager::getQuestName(static_cast<uint32>(questId));
return JavaString(questName).getReturnValue();
}
// ---------------------------------------------------------------------
jboolean JNICALL ScriptMethodsQuestNamespace::questIsQuestComplete(JNIEnv *, jobject, jint questId, jlong playerId)
{
PlayerObject const * const playerObject = getPlayerForCharacter(playerId);
if (playerObject)
return playerObject->questHasCompletedQuest(static_cast<uint32>(questId));
else
return JNI_FALSE;
}
// ---------------------------------------------------------------------
jint JNICALL ScriptMethodsQuestNamespace::questCanActivateQuest(JNIEnv *, jobject, jint questId, jlong playerId)
{
PlayerObject const * const playerObject = getPlayerForCharacter(playerId);
if (playerObject)
{
PlayerObject::QuestResult result = playerObject->questCanActivateQuest(static_cast<uint32>(questId));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questId));
return static_cast<int>(result);
}
else
return static_cast<int>(PlayerObject::QR_noSuchPlayer);
}
// ---------------------------------------------------------------------
jboolean JNICALL ScriptMethodsQuestNamespace::questIsQuestActive(JNIEnv *, jobject, jint questId, jlong playerId)
{
PlayerObject const * const playerObject = getPlayerForCharacter(playerId);
if (playerObject)
return playerObject->questHasActiveQuest(static_cast<uint32>(questId));
else
return false;
}
// ---------------------------------------------------------------------
jint JNICALL ScriptMethodsQuestNamespace::questActivateQuest(JNIEnv *, jobject, jint questId, jlong playerId, jlong questGiver)
{
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
if (!playerObject)
return static_cast<jint>(PlayerObject::QR_noSuchPlayer);
//send down the loot info
Quest const * const q = QuestManager::getQuest(questId);
if(q)
{
std::vector<std::string> const & inclusiveStaticLootItems = q->getInclusiveStaticLootItemNames();
for(std::vector<std::string>::const_iterator it = inclusiveStaticLootItems.begin(); it != inclusiveStaticLootItems.end(); ++it)
{
StaticLootItemManager::sendDataToClient(NetworkId(playerId), *it);
}
std::vector<std::string> const & exclusiveStaticLootItems = q->getExclusiveStaticLootItemNames();
for(std::vector<std::string>::const_iterator it2 = exclusiveStaticLootItems.begin(); it2 != exclusiveStaticLootItems.end(); ++it2)
{
StaticLootItemManager::sendDataToClient(NetworkId(playerId), *it2);
}
}
PlayerObject::QuestResult result = playerObject->questActivateQuest(static_cast<uint32>(questId), NetworkId(questGiver));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questId));
return static_cast<int>(result);
}
// ---------------------------------------------------------------------
jint JNICALL ScriptMethodsQuestNamespace::questCompleteQuest(JNIEnv *, jobject, jint questId, jlong playerId)
{
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
if (!playerObject)
return static_cast<int>(PlayerObject::QR_noSuchPlayer);
PlayerObject::QuestResult result = playerObject->questCompleteQuest(static_cast<uint32>(questId));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questId));
return static_cast<int>(result);
}
// ----------------------------------------------------------------------
void JNICALL ScriptMethodsQuestNamespace::questClearQuest(JNIEnv *, jobject, jint questId, jlong playerId)
{
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
if (playerObject)
playerObject->questClearQuest(static_cast<uint32>(questId));
}
// ======================================================================
// Task Functions
jboolean JNICALL ScriptMethodsQuestNamespace::questIsTaskComplete(JNIEnv *, jobject, jint questId, jint taskId, jlong playerId)
{
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return JNI_FALSE;
}
PlayerObject const * const playerObject = getPlayerForCharacter(playerId);
if (playerObject)
return playerObject->questHasCompletedQuestTask(static_cast<uint32>(questId), taskId);
else
return JNI_FALSE;
}
// ---------------------------------------------------------------------
jint JNICALL ScriptMethodsQuestNamespace::questCanActivateTask(JNIEnv *, jobject, jint questId, jint taskId, jlong playerId)
{
PlayerObject const * const playerObject = getPlayerForCharacter(playerId);
if (playerObject)
{
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return PlayerObject::QR_noSuchTask;
}
PlayerObject::QuestResult result = playerObject->questCanActivateQuestTask(static_cast<uint32>(questId), taskId);
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questId));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchTask,("Requested quest %i task %i, which could not be found.", questId, taskId));
return static_cast<int>(result);
}
else
return static_cast<int>(PlayerObject::QR_noSuchPlayer);
}
// ---------------------------------------------------------------------
jboolean JNICALL ScriptMethodsQuestNamespace::questIsTaskActive(JNIEnv *, jobject, jint questId, jint taskId, jlong playerId)
{
PlayerObject const * const playerObject = getPlayerForCharacter(playerId);
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return JNI_FALSE;
}
if (playerObject)
return playerObject->questHasActiveQuestTask(static_cast<uint32>(questId), taskId);
else
return JNI_FALSE;
}
// ---------------------------------------------------------------------
jint JNICALL ScriptMethodsQuestNamespace::questActivateTask(JNIEnv *, jobject, jint questId, jint taskId, jlong playerId)
{
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
if (!playerObject)
return static_cast<int>(PlayerObject::QR_noSuchPlayer);
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return PlayerObject::QR_noSuchTask;
}
PlayerObject::QuestResult result = playerObject->questActivateQuestTask(static_cast<uint32>(questId), taskId);
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questId));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchTask,("Requested quest %i task %i, which could not be found.", questId, taskId));
return static_cast<int>(result);
}
// ---------------------------------------------------------------------
jint JNICALL ScriptMethodsQuestNamespace::questCompleteTask(JNIEnv *, jobject, jint questId, jint taskId, jlong playerId)
{
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
if (!playerObject)
return static_cast<int>(PlayerObject::QR_noSuchPlayer);
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return PlayerObject::QR_noSuchTask;
}
PlayerObject::QuestResult result = playerObject->questCompleteQuestTask(static_cast<uint32>(questId), taskId);
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questId));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchTask,("Requested quest %i task %i, which could not be found.", questId, taskId));
return static_cast<int>(result);
}
// ---------------------------------------------------------------------
jint JNICALL ScriptMethodsQuestNamespace::questFailTask(JNIEnv *, jobject, jint questId, jint taskId, jlong playerId)
{
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
if (!playerObject)
return static_cast<int>(PlayerObject::QR_noSuchPlayer);
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return PlayerObject::QR_noSuchTask;
}
PlayerObject::QuestResult result = playerObject->questFailQuestTask(static_cast<uint32>(questId), taskId);
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questId));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchTask,("Requested quest %i task %i, which could not be found.", questId, taskId));
return static_cast<int>(result);
}
// ----------------------------------------------------------------------
void JNICALL ScriptMethodsQuestNamespace::questClearQuestTask(JNIEnv *, jobject, jint questId, jint taskId, jlong playerId)
{
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return;
}
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
if (playerObject)
IGNORE_RETURN(playerObject->questClearQuestTask(static_cast<uint32>(questId), taskId));
}
// ----------------------------------------------------------------------
void JNICALL ScriptMethodsQuestNamespace::questSetDebugging(JNIEnv *env, jobject self, jboolean debugging)
{
QuestManager::setDebugging(debugging);
}
// ----------------------------------------------------------------------
jboolean JNICALL ScriptMethodsQuestNamespace::questGetDebugging(JNIEnv *env, jobject self)
{
return QuestManager::getDebugging();
}
// ----------------------------------------------------------------------
void JNICALL ScriptMethodsQuestNamespace::questSetQuestTaskCounter(JNIEnv *env, jobject self, jlong playerId, jstring questName, jint taskId, jstring sourceName, jint counter, jint counterMax)
{
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return;
}
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
CreatureObject * const creatureObject = playerObject ? playerObject->getCreatureObject() : nullptr;
Controller * const controller = creatureObject ? creatureObject->getController() : nullptr;
if(!controller)
return;
JavaStringParam jquestNameName(questName);
std::string questNameString;
if (!JavaLibrary::convert(jquestNameName, questNameString))
return;
JavaStringParam jsourceNameName(sourceName);
std::string sourceNameString;
if (!JavaLibrary::convert(jsourceNameName, sourceNameString))
return;
MessageQueueQuestTaskCounterMessage * const msg = new MessageQueueQuestTaskCounterMessage(questNameString, taskId, Unicode::narrowToWide(sourceNameString), counter, counterMax);
controller->appendMessage(static_cast<int>(CM_questTaskCounterData), 0.0f, msg, GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_CLIENT);
}
// ----------------------------------------------------------------------
void JNICALL ScriptMethodsQuestNamespace::questSetQuestTaskLocation(JNIEnv *env, jobject self, jlong playerId, jstring questName, jint taskId, jobject taskLocation)
{
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return;
}
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
CreatureObject * const creatureObject = playerObject ? playerObject->getCreatureObject() : nullptr;
Controller * const controller = creatureObject ? creatureObject->getController() : nullptr;
if(!controller)
return;
JavaStringParam jquestNameName(questName);
std::string questNameString;
if (!JavaLibrary::convert(jquestNameName, questNameString))
return;
Location location;
if(!ScriptConversion::convert(LocalRefParam(taskLocation), location))
return;
MessageQueueQuestTaskLocationMessage * const msg = new MessageQueueQuestTaskLocationMessage(questNameString, taskId, location);
controller->appendMessage(static_cast<int>(CM_questTaskLocationData), 0.0f, msg, GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_CLIENT);
}
// ----------------------------------------------------------------------
void JNICALL ScriptMethodsQuestNamespace::questSetQuestTaskTimer(JNIEnv *env, jobject self, jlong playerId, jstring questName, jint taskId, jstring sourceName, jint finalPlayedTime)
{
if(!QuestManager::isValidTaskId(taskId))
{
JAVA_THROW_SCRIPT_EXCEPTION(true, ("TaskId %i, outside legal range.", taskId));
return;
}
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
CreatureObject * const creatureObject = playerObject ? playerObject->getCreatureObject() : nullptr;
Controller * const controller = creatureObject ? creatureObject->getController() : nullptr;
if(!controller)
return;
JavaStringParam jquestNameName(questName);
std::string questNameString;
if (!JavaLibrary::convert(jquestNameName, questNameString))
return;
JavaStringParam jsourceNameName(sourceName);
std::string sourceNameString;
if (!JavaLibrary::convert(jsourceNameName, sourceNameString))
return;
MessageQueueQuestTaskTimerMessage * const msg = new MessageQueueQuestTaskTimerMessage(questNameString, taskId, Unicode::narrowToWide(sourceNameString), finalPlayedTime);
controller->appendMessage(static_cast<int>(CM_questTaskTimerData), 0.0f, msg, GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_CLIENT);
}
// ----------------------------------------------------------------------
void JNICALL ScriptMethodsQuestNamespace::requestActivateQuest(JNIEnv * env, jobject self, jint questCrc, jlong playerId, jlong questGiver)
{
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
if (playerObject)
{
if(playerObject->questHasActiveQuest(static_cast<uint32>(questCrc)))
{
return;
}
CreatureObject * playerCreature = nullptr;
if (JavaLibrary::getObject(playerId, playerCreature) && playerCreature)
{
Quest const * const q = QuestManager::getQuest(questCrc);
if(q)
{
std::vector<std::string> const & inclusiveStaticLootItems = q->getInclusiveStaticLootItemNames();
for(std::vector<std::string>::const_iterator it = inclusiveStaticLootItems.begin(); it != inclusiveStaticLootItems.end(); ++it)
{
StaticLootItemManager::sendDataToClient(NetworkId(playerId), *it);
}
std::vector<std::string> const & exclusiveStaticLootItems = q->getExclusiveStaticLootItemNames();
for(std::vector<std::string>::const_iterator it2 = exclusiveStaticLootItems.begin(); it2 != exclusiveStaticLootItems.end(); ++it2)
{
StaticLootItemManager::sendDataToClient(NetworkId(playerId), *it2);
}
if(QuestManager::isQuestForceAccepted(q->getName().getString()))
{
PlayerObject::QuestResult result = playerObject->questActivateQuest(static_cast<uint32>(questCrc), NetworkId(questGiver));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questCrc));
MessageQueueGenericValueType<int> * const msg = new MessageQueueGenericValueType<int>(static_cast<int>(questCrc));
Controller * const controller = playerCreature->getController();
if(controller)
{
controller->appendMessage(static_cast<int>(CM_forceActivateQuest), 0.0f, msg, GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_CLIENT);
}
}
//see if this quest needs to go through our acceptance/completion UI flow
else if(QuestManager::isQuestAcceptable(q->getName().getString()))
{
Controller * const controller = playerCreature->getController();
if(controller)
{
if(QuestManager::getMaximumNumberOfQuestsPerPlayer() > -1)
{
if(playerObject->getNumberOfActiveQuests() >= QuestManager::getMaximumNumberOfQuestsPerPlayer())
{
Chat::sendSystemMessage(*playerCreature, SharedStringIds::quest_journal_is_full, Unicode::emptyString);
return;
}
}
playerObject->setPendingRequestQuestInformation(questCrc, NetworkId(questGiver));
MessageQueueGenericValueType<int> * const msg = new MessageQueueGenericValueType<int>(static_cast<int>(questCrc));
controller->appendMessage(static_cast<int>(CM_requestActivateQuest), 0.0f, msg, GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_CLIENT);
}
}
else
{
PlayerObject::QuestResult result = playerObject->questActivateQuest(static_cast<uint32>(questCrc), NetworkId(questGiver));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questCrc));
}
}
}
}
}
// ----------------------------------------------------------------------
void JNICALL ScriptMethodsQuestNamespace::requestCompleteQuest(JNIEnv * env, jobject self, jint questCrc, jlong playerId)
{
PlayerObject * const playerObject = getPlayerForCharacter(playerId);
if (playerObject)
{
if(!playerObject->questHasActiveQuest(static_cast<uint32>(questCrc)))
{
return;
}
CreatureObject * playerCreature = nullptr;
if (JavaLibrary::getObject(playerId, playerCreature) && playerCreature)
{
Quest const * const q = QuestManager::getQuest(questCrc);
if(q)
{
PlayerObject::QuestResult result = playerObject->questCompleteQuest(static_cast<uint32>(questCrc));
JAVA_THROW_SCRIPT_EXCEPTION(result==PlayerObject::QR_noSuchQuest,("Requested quest %i, which could not be found.", questCrc));
}
}
}
}
// ----------------------------------------------------------------------
void JNICALL ScriptMethodsQuestNamespace::showCyberneticsPage(JNIEnv *env, jobject self, jlong playerId, jlong npcId, jint openType)
{
MessageQueueCyberneticsOpen::OpenType const type = static_cast<MessageQueueCyberneticsOpen::OpenType>(openType);
CreatureObject * npc = nullptr;
if (!JavaLibrary::getObject(npcId, npc))
return;
if(!npc)
return;
CreatureObject * playerCreature = nullptr;
if (JavaLibrary::getObject(playerId, playerCreature))
{
Controller * const playerController = playerCreature->getController();
if(playerController)
{
MessageQueueCyberneticsOpen * msg = new MessageQueueCyberneticsOpen(type, npc->getNetworkId());
playerController->appendMessage(CM_cyberneticsOpen, 0.0f, msg, GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_CLIENT);
}
}
}
// ----------------------------------------------------------------------
jintArray JNICALL ScriptMethodsQuestNamespace::questGetAllActiveQuestIds(JNIEnv *env, jobject self, jlong playerId)
{
PlayerObject const * const playerObject = getPlayerForCharacter(playerId);
if (!playerObject)
{
LocalIntArrayRefPtr results = createNewIntArray(0);
return results->getReturnValue();
}
std::vector<int> questIds = playerObject->questGetAllActiveQuestIds();
LocalIntArrayRefPtr results = createNewIntArray(static_cast<int>(questIds.size()));
setIntArrayRegion(*results, 0 , static_cast<int>(questIds.size()), reinterpret_cast<jint*>(&(questIds[0])));
return results->getReturnValue();
}
// ----------------------------------------------------------------------
jintArray JNICALL ScriptMethodsQuestNamespace::questGetAllCompletedQuestIds(JNIEnv *env, jobject self, jlong playerId)
{
PlayerObject const * const playerObject = getPlayerForCharacter(playerId);
if (!playerObject)
{
LocalIntArrayRefPtr results = createNewIntArray(0);
return results->getReturnValue();
}
std::vector<int> questIds = playerObject->questGetAllCompletedQuestIds();
LocalIntArrayRefPtr results = createNewIntArray(static_cast<int>(questIds.size()));
setIntArrayRegion(*results, 0 , static_cast<int>(questIds.size()), reinterpret_cast<jint*>(&(questIds[0])));
return results->getReturnValue();
}
// ----------------------------------------------------------------------
/**
* Given a dictionary representing the static item data for loot item, pack it all into a single vector and send to the client.
*/
void JNICALL ScriptMethodsQuestNamespace::sendStaticItemDataToPlayer(JNIEnv *env, jobject self, jlong playerId, jobjectArray keys, jobjectArray values)
{
//turn the java objects into parallel vectors
std::vector<const Unicode::String *> keyStrings;
getStringArray(LocalObjectArrayRefParam(keys), keyStrings);
std::vector<const Unicode::String *> valueStrings;
getStringArray(LocalObjectArrayRefParam(values), valueStrings);
//build a single dictionary to hold ALL the data. ALL keys, then ALL data. gcc can't handle it as a pair of vector,
// it caused an deep in archive where it blows out the template instanctiation depth
std::vector<Unicode::String> flattenedDictionary;
flattenedDictionary.reserve(keyStrings.size() * 2);
//put everything in it
Unicode::String s;
for(std::vector<const Unicode::String *>::const_iterator i = keyStrings.begin(); i != keyStrings.end(); ++i)
{
s = **i;
flattenedDictionary.push_back(s);
}
for(std::vector<const Unicode::String *>::const_iterator i2 = valueStrings.begin(); i2 != valueStrings.end(); ++i2)
{
s = **i2;
flattenedDictionary.push_back(s);
}
//send to player
CreatureObject * playerCreature = nullptr;
if (JavaLibrary::getObject(playerId, playerCreature))
{
Controller * const playerController = playerCreature->getController();
if(playerController)
{
MessageQueueGenericValueType<std::vector<Unicode::String> > * const msg = new MessageQueueGenericValueType<std::vector<Unicode::String> >(flattenedDictionary);
playerController->appendMessage(static_cast<int>(CM_staticLootItemData), 0.0f, msg, GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_CLIENT);
}
}
}
// ----------------------------------------------------------------------
/**
* Given a player and a list of networkids, tell the client to show a UI listing these objects as newly earned
*/
void JNICALL ScriptMethodsQuestNamespace::showLootBox(JNIEnv *env, jobject self, jlong playerId, jlongArray newObjects)
{
std::vector<NetworkId> objectIds;
if (!ScriptConversion::convert(newObjects, objectIds))
return;
//send to player
CreatureObject * playerCreature = nullptr;
if (JavaLibrary::getObject(playerId, playerCreature))
{
Controller * const playerController = playerCreature->getController();
if(playerController)
{
MessageQueueGenericValueType<std::vector<NetworkId> > * const msg = new MessageQueueGenericValueType<std::vector<NetworkId> >(objectIds);
playerController->appendMessage(static_cast<int>(CM_showLootBox), 0.0f, msg, GameControllerMessageFlags::SEND | GameControllerMessageFlags::RELIABLE | GameControllerMessageFlags::DEST_AUTH_CLIENT);
}
}
}
// ----------------------------------------------------------------------
bool JNICALL ScriptMethodsQuestNamespace::questIsQuestAbandonable(JNIEnv * , jobject , jint questCrc)
{
Quest const * const q = QuestManager::getQuest(questCrc);
if(!q)
return JNI_FALSE;
return(QuestManager::isQuestAbandonable(q->getName().getString())) ? JNI_TRUE : JNI_FALSE;
}
// ----------------------------------------------------------------------
bool JNICALL ScriptMethodsQuestNamespace::questIsQuestForceAccept(JNIEnv * , jobject , jint questCrc)
{
Quest const * const q = QuestManager::getQuest(questCrc);
if(!q)
return JNI_FALSE;
return(QuestManager::isQuestForceAccepted(q->getName().getString())) ? JNI_TRUE : JNI_FALSE;
}
// ----------------------------------------------------------------------
bool JNICALL ScriptMethodsQuestNamespace::questDoesUseAcceptanceUI(JNIEnv * , jobject , jint questCrc)
{
Quest const * const q = QuestManager::getQuest(questCrc);
if(!q)
return JNI_FALSE;
return(QuestManager::isQuestAcceptable(q->getName().getString())) ? JNI_TRUE : JNI_FALSE;
}
// ======================================================================
Reference in New Issue View Git Blame Copy Permalink