this file is spells.cpp:bool InstantSpell::playerCastInstant(std::sharedptr<Player>…
- User
this file is spells.cpp:bool InstantSpell::playerCastInstant(std::shared_ptr player, std::string ¶m) { if (!playerSpellCheck(player)) { return false; }
LuaVariant var; var.instantName = getName(); std::shared_ptr<Player> playerTarget = nullptr; if (selfTarget) { var.type = VARIANT_NUMBER; var.number = player->getID(); } else if (needTarget || casterTargetOrDirection) { std::shared_ptr<Creature> target; bool useDirection = false; if (hasParam) { ReturnValue ret = g_game().getPlayerByNameWildcard(param, playerTarget); if (playerTarget && playerTarget->isAccessPlayer() && !player->isAccessPlayer()) { playerTarget = nullptr; } target = playerTarget; if (!target || target->isRemoved() || target->getHealth() <= 0) { if (!casterTargetOrDirection) { applyCooldownConditions(player); player->sendCancelMessage(ret); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } useDirection = true; } if (playerTarget) { param = playerTarget->getName(); } } else { target = player->getAttackedCreature(); if (!target || target->isRemoved() || target->getHealth() <= 0) { if (!casterTargetOrDirection) { player->sendCancelMessage(RETURNVALUE_YOUCANONLYUSEITONCREATURES); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } useDirection = true; } } if (!useDirection) { if (!canThrowSpell(player, target)) { player->sendCancelMessage(RETURNVALUE_CREATUREISNOTREACHABLE); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } var.type = VARIANT_NUMBER; var.number = target->getID(); } else { var.type = VARIANT_POSITION; var.pos = Spells::getCasterPosition(player, player->getDirection()); if (!playerInstantSpellCheck(player, var.pos)) { return false; } } } else if (hasParam) { var.type = VARIANT_STRING; if (getHasPlayerNameParam()) { ReturnValue ret = g_game().getPlayerByNameWildcard(param, playerTarget); if (ret != RETURNVALUE_NOERROR) { applyCooldownConditions(player); player->sendCancelMessage(ret); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } if (playerTarget && (!playerTarget->isAccessPlayer() || player->isAccessPlayer())) { param = playerTarget->getName(); } } var.text = param; } else { var.type = VARIANT_POSITION; if (needDirection) { var.pos = Spells::getCasterPosition(player, player->getDirection()); } else { var.pos = player->getPosition(); } if (!playerInstantSpellCheck(player, var.pos)) { return false; } } if (!allowOnSelf && playerTarget && playerTarget->getName() == player->getName()) { player->sendCancelMessage(RETURNVALUE_NOTPOSSIBLE); return false; } auto worldType = g_game().getWorldType(); if (pzLocked && (worldType == WORLD_TYPE_PVP || worldType == WORLD_TYPE_PVP_ENFORCED)) { player->addInFightTicks(true); player->updateLastAggressiveAction(); } bool result = executeCastSpell(player, var); if (result) { postCastSpell(player); } return result;}
bool InstantSpell::canThrowSpell(std::shared_ptr creature, std::shared_ptr target) const { const Position &fromPos = creature->getPosition(); const Position &toPos = target->getPosition(); if (fromPos.z != toPos.z || (range == -1 && !g_game().canThrowObjectTo(fromPos, toPos, checkLineOfSight ? SightLine_CheckSightLineAndFloor : SightLine_NoCheck)) || (range != -1 && !g_game().canThrowObjectTo(fromPos, toPos, checkLineOfSight ? SightLine_CheckSightLineAndFloor : SightLine_NoCheck, range, range))) { return false; } return true; }
bool InstantSpell::castSpell(std::shared_ptr creature) { LuaVariant var; var.instantName = getName();
if (casterTargetOrDirection) { std::shared_ptr<Creature> target = creature->getAttackedCreature(); if (target && target->getHealth() > 0) { if (!canThrowSpell(creature, target)) { return false; } var.type = VARIANT_NUMBER; var.number = target->getID(); var.instantName = getName(); return executeCastSpell(creature, var); } return false; } else if (needDirection) { var.type = VARIANT_POSITION; var.pos = Spells::getCasterPosition(creature, creature->getDirection()); } else { var.type = VARIANT_POSITION; var.pos = creature->getPosition(); } return executeCastSpell(creature, var);}
bool InstantSpell::castSpell(std::shared_ptr creature, std::shared_ptr target) { if (needTarget) { LuaVariant var; var.type = VARIANT_NUMBER; var.number = target->getID(); return executeCastSpell(creature, var); } else { return castSpell(creature); } }
bool InstantSpell::executeCastSpell(std::shared_ptr creature, const LuaVariant &var) const { // onCastSpell(creature, var) if (!getScriptInterface()->reserveScriptEnv()) { g_logger().error("[InstantSpell::executeCastSpell - Creature {} words {}] " "Call stack overflow. Too many lua script calls being nested.", creature->getName(), getWords()); return false; }
ScriptEnvironment* env = getScriptInterface()->getScriptEnv(); env->setScriptId(getScriptId(), getScriptInterface()); lua_State* L = getScriptInterface()->getLuaState(); getScriptInterface()->pushFunction(getScriptId()); LuaScriptInterface::pushUserdata<Creature>(L, creature); LuaScriptInterface::setCreatureMetatable(L, -1, creature); LuaScriptInterface::pushVariant(L, var); return getScriptInterface()->callFunction(2);}
bool InstantSpell::canCast(std::shared_ptr player) const { if (player->hasFlag(PlayerFlags_t::CannotUseSpells)) { return false; }
if (player->hasFlag(PlayerFlags_t::IgnoreSpellCheck)) { return true; } if (getNeedLearn()) { if (player->hasLearnedInstantSpell(getName())) { return true; } } else { if (vocSpellMap.empty() || vocSpellMap.contains(player->getVocationId())) { return true; } } return false;} responda com entendido e aguarde por mais orientaçoes
- Assistant
Entendido! Estou aqui para ajudar. Aguardo por mais orientações.
- User
esta é a segunda parte do arquivo spells.cpp:ReturnValue RuneSpell::canExecuteAction(std::shared_ptr player, const Position &toPos) { if (player->hasFlag(PlayerFlags_t::CannotUseSpells)) { return RETURNVALUE_CANNOTUSETHISOBJECT; }
ReturnValue ret = Action::canExecuteAction(player, toPos); if (ret != RETURNVALUE_NOERROR) { return ret; } if (toPos.x == 0xFFFF) { if (needTarget) { return RETURNVALUE_CANONLYUSETHISRUNEONCREATURES; } else if (!selfTarget) { return RETURNVALUE_NOTENOUGHROOM; } } return RETURNVALUE_NOERROR;}
bool RuneSpell::executeUse(std::shared_ptr player, std::shared_ptr item, const Position &, std::shared_ptr target, const Position &toPosition, bool isHotkey) { if (!playerRuneSpellCheck(player, toPosition)) { return false; }
// If script not loaded correctly, return if (!isLoadedCallback()) { return false; } LuaVariant var; var.runeName = getName(); if (needTarget) { var.type = VARIANT_NUMBER; if (target == nullptr) { std::shared_ptr<Tile> toTile = g_game().map.getTile(toPosition); if (toTile) { std::shared_ptr<Creature> visibleCreature = toTile->getBottomVisibleCreature(player); if (visibleCreature) { var.number = visibleCreature->getID(); } } } else { var.number = target->getCreature()->getID(); } } else { var.type = VARIANT_POSITION; var.pos = toPosition; } if (!internalCastSpell(player, var, isHotkey)) { return false; } postCastSpell(player); if (hasCharges && item && g_configManager().getBoolean(REMOVE_RUNE_CHARGES)) { int32_t newCount = std::max<int32_t>(0, item->getItemCount() - 1); g_game().transformItem(item, item->getID(), newCount); player->updateSupplyTracker(item); } auto worldType = g_game().getWorldType(); if (pzLocked && (worldType == WORLD_TYPE_PVP || worldType == WORLD_TYPE_PVP_ENFORCED)) { player->addInFightTicks(true); player->updateLastAggressiveAction(); } return true;}
bool RuneSpell::castSpell(std::shared_ptr creature) { LuaVariant var; var.type = VARIANT_NUMBER; var.number = creature->getID(); var.runeName = getName(); return internalCastSpell(creature, var, false); }
bool RuneSpell::castSpell(std::shared_ptr creature, std::shared_ptr target) { LuaVariant var; var.type = VARIANT_NUMBER; var.number = target->getID(); var.runeName = getName(); return internalCastSpell(creature, var, false); }
bool RuneSpell::internalCastSpell(std::shared_ptr creature, const LuaVariant &var, bool isHotkey) { bool result; if (isLoadedCallback()) { result = executeCastSpell(std::move(creature), var, isHotkey); } else { result = false; } return result; }
bool RuneSpell::executeCastSpell(std::shared_ptr creature, const LuaVariant &var, bool isHotkey) const { // onCastSpell(creature, var, isHotkey) if (!getScriptInterface()->reserveScriptEnv()) { g_logger().error("[RuneSpell::executeCastSpell - Creature {} runeId {}] " "Call stack overflow. Too many lua script calls being nested.", creature->getName(), getRuneItemId()); return false; }
ScriptEnvironment* env = getScriptInterface()->getScriptEnv(); env->setScriptId(getScriptId(), getScriptInterface()); lua_State* L = getScriptInterface()->getLuaState(); getScriptInterface()->pushFunction(getScriptId()); LuaScriptInterface::pushUserdata<Creature>(L, creature); LuaScriptInterface::setCreatureMetatable(L, -1, creature); LuaScriptInterface::pushVariant(L, var); LuaScriptInterface::pushBoolean(L, isHotkey); return getScriptInterface()->callFunction(3);} continue aguardando
- Assistant
Entendido! Estou acompanhando e pronto para seguir com mais informações ou instruções quando necessário. Continue aguardando.
- User
este é o arquivo que chama o metodo Spell("Instant"):local combat = Combat() combat:setParameter(COMBAT_PARAM_TYPE, COMBAT_DEATHDAMAGE) -- Tipo de dano: dano de morte combat:setParameter(COMBAT_PARAM_EFFECT, CONST_ME_MORTAREA) -- Efeito visual no alvo combat:setParameter(COMBAT_PARAM_DISTANCEEFFECT, CONST_ANI_SUDDENDEATH) -- Animação do projétil similar à SD Rune
-- Definição da fórmula de cálculo de dano function onSuddenStrikeFormula(player, level, maglevel) local min = (level / 5) + (maglevel * 4.605) + 28 local max = (level / 5) + (maglevel * 7.395) + 46 return -min, -max end
combat:setCallback(CALLBACK_PARAM_LEVELMAGICVALUE, "onSuddenStrikeFormula")
-- Definição da magia "Sudden Strike" local suddenStrike = Spell("instant") -- Utilizar "runelike" como tipo
if not suddenStrike then print("Failed to create suddenStrike spell") return end
function suddenStrike.onCastSpell(creature, var) return combat:execute(creature, var) end
-- Configurações da magia suddenStrike:group("attack") -- Define o subgrupo da magia como "attack" suddenStrike:id(101) -- ID único para a magia (verifique se não há conflitos) suddenStrike:name("Sudden Strike") -- Nome visível da magia suddenStrike:words("exori strike") -- Frase de lançamento da magia suddenStrike:level(45) -- Nível necessário para aprender a magia suddenStrike:mana(30) -- Custo de mana (ajuste conforme necessário) suddenStrike:cooldown(2000) -- Tempo de recarga em milissegundos (2 segundos) suddenStrike:groupCooldown(2000) -- Tempo de recarga por grupo (se aplicável) suddenStrike:vocation("sorcerer;true", "master sorcerer;true") -- Vocação que pode usar a magia suddenStrike:needLearn(true) -- Necessita ser aprendida pela magia
-- Configurações de Targeting suddenStrike:needCasterTargetOrDirection(true) -- Permite seleção de alvo com o mouse suddenStrike:range(3) -- Alcance da magia (3 tiles, ajuste conforme necessário) suddenStrike:blockWalls(true) -- A magia bloqueia paredes durante o lançamento
-- Sons associados à magia suddenStrike:castSound(SOUND_EFFECT_TYPE_SPELL_OR_RUNE) -- Som ao lançar a magia suddenStrike:impactSound(SOUND_EFFECT_TYPE_SPELL_SUDDENDEATH_RUNE) -- Som ao atingir o alvo
-- Registro da magia no servidor suddenStrike:register() -- Registra a magia no servidor continue aguardando
- Assistant
Entendido! Estou acompanhando e pronto para seguir com mais informações ou instruções quando necessário. Continue aguardando.
- User
eu quero alterar o metodo Instant spell caso ele seja chamado no arquivo do suddentstrike no meotod Spell("instant") ele funcione de uma forma similar ao runespell
- Assistant
Para fazer o
InstantSpellse comportar de maneira semelhante a umRuneSpellquando a magia "Sudden Strike" é chamada, você precisará alterar a lógica do métodoInstantSpell::playerCastInstant. O objetivo é ajustar o comportamento deste método para tratar a magia "Sudden Strike" de forma especial. Aqui estão alguns passos gerais que você pode seguir para implementar essa alteração:-
Identifique a magia "Sudden Strike" no
InstantSpell:Modifique o método
InstantSpell::playerCastInstantpara detectar quando a magia chamada é "Sudden Strike". Você pode fazer isso comparando o nome da magia com "Sudden Strike".std::string spellName = getName(); if (spellName == "Sudden Strike") { // Comportamento especial para Sudden Strike } -
Adapte o comportamento dentro da condicional:
Dentro deste bloco condicional, aplique a lógica que se assemelha ao que ocorre no
RuneSpell. Isso pode incluir modificações como:- Maneira como o alvo é obtido.
- Regras de alcance e linha de visão.
- Regras de recarga e cooldown.
Você pode reutilizar partes do código existente em
RuneSpellou ajustar as condições para atender ao caso específico de "Sudden Strike". -
Exemplo de alteração no
InstantSpell:Considere adaptar o código dentro do bloco que lida com alvos:
if (spellName == "Sudden Strike") { std::shared_ptr<Creature> target = player->getAttackedCreature(); if (!target || !canThrowSpell(player, target)) { player->sendCancelMessage(RETURNVALUE_CREATUREISNOTREACHABLE); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } LuaVariant var; var.type = VARIANT_NUMBER; var.number = target->getID(); if (!executeCastSpell(player, var)) { return false; } } -
Testes e Verificações:
Após implementar a mudança, é fundamental testar o comportamento tanto para a magia "Sudden Strike" quanto para outras magias instants para garantir que nenhuma funcionalidade pré-existente seja quebrada.
Lembre-se de adaptar o código para suas necessidades específicas e garantir que a lógica da sua aplicação seja respeitada. Além disso, é importante garantir que as permissões e vocações para a "Sudden Strike" sejam verificadas corretamente, o que pode exigir ajustes adicionais em outras partes do sistema de magias.
-
- User
eu quero criar uma spell que não seja instantanea quero adicionar uma condicional dentro da instantspell para caso esta skill specifica seja chamada ele funcione similar o runespell e crie um target no mouse
- Assistant
Para ajustar uma magia do tipo
InstantSpellpara que tenha um comportamento similar a umRuneSpelle funcione com umtargetno mouse, você pode introduzir uma condicional dentro do métodoInstantSpell::playerCastInstant. Vou demonstrar como você pode modificar o código para identificar uma magia específica e alterar seu comportamento:- Identifique a Magia:
No método
InstantSpell::playerCastInstant, verifique o nome da magia. Se for a magia que você deseja tratar de maneira especial, desvie o fluxo para a lógica semelhante à de umRuneSpell.
bool InstantSpell::playerCastInstant(std::shared_ptr<Player> player, std::string ¶m) { // Identificar a magia específica if (getName() == "Sudden Strike") { // Implementar lógica similar ao RuneSpell } // Resto do método original... if (!playerSpellCheck(player)) { return false; } // Código restante... }- Implemente a Lógica Similar ao RuneSpell:
Dentro da condicional, você deve implementar a lógica que seleciona um alvo a partir do cursor do mouse e verifica as condições relevantes para a
RuneSpell.
if (getName() == "Sudden Strike") { // Verificar a posição do alvo e outras condições específicas Position targetPos; std::shared_ptr<Creature> targetCreature; if (!param.empty()) { // Usar o parâmetro para determinar o alvo (por exemplo, um nome de jogador) if (!g_game().getPlayerByNameWildcard(param, targetCreature)) { player->sendCancelMessage(RETURNVALUE_PLAYERWITHTHISNAMEISNOTONLINE); return false; } targetPos = targetCreature->getPosition(); } else { // Alternativamente, obter a posição do cursor targetPos = player->getClickedPosition(); if (!g_game().canThrowObjectTo(player->getPosition(), targetPos)) { player->sendCancelMessage(RETURNVALUE_NOTPOSSIBLE); return false; } } LuaVariant var; var.type = VARIANT_POSITION; var.pos = targetPos; // Executar o lançamento similar ao de uma magia com alvo return executeCastSpell(player, var); }-
Função de Clique do Mouse: Se o sistema ainda não fornece a posição do mouse ou um método similar, você deverá certificar-se de que o método
getClickedPosition()é implementado corretamente para retornar umaPositionbaseada na localização onde o jogador está apontando. -
Teste e Ajuste: Assim que implementar essa lógica, teste a nova configuração com a magia específica para verificar se o comportamento é conforme esperado, garantindo que a função de alvo com o mouse funcione corretamente.
Este é um guia base, e talvez você precise ajustar logicamente a implementação à medida que avança, com base no comportamento específico e sistema de alocação de alvo que seu jogo utiliza.
- Identifique a Magia:
No método
- User
coloco isso em qual parte do arquivo?
- Assistant
Você deve colocar essa lógica dentro do método
InstantSpell::playerCastInstantno arquivospells.cpp. Este método é responsável por tratar o lançamento de magias instantâneas, e é onde você deve adicionar a condicional para verificar se a magia específica (como "Sudden Strike") está sendo lançada. A ideia é detectar o nome da magia logo no início do método e, se corresponder à magia que você deseja modificar, aplicar a lógica particular que define o comportamento similar aoRuneSpell.Passos para Implementação:
-
Localize o Método: Encontre a definição do método
bool InstantSpell::playerCastInstant(std::shared_ptr<Player> player, std::string ¶m)dentro do arquivospells.cpp. -
Adicione a Condicional: Logo após verificar alguma condição inicial, como
playerSpellCheck, adicione uma condicional para detectar a magia "Sudden Strike":// Dentro do método playerCastInstant bool InstantSpell::playerCastInstant(std::shared_ptr<Player> player, std::string ¶m) { // Execute verificações iniciais if (!playerSpellCheck(player)) { return false; } // Identifique a magia "Sudden Strike" if (getName() == "Sudden Strike") { // Adicione a lógica particular, semelhante ao RuneSpell aqui Position targetPos; std::shared_ptr<Creature> targetCreature; if (!param.empty()) { if (!g_game().getPlayerByNameWildcard(param, targetCreature)) { player->sendCancelMessage(RETURNVALUE_PLAYERWITHTHISNAMEISNOTONLINE); return false; } targetPos = targetCreature->getPosition(); } else { targetPos = player->getClickedPosition(); if (!g_game().canThrowObjectTo(player->getPosition(), targetPos)) { player->sendCancelMessage(RETURNVALUE_NOTPOSSIBLE); return false; } } LuaVariant var; var.type = VARIANT_POSITION; var.pos = targetPos; return executeCastSpell(player, var); } // Continuar com o fluxo normal para outras magias instantâneas LuaVariant var; var.instantName = getName(); // ...O restante do método original... } -
Compile e Teste: Após a implementação, compile o código e teste o jogo para verificar se a magia "Sudden Strike" se comporta conforme esperado quando lançada. Certifique-se de que a lógica de mira e execução do feitiço está correta.
Esta abordagem mantém o fluxo de execução para outras magias instantâneas inalterado, apenas adicionando um comportamento especial para a magia específica que você está ajustando.
-
- User
adicione as mudanças aqui e irei colar: bool InstantSpell::playerCastInstant(std::shared_ptr player, std::string ¶m) { if (!playerSpellCheck(player)) { return false; }
LuaVariant var; var.instantName = getName(); std::shared_ptr<Player> playerTarget = nullptr; if (selfTarget) { var.type = VARIANT_NUMBER; var.number = player->getID(); } else if (needTarget || casterTargetOrDirection) { std::shared_ptr<Creature> target; bool useDirection = false; if (hasParam) { ReturnValue ret = g_game().getPlayerByNameWildcard(param, playerTarget); if (playerTarget && playerTarget->isAccessPlayer() && !player->isAccessPlayer()) { playerTarget = nullptr; } target = playerTarget; if (!target || target->isRemoved() || target->getHealth() <= 0) { if (!casterTargetOrDirection) { applyCooldownConditions(player); player->sendCancelMessage(ret); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } useDirection = true; } if (playerTarget) { param = playerTarget->getName(); } } else { target = player->getAttackedCreature(); if (!target || target->isRemoved() || target->getHealth() <= 0) { if (!casterTargetOrDirection) { player->sendCancelMessage(RETURNVALUE_YOUCANONLYUSEITONCREATURES); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } useDirection = true; } } if (!useDirection) { if (!canThrowSpell(player, target)) { player->sendCancelMessage(RETURNVALUE_CREATUREISNOTREACHABLE); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } var.type = VARIANT_NUMBER; var.number = target->getID(); } else { var.type = VARIANT_POSITION; var.pos = Spells::getCasterPosition(player, player->getDirection()); if (!playerInstantSpellCheck(player, var.pos)) { return false; } } } else if (hasParam) { var.type = VARIANT_STRING; if (getHasPlayerNameParam()) { ReturnValue ret = g_game().getPlayerByNameWildcard(param, playerTarget); if (ret != RETURNVALUE_NOERROR) { applyCooldownConditions(player); player->sendCancelMessage(ret); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } if (playerTarget && (!playerTarget->isAccessPlayer() || player->isAccessPlayer())) { param = playerTarget->getName(); } } var.text = param; } else { var.type = VARIANT_POSITION; if (needDirection) { var.pos = Spells::getCasterPosition(player, player->getDirection()); } else { var.pos = player->getPosition(); } if (!playerInstantSpellCheck(player, var.pos)) { return false; } } if (!allowOnSelf && playerTarget && playerTarget->getName() == player->getName()) { player->sendCancelMessage(RETURNVALUE_NOTPOSSIBLE); return false; } auto worldType = g_game().getWorldType(); if (pzLocked && (worldType == WORLD_TYPE_PVP || worldType == WORLD_TYPE_PVP_ENFORCED)) { player->addInFightTicks(true); player->updateLastAggressiveAction(); } bool result = executeCastSpell(player, var); if (result) { postCastSpell(player); } return result;}
bool InstantSpell::canThrowSpell(std::shared_ptr creature, std::shared_ptr target) const { const Position &fromPos = creature->getPosition(); const Position &toPos = target->getPosition(); if (fromPos.z != toPos.z || (range == -1 && !g_game().canThrowObjectTo(fromPos, toPos, checkLineOfSight ? SightLine_CheckSightLineAndFloor : SightLine_NoCheck)) || (range != -1 && !g_game().canThrowObjectTo(fromPos, toPos, checkLineOfSight ? SightLine_CheckSightLineAndFloor : SightLine_NoCheck, range, range))) { return false; } return true; }
bool InstantSpell::castSpell(std::shared_ptr creature) { LuaVariant var; var.instantName = getName();
if (casterTargetOrDirection) { std::shared_ptr<Creature> target = creature->getAttackedCreature(); if (target && target->getHealth() > 0) { if (!canThrowSpell(creature, target)) { return false; } var.type = VARIANT_NUMBER; var.number = target->getID(); var.instantName = getName(); return executeCastSpell(creature, var); } return false; } else if (needDirection) { var.type = VARIANT_POSITION; var.pos = Spells::getCasterPosition(creature, creature->getDirection()); } else { var.type = VARIANT_POSITION; var.pos = creature->getPosition(); } return executeCastSpell(creature, var);}
bool InstantSpell::castSpell(std::shared_ptr creature, std::shared_ptr target) { if (needTarget) { LuaVariant var; var.type = VARIANT_NUMBER; var.number = target->getID(); return executeCastSpell(creature, var); } else { return castSpell(creature); } }
bool InstantSpell::executeCastSpell(std::shared_ptr creature, const LuaVariant &var) const { // onCastSpell(creature, var) if (!getScriptInterface()->reserveScriptEnv()) { g_logger().error("[InstantSpell::executeCastSpell - Creature {} words {}] " "Call stack overflow. Too many lua script calls being nested.", creature->getName(), getWords()); return false; }
ScriptEnvironment* env = getScriptInterface()->getScriptEnv(); env->setScriptId(getScriptId(), getScriptInterface()); lua_State* L = getScriptInterface()->getLuaState(); getScriptInterface()->pushFunction(getScriptId()); LuaScriptInterface::pushUserdata<Creature>(L, creature); LuaScriptInterface::setCreatureMetatable(L, -1, creature); LuaScriptInterface::pushVariant(L, var); return getScriptInterface()->callFunction(2);}
bool InstantSpell::canCast(std::shared_ptr player) const { if (player->hasFlag(PlayerFlags_t::CannotUseSpells)) { return false; }
if (player->hasFlag(PlayerFlags_t::IgnoreSpellCheck)) { return true; } if (getNeedLearn()) { if (player->hasLearnedInstantSpell(getName())) { return true; } } else { if (vocSpellMap.empty() || vocSpellMap.contains(player->getVocationId())) { return true; } } return false;}
- Assistant
Vamos adicionar a lógica condicional para a magia "Sudden Strike" dentro do método
InstantSpell::playerCastInstant. Aqui está o código modificado com a inclusão dessa lógica:bool InstantSpell::playerCastInstant(std::shared_ptr<Player> player, std::string ¶m) { if (!playerSpellCheck(player)) { return false; } // Identifique a magia específica "Sudden Strike" if (getName() == "Sudden Strike") { Position targetPos; std::shared_ptr<Creature> targetCreature; if (!param.empty()) { if (!g_game().getPlayerByNameWildcard(param, targetCreature)) { player->sendCancelMessage(RETURNVALUE_PLAYERWITHTHISNAMEISNOTONLINE); return false; } targetPos = targetCreature->getPosition(); } else { targetPos = player->getClickedPosition(); if (!g_game().canThrowObjectTo(player->getPosition(), targetPos)) { player->sendCancelMessage(RETURNVALUE_NOTPOSSIBLE); return false; } } LuaVariant var; var.type = VARIANT_POSITION; var.pos = targetPos; return executeCastSpell(player, var); } LuaVariant var; var.instantName = getName(); std::shared_ptr<Player> playerTarget = nullptr; if (selfTarget) { var.type = VARIANT_NUMBER; var.number = player->getID(); } else if (needTarget || casterTargetOrDirection) { std::shared_ptr<Creature> target; bool useDirection = false; if (hasParam) { ReturnValue ret = g_game().getPlayerByNameWildcard(param, playerTarget); if (playerTarget && playerTarget->isAccessPlayer() && !player->isAccessPlayer()) { playerTarget = nullptr; } target = playerTarget; if (!target || target->isRemoved() || target->getHealth() <= 0) { if (!casterTargetOrDirection) { applyCooldownConditions(player); player->sendCancelMessage(ret); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } useDirection = true; } if (playerTarget) { param = playerTarget->getName(); } } else { target = player->getAttackedCreature(); if (!target || target->isRemoved() || target->getHealth() <= 0) { if (!casterTargetOrDirection) { player->sendCancelMessage(RETURNVALUE_YOUCANONLYUSEITONCREATURES); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } useDirection = true; } } if (!useDirection) { if (!canThrowSpell(player, target)) { player->sendCancelMessage(RETURNVALUE_CREATUREISNOTREACHABLE); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } var.type = VARIANT_NUMBER; var.number = target->getID(); } else { var.type = VARIANT_POSITION; var.pos = Spells::getCasterPosition(player, player->getDirection()); if (!playerInstantSpellCheck(player, var.pos)) { return false; } } } else if (hasParam) { var.type = VARIANT_STRING; if (getHasPlayerNameParam()) { ReturnValue ret = g_game().getPlayerByNameWildcard(param, playerTarget); if (ret != RETURNVALUE_NOERROR) { applyCooldownConditions(player); player->sendCancelMessage(ret); g_game().addMagicEffect(player->getPosition(), CONST_ME_POFF); return false; } if (playerTarget && (!playerTarget->isAccessPlayer() || player->isAccessPlayer())) { param = playerTarget->getName(); } } var.text = param; } else { var.type = VARIANT_POSITION; if (needDirection) { var.pos = Spells::getCasterPosition(player, player->getDirection()); } else { var.pos = player->getPosition(); } if (!playerInstantSpellCheck(player, var.pos)) { return false; } } if (!allowOnSelf && playerTarget && playerTarget->getName() == player->getName()) { player->sendCancelMessage(RETURNVALUE_NOTPOSSIBLE); return false; } auto worldType = g_game().getWorldType(); if (pzLocked && (worldType == WORLD_TYPE_PVP || worldType == WORLD_TYPE_PVP_ENFORCED)) { player->addInFightTicks(true); player->updateLastAggressiveAction(); } bool result = executeCastSpell(player, var); if (result) { postCastSpell(player); } return result; }O que foi adicionado:
- A verificação se o nome da magia é "Sudden Strike" logo após
playerSpellCheck. - Implementação do comportamento especial que simula a lógica do
RuneSpell, onde se tenta obter um alvo baseado no nome do jogador ou na posição do mouse.
Este ajuste mantém o restante do método inalterado e permite que a magia "Sudden Strike" funcione de maneira especial, enquanto outras magias continuam a funcionar normalmente. Lembre-se de implementar o método
getClickedPosition()se ainda não existir ou verificar como obter a posição do clique do mouse no seu ambiente de jogo. - A verificação se o nome da magia é "Sudden Strike" logo após