Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

this file is spells.cpp:bool InstantSpell::playerCastInstant(std::sharedptr<Player>…

  1. User

    this file is spells.cpp:bool InstantSpell::playerCastInstant(std::shared_ptr player, std::string &param) { 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

  2. Assistant

    Entendido! Estou aqui para ajudar. Aguardo por mais orientações.

  3. 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

  4. Assistant

    Entendido! Estou acompanhando e pronto para seguir com mais informações ou instruções quando necessário. Continue aguardando.

  5. 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

  6. Assistant

    Entendido! Estou acompanhando e pronto para seguir com mais informações ou instruções quando necessário. Continue aguardando.

  7. 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

  8. Assistant

    Para fazer o InstantSpell se comportar de maneira semelhante a um RuneSpell quando a magia "Sudden Strike" é chamada, você precisará alterar a lógica do método InstantSpell::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:

    1. Identifique a magia "Sudden Strike" no InstantSpell:

      Modifique o método InstantSpell::playerCastInstant para 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
      }
      
    2. 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 RuneSpell ou ajustar as condições para atender ao caso específico de "Sudden Strike".

    3. 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;
          }
      }
      
    4. 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.

  9. 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

  10. Assistant

    Para ajustar uma magia do tipo InstantSpell para que tenha um comportamento similar a um RuneSpell e funcione com um target no mouse, você pode introduzir uma condicional dentro do método InstantSpell::playerCastInstant. Vou demonstrar como você pode modificar o código para identificar uma magia específica e alterar seu comportamento:

    1. 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 um RuneSpell.
    bool InstantSpell::playerCastInstant(std::shared_ptr<Player> player, std::string &param) {
        // 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...
    }
    
    1. 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);
    }
    
    1. 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 uma Position baseada na localização onde o jogador está apontando.

    2. 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.

  11. User

    coloco isso em qual parte do arquivo?

  12. Assistant

    Você deve colocar essa lógica dentro do método InstantSpell::playerCastInstant no arquivo spells.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 ao RuneSpell.

    Passos para Implementação:

    1. Localize o Método: Encontre a definição do método bool InstantSpell::playerCastInstant(std::shared_ptr<Player> player, std::string &param) dentro do arquivo spells.cpp.

    2. 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 &param) {
          // 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...
      }
      
    3. 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.

  13. User

    adicione as mudanças aqui e irei colar: bool InstantSpell::playerCastInstant(std::shared_ptr player, std::string &param) { 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;
    

    }

  14. 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 &param) {
    	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.