public int CalculateDamage(IPokemon pokemon, IPokemon target)
{
int damage = 0;
if (AdditionalEffects.ContainsEffectType(typeof(AlwaysSameDamage)))
{
AlwaysSameDamage alwaysSameDamage = AdditionalEffects.First(e => e is AlwaysSameDamage) as AlwaysSameDamage;
damage = alwaysSameDamage.IsBasedOnLevel() ? pokemon.Level : (int)alwaysSameDamage.PrimaryParameter;
}
if (damage == 0 && Power.HasValue)
{
damage = DamageCalculator.CalculateAttackDamage(this, pokemon, target);
if (damage < 1)
{
damage = 1;
}
if (BattleHelper.IsCritical(AdditionalEffects, pokemon.IsEnergyFocused))
{
damage *= 2;
//_battleLogController.SetText("Critical hit!");
}
}
return(damage);
}
/// <inheritdoc />
public override AttackResult CalculateDamages()
{
var attackResult = new AttackResult
{
Flags = AttackFlags.AF_MAGIC
};
AttackResult weaponAttackResult = null;
if (Attacker is IPlayerEntity player)
{
Item wandWeapon = player.Inventory.GetEquipedItem(ItemPartType.RightWeapon) ?? player.Hand;
weaponAttackResult = BattleHelper.GetWeaponAttackPower(Attacker, wandWeapon);
var weaponAttackDamages = BattleHelper.GetWeaponAttackDamages(WeaponType.MAGIC_WAND, player);
weaponAttackResult.AttackMin += weaponAttackDamages;
weaponAttackResult.AttackMax += weaponAttackDamages;
}
if (weaponAttackResult != null)
{
attackResult.Damages = RandomHelper.Random(weaponAttackResult.AttackMin, weaponAttackResult.AttackMax);
attackResult.Damages += Math.Max(0, Attacker.Attributes[DefineAttributes.CHR_DMG]);
attackResult.Damages = (int)(attackResult.Damages * GetWandAttackMultiplier());
}
return(attackResult);
}
private static void ActionSequence(Character activePlayer, Character reactivePlayer, BaseAction activePlayerAction, List <ActionStep> steps)
{
steps.Add(new ActionStep {
Author = activePlayer, StepMessage = activePlayer.Name.ToString() + ":look-at"
});
var damage = activePlayerAction.Power;
var step = new ActionStep
{
Author = activePlayer,
StepMessage = activePlayer.Name.ToString() + ":hit",
ActionRef = activePlayerAction,
StepType = ActionStepType.Attack
};
step.Run = delegate()
{
if (BattleHelper.CheckAttackRange(activePlayer.Position, reactivePlayer.Position, activePlayerAction.MinRange, activePlayerAction.MaxRange))
{
reactivePlayer.HP -= damage;
}
activePlayer.Position = activePlayerAction.MoveTo;
};
steps.Add(step);
}
IEnumerator StartSpawnFoods()
{
while (true)
{
var spawnFoodCount = Constants.INIT_FOOD_COUNT - battle.IdToFoods.Count;
// 获取最大食物 id
PlayArray spawnFoods = new PlayArray();
var nextFoodId = battle.NextFoodId;
for (int i = 0; i < spawnFoodCount; i++)
{
var foodId = nextFoodId + i;
var foodPos = BattleHelper.RandomPos();
var food = new Food {
Id = foodId,
Type = i % 3,
X = foodPos.X,
Y = foodPos.Y
};
spawnFoods.Add(food);
}
var eventData = new PlayObject {
{ "foods", spawnFoods },
{ "nextFoodId", nextFoodId + spawnFoodCount }
};
var client = LeanCloudUtils.GetClient();
client.SendEvent(Constants.SPAWN_FOOD_EVENT, eventData);
yield return(new WaitForSeconds(Constants.SPWAN_FOOD_DURATION));
}
}
public override void Update(SkillObjMoveController ctrl, SkillBulletMove move, float deltaTime, float timeMS)
{
double MoveDir = move.GetSpeedDirection_Radian();
int tarId = ctrl.GetTarID();
var target = ctrl.GetTar();
if (target != null && !target.IsDead())
{
MoveDir = BattleHelper.Radian2PI(MoveDir);
var tarPos = target.GetPos();
Vector3_Hzy selfPos = ctrl.GetPos();
double radian = BattleHelper.RadianA2B_2D(tarPos, selfPos);
radian = BattleHelper.Radian2PI(radian);
if (radian != MoveDir)
{
float tickRadian = ctrl.GetMovingFloatParam(Key_TickRadian_MovingFloatParam);
double something = ((5 + tickRadian) * System.Math.PI / 180);
double changeRadian = BattleHelper.RadianA2B_Sym(radian, MoveDir, something);
tickRadian += deltaTime * 0.6f / 30;
ctrl.SetMovingFloatParam(Key_TickRadian_MovingFloatParam, tickRadian);
MoveDir = BattleHelper.Radian2PI(MoveDir + changeRadian);
move.SetSpeedDirection((float)MoveDir);
}
}
else
{
ctrl.SetLifeTime(-1);
return;
}
base.Update(ctrl, move, deltaTime, timeMS);
}
/// <summary>
/// Gets the attacker skill power.
/// </summary>
/// <returns>Skill power.</returns>
protected int GetAttackerSkillPower()
{
var referStatistic1 = Attacker.Attributes[Skill.Data.ReferStat1];
var referStatistic2 = Attacker.Attributes[Skill.Data.ReferStat2];
if (Skill.Data.ReferTarget1 == SkillReferTargetType.Attack && referStatistic1 != 0)
{
referStatistic1 = (int)(Skill.Data.ReferValue1 / 10f * referStatistic1 + Skill.Level * (referStatistic1 / 50f));
}
if (Skill.Data.ReferTarget2 == SkillReferTargetType.Attack && referStatistic2 != 0)
{
referStatistic2 = (int)(Skill.Data.ReferValue2 / 10f * referStatistic2 + Skill.Level * (referStatistic2 / 50f));
}
var referStatistic = referStatistic1 + referStatistic2;
int attackMin;
int attackMax;
if (Attacker.Type == WorldEntityType.Player && Defender.Type == WorldEntityType.Player)
{
attackMin = Skill.LevelData.AbilityMinPVP;
attackMax = Skill.LevelData.AbilityMaxPVP;
}
else
{
attackMin = Skill.LevelData.AbilityMin;
attackMax = Skill.LevelData.AbilityMax;
}
Item weaponItem = Attacker.Hand;
if (Attacker is IPlayerEntity player)
{
weaponItem = player.Inventory.GetEquipedItem(ItemPartType.RightWeapon);
if (weaponItem.Id == -1)
{
weaponItem = InventorySystem.Hand;
}
}
AttackResult weaponAttackPower = BattleHelper.GetWeaponAttackPower(Attacker, weaponItem);
var weaponExtraDamages = BattleHelper.GetWeaponExtraDamages(Attacker, weaponItem);
attackMin += weaponItem.Data.AttackSkillMin;
attackMax += weaponItem.Data.AttackSkillMax;
float powerMin = (weaponAttackPower.AttackMin + attackMin * 5 + referStatistic - 20) * (16 + Skill.Level) / 13;
float powerMax = (weaponAttackPower.AttackMax + attackMax * 5 + referStatistic - 20) * (16 + Skill.Level) / 13;
// TODO: check CHR_DMG
powerMin += weaponExtraDamages;
powerMax += weaponExtraDamages;
var attackMinMax = Math.Max(powerMax - powerMin + 1, 1);
return((int)(powerMin + RandomHelper.FloatRandom(1f, attackMinMax)));
}
public QueueService(
IBattleService battleService)
{
_battleService = battleService;
_botsRandom = new Random();
_bots = new HashSet <BotDefinition>();
_queues = BattleHelper.GetNewModeQueue();
}
public void ProcessMessage(GameReady gameReadyMessage)
{
battleViewer.DisableCancelFindButton();
var kernelPlayer1 = new Player(0);
var kernelPlayer2 = new Player(1);
LocalPlayer = new LocalPlayer(battleViewer, kernelPlayer1, this, gameManager.UserName);
OnlinePlayer = new OnlinePlayer(kernelPlayer2, this, gameReadyMessage.Opponent.Login);
((OnlinePlayer)OnlinePlayer).OnEnable();
IEnumerable <GameObject> opponentTeam = ClientFruitonFactory.CreateClientFruitonTeam(gameReadyMessage.OpponentTeam.FruitonIDs, battleViewer.Board);
IEnumerable <GameObject> currentTeam = ClientFruitonFactory.CreateClientFruitonTeam(gameManager.CurrentFruitonTeam.FruitonIDs, battleViewer.Board);
// The opponent team is obtained from the server with the correctly set positions.
battleViewer.InitializeTeam(opponentTeam, kernelPlayer2, kernelPlayer2.id == 0, gameReadyMessage.OpponentTeam.Positions.ToArray());
GameSettings kernelSettings = GameSettingsFactory.CreateGameSettings(gameReadyMessage.MapId, battleViewer.GameMode);
var fruitons = new haxe.root.Array <object>();
foreach (var fruiton in currentTeam)
{
fruitons.push(fruiton.GetComponent <ClientFruiton>().KernelFruiton);
}
foreach (var fruiton in opponentTeam)
{
fruitons.push(fruiton.GetComponent <ClientFruiton>().KernelFruiton);
}
IsLocalPlayerFirst = gameReadyMessage.StartsFirst;
Player player1;
Player player2;
// If the local player begins, the game will be started with kernelPlayer1 as first argument.
if (IsLocalPlayerFirst)
{
battleViewer.InitializeTeam(currentTeam, kernelPlayer1, kernelPlayer1.id == 0, GameManager.Instance.CurrentFruitonTeam.Positions.ToArray());
player1 = kernelPlayer1;
player2 = kernelPlayer2;
}
// If the online opponent begins, we need to flip the positions to the opposite side because we do not receive
// the new positions from the server. The first argument has to be the online opponent = kernelPlayer2.
else
{
var width = GameState.WIDTH;
var height = GameState.HEIGHT;
var flippedPositions = BattleHelper.FlipCoordinates(GameManager.Instance.CurrentFruitonTeam.Positions, width, height);
battleViewer.InitializeTeam(currentTeam, kernelPlayer1, kernelPlayer1.id == 0, flippedPositions.ToArray());
player1 = kernelPlayer2;
player2 = kernelPlayer1;
battleViewer.DisableEndTurnButton();
}
Kernel = new Kernel(player1, player2, fruitons, kernelSettings, false, false);
SendReadyMessage();
battleViewer.InitializePlayersInfo();
BattleReady();
}
public AIBattle(BattleViewer battleViewer, AIType aiType)
: base(battleViewer)
{
int[] aiTeamIDs;
var kernelPlayer1 = new Player(0);
var kernelPlayer2 = new Player(1);
HumanPlayer = new LocalPlayer(battleViewer, kernelPlayer1, this, GameManager.Instance.UserName);
AiPlayer = CreateAI(aiType, battleViewer, kernelPlayer2, this, out aiTeamIDs);
IEnumerable <GameObject> humanTeam;
IEnumerable <Position> coords;
IEnumerable <Position> flippedCoords;
IEnumerable <GameObject> aiTeam = ClientFruitonFactory.CreateClientFruitonTeam(aiTeamIDs, battleViewer.Board);
if (aiType == AIType.Tutorial)
{
int[] humanTeamIDs = { 2, 5, 15, 14, 12, 17, 21, 21, 30, 25 };
humanTeam = ClientFruitonFactory.CreateClientFruitonTeam(humanTeamIDs, battleViewer.Board);
coords = Tutorial.CreatePositionsForArtificialTeam(humanTeam.Select(gameObject =>
gameObject.GetComponent <ClientFruiton>().KernelFruiton));
}
else
{
humanTeam = ClientFruitonFactory.CreateClientFruitonTeam(gameManager.CurrentFruitonTeam.FruitonIDs, battleViewer.Board);
coords = gameManager.CurrentFruitonTeam.Positions;
}
battleViewer.InitializeTeam(humanTeam, kernelPlayer1, kernelPlayer1.id == 0, coords.ToArray());
flippedCoords = BattleHelper.FlipCoordinates(coords, GameState.WIDTH, GameState.HEIGHT);
battleViewer.InitializeTeam(aiTeam, kernelPlayer2, kernelPlayer2.id == 0, flippedCoords.ToArray());
var fruitons = new Array <object>();
foreach (var fruiton in humanTeam)
{
fruitons.push(fruiton.GetComponent <ClientFruiton>().KernelFruiton);
}
foreach (var fruiton in aiTeam)
{
fruitons.push(fruiton.GetComponent <ClientFruiton>().KernelFruiton);
}
Array <int> maps = GameManager.Instance.FruitonDatabase.getMapsIds();
int rndMapId = maps[Random.Range(0, maps.length)];
GameSettings kernelSettings = GameSettingsFactory.CreateGameSettings(rndMapId, battleViewer.GameMode);
bool infiniteTurnTime = battleViewer.battleType == BattleType.TutorialBattle;
Kernel = new Kernel(kernelPlayer1, kernelPlayer2, fruitons, kernelSettings, false, infiniteTurnTime);
BattleReady();
}
public IEnumerable <SynchronizerDto> GetAllUserSynchronizationInfos(string userId)
{
return(_scenes
.Where(scene => scene.IsActive && scene.ShortPlayers.FirstOrDefault(x => x.UserId == userId && !x.Left) != null)
.Select(scene =>
{
var player = scene.ShortPlayers.First(x => x.UserId == userId);
var synchronizer = BattleHelper.GetFullSynchronizationData(scene, userId);
BattleHelper.CalculateReward(ref synchronizer, scene, player.Id);
return synchronizer;
})
.ToHashSet());
}
void OnBallAndBallCollision(BallCollisionArgs args)
{
var ball1 = args.Ball1;
var ball2 = args.Ball2;
// 判断胜负
var weight1 = ball1.Player.CustomProperties.GetFloat("weight");
var weight2 = ball2.Player.CustomProperties.GetFloat("weight");
Player winner, loser;
if (weight1 > weight2)
{
winner = ball1.Player;
loser = ball2.Player;
}
else
{
winner = ball2.Player;
loser = ball1.Player;
}
var winnerWeight = weight1 + weight2;
var props = new PlayObject {
{ "weight", winnerWeight }
};
// 设置胜利方
winner.SetCustomProperties(props);
// 重置失败方
var loserWeight = Mathf.Pow(Constants.BORN_SIZE, 2);
var pos = BattleHelper.RandomPos();
props = new PlayObject {
{ "pos", pos },
{ "weight", loserWeight },
{ "move", null }
};
loser.SetCustomProperties(props);
// 通知胜负情况
var client = LeanCloudUtils.GetClient();
var eventData = new PlayObject {
{ "winnerId", winner.ActorId },
{ "loserId", loser.ActorId }
};
client.SendEvent(Constants.KILL_EVENT, eventData);
// 通知重生
eventData = new PlayObject {
{ "playerId", loser.ActorId }
};
client.SendEvent(Constants.REBORN_EVENT, eventData);
}
public void SetInfo(int rank, string name, int weight, bool isLocal)
{
var color = Color.white;
if (isLocal)
{
color = Color.yellow;
}
rankText.color = color;
nameText.color = color;
weightText.color = color;
rankText.text = rank.ToString();
nameText.text = name;
weightText.text = BattleHelper.ToReadableWeight(weight);
}
public void OnClick()
{
A_TypeEffectiveness typeEffectiveness = BattleHelper.GetTypeEffectiveness(AttackType, DefendType0, DefendType1);
if (DefendType1 != P_Type.none)
{
Logger.Debug(GetType(), "'" + AttackType.ToString() + "' is '" + typeEffectiveness.ToString() + "' on '" +
DefendType0.ToString() + "' & '" + DefendType1.ToString() + "'.");
}
else
{
Logger.Debug(GetType(), "'" + AttackType.ToString() + "' is '" + typeEffectiveness.ToString() + "' on '" +
DefendType0.ToString() + "'.");
}
Logger.Debug(GetType(), TypeData.GetColor(AttackType).ToString());
}
public SynchronizerDto GetUserSynchronizationInfo(string userId, Guid?sceneId)
{
IScene scene;
scene = _scenes
.FirstOrDefault(scene => scene.IsActive &&
(sceneId == null || sceneId == scene.Id) &&
scene.ShortPlayers.FirstOrDefault(x => x.UserId == userId && !x.Left) != null);
if (scene == null)
{
return(null);
}
var player = scene.ShortPlayers.First(x => x.UserId == userId);
var synchronizer = BattleHelper.GetFullSynchronizationData(scene, userId);
BattleHelper.CalculateReward(ref synchronizer, scene, player.Id);
return(synchronizer);
}
public bool IsAbleToAttack()
{
if (IsFlinched)
{
IsFlinched = false;
//_battleLogController.SetText($"{attackingPokemon.Name} is flinched");
return(false);
}
if (IsConfused && BattleHelper.HasFailedConfusion(this))
{
var confusionHit = PokemonAttacksFactory.CreateAttack("ConfusionHit");
int damage = DamageCalculator.CalculateAttackDamage(confusionHit, this, this);
Hurt(damage);
//_battleLogController.SetText($"{attackingPokemon.Name} hurts itself in its confusion");
return(IsPokemonAlive());
}
return(true);
}
async void NewPlayer(Player player)
{
var weight = Mathf.Pow(Constants.BORN_SIZE, 2);
var pos = BattleHelper.RandomPos();
var props = new PlayObject {
{ "weight", weight },
{ "pos", pos }
};
await player.SetCustomProperties(props);
var client = LeanCloudUtils.GetClient();
// 打包内存中的食物数据
var foods = battle.GetFoods();
var eventData = new PlayObject {
{ "foods", foods }
};
await client.SendEvent(Constants.BORN_EVENT, eventData, new SendEventOptions {
TargetActorIds = new List <int> {
player.ActorId
}
});
// 告知「其他玩家」有新玩家加入
var otherIds = new List <int>();
foreach (Player p in client.Room.PlayerList)
{
if (p == player)
{
continue;
}
otherIds.Add(p.ActorId);
}
eventData = new PlayObject {
{ "pId", player.ActorId }
};
await client.SendEvent(Constants.PLAYER_JOINED_EVENT, eventData, new SendEventOptions {
TargetActorIds = otherIds
});
}
public bool AttackCharacter(Vector2 from, Vector2 to)
{
var attacker = GetCharacterFromTile(from);
var defender = GetCharacterFromTile(to); //TODO: Change to get all defenders in range (pass range of attack).
var tile = GetTile(to); //TODO: Idem defender.
var damage = BattleHelper.CalculateDamage(attacker, defender, tile); // TODO: foreach defender.
attacker.Attack(to);
defender.GetHit(damage); //TODO: do "on hit" del defender, pasarle daño, que el mismo defender chequee si muere o no.
if (defender.Stats.HP <= 0)
{
attacker.GainExp(30);
UIManager.CreateExpText(attacker, 30, 2f);
Personajes.Remove(defender);
}
else
{
attacker.GainExp(10);
UIManager.CreateExpText(attacker, 10, 2f);
}
return(true);
}
private void SynchronizationInfoEventHandler(object sender, ISyncEventArgs e)
{
var battleHub = _serviceProvider.GetRequiredService <IHubContext <ArenaHub.ArenaHub> >();
string actionName = BattleHelper.GetBattleActionMethodName(e.Action);
var uniqueUsers = e.Scene.ShortPlayers
.GroupBy(key => key.UserId, res => res, (key, res) => new
{
UserId = key,
Players = res
})
.ToList();
foreach (var userPlayers in uniqueUsers)
{
if (userPlayers.Players.All(x => x.Left))
{
continue;
}
var user = battleHub.Clients.User(userPlayers.UserId);
if (user != null)
{
var synchronizer = BattleHelper.MapSynchronizer(e, userPlayers.UserId);
foreach (var player in userPlayers.Players)
{
if (BattleHelper.CalculateReward(ref synchronizer, e.Scene, player.Id))
{
Task.Run(async() => await PayRewardAsync(synchronizer.Reward, player.UserId));
}
}
battleHub.Clients.User(userPlayers.UserId).SendAsync(actionName, synchronizer);
}
}
}
public OfflineBattle(BattleViewer battleViewer) : base(battleViewer)
{
var kernelPlayer1 = new Player(0);
var kernelPlayer2 = new Player(1);
string login = GameManager.Instance.UserName;
Player1 = new LocalPlayer(battleViewer, kernelPlayer1, this, "Player 1");
Player2 = new LocalPlayer(battleViewer, kernelPlayer2, this, "Player 2");
IEnumerable <GameObject> currentTeam = ClientFruitonFactory.CreateClientFruitonTeam(gameManager.CurrentFruitonTeam.FruitonIDs, battleViewer.Board);
IEnumerable <GameObject> opponentTeam = ClientFruitonFactory.CreateClientFruitonTeam(gameManager.OfflineOpponentTeam.FruitonIDs, battleViewer.Board);
RepeatedField <Position> coords = gameManager.CurrentFruitonTeam.Positions;
battleViewer.InitializeTeam(currentTeam, kernelPlayer1, kernelPlayer1.id == 0, coords.ToArray());
RepeatedField <Position> flippedCoords = BattleHelper.FlipCoordinates(coords, GameState.WIDTH, GameState.HEIGHT);
battleViewer.InitializeTeam(opponentTeam, kernelPlayer2, kernelPlayer2.id == 0, flippedCoords.ToArray());
var fruitons = new Array <object>();
foreach (var fruiton in currentTeam)
{
fruitons.push(fruiton.GetComponent <ClientFruiton>().KernelFruiton);
}
foreach (var fruiton in opponentTeam)
{
fruitons.push(fruiton.GetComponent <ClientFruiton>().KernelFruiton);
}
Array <int> maps = GameManager.Instance.FruitonDatabase.getMapsIds();
int rndMapId = maps[Random.Range(0, maps.length)];
GameSettings kernelSettings = GameSettingsFactory.CreateGameSettings(rndMapId, battleViewer.GameMode);
Kernel = new Kernel(kernelPlayer1, kernelPlayer2, fruitons, kernelSettings, false, false);
BattleReady();
}
//执行指令
public void ExecuteCommand(string command, List <GameObject> paraGameObjects)
{
if (string.IsNullOrEmpty(command))
{
return;
}
m_ParaGameObjects = paraGameObjects;
string cmd = command.Split('#')[0].ToLower();
string value = command.Substring(cmd.Length + 1); //command.Split('#')[1];
if (cmd == "dialog")
{
//dialogPanel.Show("", value, null);
Jyx2_UIManager.Instance.ShowUI("ChatUIPanel", ChatType.RoleKey, "", value);
}
else if (cmd == "selfsay")
{
GameRuntimeData.Instance.Player.View.Say(value);
}
else if (cmd == "loadlevel")
{
SceneManager.LoadScene(value);
}
else if (cmd == "loadmap")
{
var loadPara = new LevelMaster.LevelLoadPara()
{
loadType = LevelMaster.LevelLoadPara.LevelLoadType.Load
};
LevelLoader.LoadGameMap(value, loadPara);
}
else if (cmd == "mapevt")
{
MapEvt mapEvt = ConfigTable.Get <MapEvt>(value);
if (mapEvt != null)
{
//如果已经执行过，返回
if (mapEvt.IsFinished(runtime))
{
return;
}
//标记为正在执行
mapEvt.MarkAsExecuting(runtime);
m_CurrentMapEvt = mapEvt;
PlayStory(mapEvt.ExecuteCode.Split('\n'), mapEvt.Result);
}
else
{
Debug.LogError("载入了错误的mapevt:" + value);
}
}
else if (cmd == "timeline")
{
PlayTimeline(value, null);
}
else if (cmd == "runtimestory")
{
PlayStory(new string[] { value }, "");
}
else if (cmd == "transport")
{
var levelMaster = FindObjectOfType <LevelMaster>();
levelMaster.Transport(value);
}
else if (cmd == "win")
{
BattleHelper battleHelper = FindObjectOfType <BattleHelper>();
var model = battleHelper.GetModel();
foreach (var role in model.Roles)
{
if (role.team != 0)
{
role.Hp = 0;
}
role.CheckDeath();
}
HSUtilsEx.CallWithDelay(this, () => {
battleHelper.SwitchStatesTo(BattleHelper.BattleViewStates.WaitingForNextActiveBattleRole);
}, 1f);
}
else if (cmd == "lose")
{
BattleHelper battleHelper = FindObjectOfType <BattleHelper>();
var model = battleHelper.GetModel();
foreach (var role in model.Roles)
{
if (role.team == 0)
{
role.Hp = 0;
}
role.CheckDeath();
}
HSUtilsEx.CallWithDelay(this, () =>
{
battleHelper.SwitchStatesTo(BattleHelper.BattleViewStates.WaitingForNextActiveBattleRole);
}, 1f);
}
else if (cmd == "testlua")
{
LuaExecutor.Execute(value);
}
else if (cmd == "jyx2event")
{
LuaExecutor.Execute("jygame/ka" + value);
}
else if (cmd == "battle")
{
LevelLoader.LoadBattle(int.Parse(value), null);
}
}
public bool OnRange(int oponentPosition)
{
return(BattleHelper.CheckAttackRange(this.Author.Position, oponentPosition, this.ActionRef.MinRange, this.ActionRef.MaxRange));
}
/// <inheritdoc />
public override AttackResult CalculateDamages()
{
var attackResult = new AttackResult
{
Flags = GetAttackFlags()
};
if (attackResult.Flags.HasFlag(AttackFlags.AF_MISS))
{
return(attackResult);
}
if (Attacker is IPlayerEntity player)
{
Item rightWeapon = player.Inventory.GetEquipedItem(ItemPartType.RightWeapon) ?? player.Hand;
// TODO: GetDamagePropertyFactor()
var weaponAttack = BattleHelper.GetWeaponAttackDamages(rightWeapon.Data.WeaponType, player);
attackResult.AttackMin = rightWeapon.Data.AbilityMin * 2 + weaponAttack;
attackResult.AttackMax = rightWeapon.Data.AbilityMax * 2 + weaponAttack;
}
else if (Attacker is IMonsterEntity monster)
{
if (attackResult.Flags.HasFlag(AttackFlags.AF_MISS))
{
return(attackResult);
}
attackResult.AttackMin = monster.Data.AttackMin;
attackResult.AttackMax = monster.Data.AttackMax;
}
if (IsCriticalAttack(Attacker, attackResult.Flags))
{
attackResult.Flags |= AttackFlags.AF_CRITICAL;
CalculateCriticalDamages(attackResult);
if (IsKnockback(attackResult.Flags))
{
attackResult.Flags |= AttackFlags.AF_FLYING;
}
}
attackResult.Damages = RandomHelper.Random(attackResult.AttackMin, attackResult.AttackMax);
attackResult.Damages -= GetDefenderDefense(attackResult);
if (attackResult.Damages > 0)
{
var blockFactor = GetDefenderBlockFactor();
if (blockFactor < 1f)
{
attackResult.Flags |= AttackFlags.AF_BLOCKING;
attackResult.Damages = (int)(attackResult.Damages * blockFactor);
}
}
else
{
attackResult.Damages = 0;
attackResult.Flags &= ~AttackFlags.AF_CRITICAL;
attackResult.Flags &= ~AttackFlags.AF_FLYING;
}
return(attackResult);
}