void Update()
{
//Calculate Neareat Target
Target = GetTarget();
//Adjust Direction
transform.LookAt(Target.transform, Vector3.up);
}
private void SetBattleCharData(Obj obj, Int32 kind, Int32 value)
{
Int32 index = 0;
while (index < 8 && this._objPtrList[index] != obj)
{
++index;
}
if (index >= 8)
{
return;
}
BattleUnit btl = kind != 32 ? btl_scrp.FindBattleUnit((UInt16)(1 << index)) : btl_scrp.FindBattleUnitUnlimited((UInt16)(1 << index));
if (btl == null)
{
return;
}
btl_scrp.SetCharacterData(btl.Data, (UInt32)kind, (UInt32)value);
}
public override void CalculateBehaviourItem(List <BattleBehaviourItem> behaviourItems, float weight)
{
BattleUnit battleUnit = null;
for (int i = 0; i < baseData.enemyBattleTeam.battleUnits.Count; ++i)
{
battleUnit = baseData.enemyBattleTeam.battleUnits[i];
if (!battleUnit.CanAction)
{
continue;
}
BattleBehaviourItem item = BattleBehaviourItem.CreateInstance(battleUnit, BehaviourType);
int distance = baseData.hostBattleUnit.mapGrid.Distance(battleUnit.mapGrid);
float distanceWeight = behaviourSystem.GetDistanceWeight(distance);
item.point = EGameConstL.BattleBehaviourChipMaxPoint * weight * distanceWeight;
battleBehaviourItems.Add(item);
}
//调整行为分数
AddToTargetList(behaviourItems);
}
public override bool IsTrue(TBTWorkingData wData)
{
BattleDecisionWorkingData decisionData = wData as BattleDecisionWorkingData;
BattleUnit battleEntity = decisionData.owner;
if (!battleEntity.IsCanDecision())
{
return(false);
}
// 新的决策
AIBehaviorRequest request = decisionData.request;
if (request == null)
{
return(true);
}
else
{
//上一个请求已经执行完成，就更新新请求
return(request.IsRequestCompleted());
}
}
void onPlayerFightPropChange(EventBase e)
{
if (!mEnable)
{
return;
}
PropertyEvent evt = (PropertyEvent)e;
BattleUnit unit = PlayerController.Instance.GetControlObj() as BattleUnit;
if (unit.GetMaxHP() <= 0)
{
mSprite.alpha = 0.0f;
}
else
{
mHpScale = (float)unit.GetHP() / (float)unit.GetMaxHP();
if (mHpScale <= mOpenScalse)
{
float alpha = (mOpenScalse - mHpScale) / mOpenScalse + mBeginAlpha;
if (!mBeginFlicker)
{
mSprite.alpha = mCurAlpha = mBeginAlpha;
mBeginFlicker = true;
}
//mLastAlpha = 1.0f;
}
else
{
mSprite.alpha = 0.0f;
mBeginFlicker = false;
}
}
}
void OnRevive(BattleUnit unit)
{
if (!isSummonded)
{
skeletonAnimation.state.SetAnimation(0, idleAnimation, true);
}
//SetBattleGroup(battleGroup);//?
tomestone = null;
//if (tomestone)
// tomestone.gameObject.SetActive(false);
if (objShadow)
{
objShadow.gameObject.SetActive(true);
}
skeletonAnimation.gameObject.SetActive(true);
skeletonAnimation.enabled = true;
if (coroutineFadeOut != null)
{
StopCoroutine(coroutineFadeOut);
coroutineFadeOut = null;
}
Renderer r = skeletonAnimation.GetComponent <Renderer>();
float alpha = 1f;
for (int i = 0; i < r.materials.Length; i++)
{
Color c = r.materials[i].color;
c.a = alpha;
r.materials[i].color = c;
}
}
private static BattleCommandId GetCommandFromCommandIndex(CommandMenu commandIndex, Int32 playerIndex)
{
BattleUnit player = FF9StateSystem.Battle.FF9Battle.GetUnit(playerIndex);
CharacterPresetId presetId = FF9StateSystem.Common.FF9.party.GetCharacter(player.Position).PresetId;
switch (commandIndex)
{
case CommandMenu.Attack:
return(BattleCommandId.Attack);
case CommandMenu.Defend:
return(BattleCommandId.Defend);
case CommandMenu.Ability1:
{
CharacterCommandSet commandSet = CharacterCommands.CommandSets[presetId];
Boolean underTrance = player.IsUnderStatus(BattleStatus.Trance);
return(commandSet.Get(underTrance, 0));
}
case CommandMenu.Ability2:
{
CharacterCommandSet commandSet = CharacterCommands.CommandSets[presetId];
Boolean underTrance = player.IsUnderStatus(BattleStatus.Trance);
return(commandSet.Get(underTrance, 1));
}
case CommandMenu.Item:
return(BattleCommandId.Item);
case CommandMenu.Change:
return(BattleCommandId.Change);
default:
return(BattleCommandId.None);
}
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Constructors/Initialisation
/// <summary>
/// Creates a new standard unit rotation action for the specified unit.
/// </summary>
/// <param name="unit">The unit that this action is attached to.</param>
/// <param name="startRotation">The initial rotation value.</param>
/// <param name="endRotation">The end rotation value.</param>
internal UnitRotation(BattleUnit unit, float startRotation, float endRotation)
: base(unit)
{
this._startRotation = startRotation;
this._endRotation = endRotation;
while (this._startRotation < 0f)
{
this._startRotation += 360f;
}
while (this._startRotation >= 360f)
{
this._startRotation -= 360f;
}
while (this._endRotation < 0f)
{
this._endRotation += 360f;
}
while (this._endRotation >= 360f)
{
this._endRotation -= 360f;
}
//if ( this._startRotation >= this._endRotation && this._endRotation - this._startRotation >= 0f )
//{
// this._direction = 1f;
//}
//else
//{
// this._direction = -1f;
//}
this._lerpValue = 0f;
}
/// <summary>
/// 创建投掷物.
/// </summary>
public static ErrorCode createProjectiles(BattleUnit user, uint skillResID, uint projResID, Vector3 targetPosition)
{
ProjectileSettingsTableItem projSettings = DataManager.ProjectileSettingsTable[projResID] as ProjectileSettingsTableItem;
for (uint i = 0; i < ProjectileSettingsTableItem.ProjectileCount; ++i)
{
ProjectileItem item = projSettings.items[i];
if (item.bulletResID == uint.MaxValue)
{
break;
}
BulletTableItem bulletRes = DataManager.BulletTable[item.bulletResID] as BulletTableItem;
// 枪口特效.
if (item.bindpointEffect != uint.MaxValue)
{
SkillClientBehaviour.AddEffect2Object(user, item.bindpointEffect, item.initBindpoint);
}
ProjectileCreateParam param = new ProjectileCreateParam()
{
User = user,
StartPosition = user.GetBonePositionByName(item.initBindpoint),
TargetPosition = targetPosition,
DistributionType = item.distributionType,
DistributionArgument = item.distributionArgument,
BulletRes = bulletRes,
SkillResID = skillResID
};
createProjectiles(param);
}
return(ErrorCode.Succeeded);
}
override public void OnSpriteModelLoaded(uint instanceid)
{
base.OnSpriteModelLoaded(instanceid);
BattleUnit unit = FindObject(instanceid) as BattleUnit;
if (unit == null)
{
return;
}
if (PlayerController.Instance.GetMainCropsControl() == instanceid || PlayerController.Instance.GetSubCropsControl() == instanceid)
{
unit.AddEffect(528, null);
unit.AddSkillEffect(new AttackerAttr(unit), SkillEffectType.Buff, GameConfig.PvpBuffId);
}
else
{
Ghost ghost = unit as Ghost;
if (ghost == null)
{
return;
}
if (ghost.IsMainPlayer())
{
mMainGhost = ghost;
mMainGhost.AddEffect(528, null);
}
else
{
mOtherGhost = ghost;
}
ghost.AddSkillEffect(new AttackerAttr(ghost), SkillEffectType.Buff, GameConfig.PvpBuffId);
}
}
protected virtual void ApplyDefence(BattleUnit unit, DetailedUserCharacteristics characteristics)
{
var chs = unit.Characteristics;
double factor = 1.5; // 150%
switch (DefencePosition)
{
case Position.HEAD:
chs.Armor_head = (int)(characteristics.Armor_head * factor);
break;
case Position.BODY:
chs.Armor_body = (int)(characteristics.Armor_body * factor);
break;
case Position.LEGS:
chs.Armor_belt = (int)(characteristics.Armor_belt * factor);
break;
case Position.FEET:
chs.Armor_feet = (int)(characteristics.Armor_feet * factor);
break;
}
}
void CheckForBattleOver(BattleUnit faintedUnit)
{
if (faintedUnit.IsPlayerUnit)
{
var nextPokemon = playerParty.GetHealthyPokemon();
if (nextPokemon != null)
{
OpenPartyScreen();
}
else
{
BattleOver(false);
}
}
else
{
if (!isTrainerBattle)
{
BattleOver(true);
}
else
{
var nextPokemon = trainerParty.GetHealthyPokemon();
if (nextPokemon != null)
{
//state = BattleState.Busy;
StartCoroutine(SendNextTrainerPokemon(nextPokemon));
//ActionSelection();
}
else
{
BattleOver(true);
}
}
}
}
public void ShowUnitInfoWnd(BattleUnit unit)
{
if (unitInfoWnd == null)
{
unitInfoWnd = GameObject.Instantiate(Resources.Load("Prefabs/UIPrefabs/UnitInfoWnd") as GameObject);
unitInfoWnd.transform.SetParent(UIRoot.transform);
unitInfoWnd.GetComponent <RectTransform>().offsetMin = new Vector2(0, 0);
unitInfoWnd.GetComponent <RectTransform>().offsetMax = new Vector2(0, 0);
}
else
{
unitInfoWnd.gameObject.SetActive(true);
}
unitInfoWnd.transform.Find("name").GetComponent <Text>().text = unit.battleUnitProperty.name;
//unitInfoWnd.transform.Find("icon").GetComponent<Image>().sprite = (Sprite)Resources.LoadAll(unit.battleUnitProperty.iconPath)[2];
unitInfoWnd.transform.Find("icon").GetComponent <Image>().sprite = AtlasManage.instance.LoadAtlasSprite(unit.battleUnitProperty.atlasPath, unit.battleUnitProperty.iconName);
unitInfoWnd.transform.Find("pro").transform.Find("UnitHUD").GetComponent <Slider>().value = unit.battleUnitProperty.nowHP / (unit.battleUnitProperty.unitHP * 1.0f);
unitInfoWnd.transform.Find("pro").transform.Find("HP").GetComponent <Text>().text = "HP: " + unit.battleUnitProperty.nowHP + "/" + unit.battleUnitProperty.unitHP;
unitInfoWnd.transform.Find("pro").transform.Find("Attack").GetComponent <Text>().text = "攻击: " + unit.battleUnitProperty.attack;
unitInfoWnd.transform.Find("pro").transform.Find("Defence").GetComponent <Text>().text = "防御: " + unit.battleUnitProperty.defence;
unitInfoWnd.transform.Find("pro").transform.Find("AttackDis").GetComponent <Text>().text = "射程: " + unit.battleUnitProperty.attackDistance;
unitInfoWnd.transform.Find("pro").transform.Find("ActionPower").GetComponent <Text>().text = "移动距离: " + unit.battleUnitProperty.actionPower;
}
/*
* IEnumerator RunMove_OLD(BattleUnit sourceUnit, BattleUnit targetUnit, Move move)
* {
* bool canRunMove = sourceUnit.Pokemon.OnBeforeMove();
* if (!canRunMove)
* {
* yield return ShowStatusChanges(sourceUnit.Pokemon);
* yield return sourceUnit.Hud.UpdateHP();
* yield break;
* }
* yield return ShowStatusChanges(sourceUnit.Pokemon);
*
* move.PP--;
* yield return dialogBox.TypeDialog($"{sourceUnit.Pokemon.Base.Name} used { move.Base.Name}");
*
* if (CheckIfMoveHits(move, sourceUnit.Pokemon, targetUnit.Pokemon))
* {
* sourceUnit.PlayAttackAnimation();
* yield return new WaitForSeconds(Settings.animationDuration);
*
* targetUnit.PlayHitAnimation();
*
* if (move.Base.Category == MoveCategory.Status)
* {
* yield return RunMoveEffects(move.Base.Effects, sourceUnit.Pokemon, targetUnit.Pokemon, move.Base.Target);
* }
* else
* {
* var damageDetails = targetUnit.Pokemon.TakeDamage(move, sourceUnit.Pokemon);
* yield return targetUnit.Hud.UpdateHP();
* yield return ShowDamageDetails(damageDetails);
* }
*
* if (move.Base.SecondaryEffects != null && move.Base.SecondaryEffects.Count > 0 && targetUnit.Pokemon.CurrentHP > 0)
* {
* foreach (var secondary in move.Base.SecondaryEffects)
* {
* var rnd = UnityEngine.Random.Range(1, 101);
* if (rnd <= secondary.Chance)
* {
* yield return RunMoveEffects(secondary, sourceUnit.Pokemon, targetUnit.Pokemon, secondary.Target);
* }
*
* }
* }
*
* if (targetUnit.Pokemon.CurrentHP <= 0) //si el target muere
* {
* yield return dialogBox.TypeDialog($"{targetUnit.Pokemon.Base.name} fainted");
*
* targetUnit.PlayFaintAnimation();
*
* yield return new WaitForSeconds(Settings.pauseDuration);
* yield return CheckForBattleOver(targetUnit);
* }
*
* }
* else
* {
* yield return dialogBox.TypeDialog($"{sourceUnit.Pokemon.Base.name}'s attack missed");
* }
* }
*/
/*
* Metodo encargado de gestionar todos los eventos que ocurren al finalizar un turno o movimiento como por ejemplo los efectos de algunos estados alterados
*/
IEnumerator RunAfterTurn(BattleUnit sourceUnit)
{
if (state == BattleState.BattleOver)
{
yield break;
}
//Con esto esperamos a que el efecto secundario del ataque no haga efecto hasta que (en caso de haber matado al enemigo) salga el nuevo pokemon (cosa que en los juegos actuales no es asi creo recordar)
yield return(new WaitUntil(() => state == BattleState.RunningTurn));
sourceUnit.Pokemon.OnAfterTurn();
yield return(ShowStatusChanges(sourceUnit.Pokemon));
yield return(sourceUnit.Hud.UpdateHP());//actualizamos el hud por si se reduce la HP del pokemon
//comprobamos si muere por el estado alterado:
if (sourceUnit.Pokemon.CurrentHP <= 0)
{
yield return(dialogBox.TypeDialog($"{sourceUnit.Pokemon.Base.name} fainted"));
sourceUnit.PlayFaintAnimation();
yield return(new WaitForSeconds(Settings.pauseDuration));
}
}
void CheckForBattleOver(BattleUnit deadUnit)
{
if (deadUnit.IsPlayerUnit)
{
//sets up next unit in party
var nextPiece = playerParty.GetHealthyPiece();
if (nextPiece != null)
{
OpenPartyUI();
}
else
{
BattleOver(false);
}
}
else
{
if (!isEnemyBattle)
{
BattleOver(true);
}
else
{
var nextPiece = enemyParty.GetHealthyPiece();
if (nextPiece != null)
{
StartCoroutine(AboutToUse(nextPiece));
}
else
{
BattleOver(true);
}
}
}
}
private void HandleMonsterFainted(BattleUnit faintedUnit)
{
if (faintedUnit.IsPlayerUnit)
{
Monster nextMonster = playerParty.GetHealthyMonster();
if (nextMonster != null)
{
OpenPartyScreen(true);
}
else
{
BattleOver(false);
}
}
else
{
if (!isTamerBattle)
{
wildMonster.Defeated();
BattleOver(true);
}
else
{
Monster nextMonster = enemyTamerParty.GetHealthyMonster();
if (nextMonster != null)
{
// Send out next monster
StartCoroutine(AboutToSummon(nextMonster));
}
else
{
BattleOver(true);
}
}
}
}
private void SpawnerOnSpawned(BattleUnit unit)
{
if (!unit.IsLocalPlayer)
{
return;
}
if (_isLocalPlayerSpawned)
{
Debug.LogError($"Some local player already spawned!");
return;
}
if (_lastLocalPlayer != null)
{
_lastLocalPlayer.HittableObject.OnDied -= HittableObjectOnDied;
}
unit.HittableObject.OnDied += HittableObjectOnDied;
_lastLocalPlayer = unit;
unit.PlayerCamera = _playerCamera;
foreach (var ownerable in _localOwnerable)
{
ownerable.InitOwner(unit);
}
foreach (var teamChangerListener in _teamChangerListeners)
{
teamChangerListener.UpdateTeamChanger(unit.TeamController);
}
_isLocalPlayerSpawned = true;
GameHelper.SetActiveCursor(false, true);
}
// called repeatedly by the battle while ai units still have moves left
public IEnumerator PlayNextAIActionRoutine()
{
BattleUnit actor = battle.GetFaction(Alignment.Enemy).NextMoveableUnit();
yield return(actor.ActionStartRoutine());
if (actor.IsDead())
{
yield break;
}
// TODO: AI
Spell spell = RandomUtils.RandomItem(battle.r, actor.unit.spells);
IntentSpell intent = new IntentSpell(battle, actor, spell);
intent.AcquireAITargets();
yield return(intent.ResolveRoutine());
yield return(actor.ActionEndRoutine());
actor.MarkActionTaken();
yield return(null);
}
private void ChangeNumberOfUnits(int numberOfUnits, BattleUnit battleUnit)
{
if (battleUnitsDictionary.ContainsKey(battleUnit) == true)
{
print("key not found" + " count of battle unit " + battleUnitsDictionary[battleUnit]);
battleUnitsDictionary[battleUnit] += numberOfUnits;
}
else
{
battleUnitsDictionary.Add(battleUnit, numberOfUnits);
}
_unitsOnBase = UnitsOnBase; // TODO wrong logic
if (_unitsOnBase < 0)
{
_unitsOnBase = 0;
}
if (OnNumberOfUnitsChange != null)
{
OnNumberOfUnitsChange(this, EventArgs.Empty);
}
}
public static UInt16 CheckCoverAbility(UInt16 tar_id)
{
BattleUnit coverBy = null;
BattleUnit targetUnit = btl_scrp.FindBattleUnit(tar_id);
if (targetUnit.IsUnderStatus(BattleStatus.Death | BattleStatus.Petrify))
{
return(0);
}
if (targetUnit.HasCategory(CharacterCategory.Female) && targetUnit.CurrentHp < (targetUnit.MaximumHp >> 1))
{
coverBy = FindStrongestDefender(SupportAbility2.ProtectGirls, targetUnit);
}
if (coverBy == null && targetUnit.IsUnderStatus(BattleStatus.LowHP))
{
coverBy = FindStrongestDefender(SupportAbility2.Cover, targetUnit);
}
if (coverBy == null)
{
return(0);
}
coverBy.FaceTheEnemy();
coverBy.Data.pos[0] = targetUnit.Data.pos[0];
coverBy.Data.pos[2] = targetUnit.Data.pos[2];
targetUnit.Data.pos[2] -= 400f;
btl_mot.setMotion(coverBy.Data, 15);
coverBy.IsCovered = true;
return(coverBy.Id);
}
public List <BattleUnit> FindTargetUnitsByManualSelect(BattleUnit caster, Ability ability,
float dragWorldPointX = -1, float dragWorldPointZ = -1)
{
List <BattleUnit> targets = new List <BattleUnit>();
var castRange = ability.GetCastRange();
if (castRange <= 0)
{
targets.Add(caster);
return(targets);
}
// 单个敌人
var abilityRange = ability.GetAbilityRange();
if (abilityRange.isSingleTarget)
{
var unit = FindNearestEnemyUnit(caster);
targets.Add(unit);
return(targets);
}
return(null);
}
private void LookForEnemy()
{
float closestDistance = Mathf.Infinity;
foreach (var aliveUnit in _unitsHolder.AliveUnitsBuffer)
{
if (aliveUnit == null)
{
continue;
}
if (aliveUnit.TeamController.IsTeammate(_battleUnit))
{
continue;
}
var distance = Vector3.Distance(transform.position, aliveUnit.transform.position);
if (distance < closestDistance)
{
closestDistance = distance;
_closestEnemy = aliveUnit;
}
}
}
public void Init()
{
m_DrawTool = GameObject.Find("MoveArea").GetComponent <DebugController>();
m_UnitMgr = BattleUnitManager.instance;
m_ActorMgr = BattleActorManager.instance;
//AddPlayer();
BattleUnit myEntity = m_UnitMgr.playerUnit;
m_playerActor = new HeroActor(myEntity);
m_playerActor.LoadAsset(OnLoadPlayer);
//AddEnemy();
var entyties = m_UnitMgr.GetEntities(BattleCamp.ENEMY);
foreach (BattleUnit unit in entyties)
{
HeroActor actor = new HeroActor(unit);
actor.LoadAsset(OnLoadGuard);
m_ActorMgr.AddActor(unit.hash, actor);
// 绘制移动区域
m_DrawTool.DrawMoveArea(unit.GetStartPoint(), unit.GetViewRange());
}
}
public void GetBattleRenderHtml_CallsBattleRenderAndUnitDetails()
{
//arrange
var nextUnit = new BattleUnit();
var target = new BattleUnit {
Name = "Target"
};
mocker.GetMock <IBattleRender>().Setup(x => x.RenderHtml(It.IsAny <Battle>(), It.IsAny <BattleUnit>(), It.IsAny <BattleUnit>())).Returns("Howdy");
mocker.GetMock <INextUnitFinder>().Setup(x => x.GetNextBattleUnit(It.IsAny <Battle>())).Returns(nextUnit);
mocker.GetMock <INextUnitFinder>().Setup(x => x.IsNextUnitPlayerControlled(It.IsAny <Battle>())).Returns(true);
mocker.GetMock <IBattleUnitRender>().Setup(x => x.RenderDetailsHtml(nextUnit)).Returns("Apple");
mocker.GetMock <IBattleUnitRender>().Setup(x => x.RenderDetailsHtml(target)).Returns("Banana");
mocker.GetMock <IBattleRender>().Setup(x => x.RenderBattleOrderHtml(It.IsAny <Battle>())).Returns("BATTLE+ORDER");
classUnderTest.CurrentBattle.Team1.Units.Add(target);
classUnderTest.StartBattle();
classUnderTest.SetSelectedBattleActionTarget("Target");
//act
var result = classUnderTest.GetBattleRenderHtml();
//assert
result.Should().Be("Howdy<h2>Current Unit:</h2>Apple<h2>Action:</h2><p></p><h2>Target:</h2>Banana<h2>Battle Order:</h2>BATTLE+ORDER");
}
private List <BattleUnit> FindTargetUnits(BattleUnit caster, MultipleTargetsTeam targetTeam, MultipleTargetsType targetDemageType)
{
List <BattleUnit> targets = new List <BattleUnit>(0);
// 根据阵营找对象
BattleCamp sourceCamp = caster.camp;
if (targetTeam == MultipleTargetsTeam.UNIT_TARGET_TEAM_FRIENDLY)
{
targetTeam = sourceCamp == BattleCamp.FRIENDLY ? MultipleTargetsTeam.UNIT_TARGET_TEAM_FRIENDLY : MultipleTargetsTeam.UNIT_TARGET_TEAM_ENEMY;
}
else if (targetTeam == MultipleTargetsTeam.UNIT_TARGET_TEAM_ENEMY)
{
targetTeam = sourceCamp == BattleCamp.FRIENDLY ? MultipleTargetsTeam.UNIT_TARGET_TEAM_ENEMY : MultipleTargetsTeam.UNIT_TARGET_TEAM_FRIENDLY;
}
switch (targetTeam)
{
case MultipleTargetsTeam.UNIT_TARGET_TEAM_ENEMY:
InsertToTargetList(BattleUnitManager.instance.GetEntities(BattleCamp.ENEMY), targets);
break;
case MultipleTargetsTeam.UNIT_TARGET_TEAM_FRIENDLY:
InsertToTargetList(BattleUnitManager.instance.GetEntities(BattleCamp.FRIENDLY), targets);
break;
case MultipleTargetsTeam.UNIT_TARGET_TEAM_BOTH:
InsertToTargetList(BattleUnitManager.instance.GetEntities(BattleCamp.ENEMY), targets);
InsertToTargetList(BattleUnitManager.instance.GetEntities(BattleCamp.FRIENDLY), targets);
break;
default:
break;
}
return(targets);
}
public void InitOwner(BattleUnit owner)
{
this.Owner = owner;
}
public Buff AttachBuff(BattleUnit buffOwner, string buffID, int stack = 1, Buff refBuff = null)
{
//버프 아이디 없거나, 정의되지 않았으면 버프 적용 안 함
if (string.IsNullOrEmpty(buffID) || !GameDataManager.buffBaseDataDic.ContainsKey(buffID))
{
Debug.LogWarning("[BuffManager]Invalid buff id : " + buffID);
return(null);
}
BuffBaseData buffBaseData = GameDataManager.buffBaseDataDic[buffID];
if (buffBaseData == null)
{
return(null);
}
//---------------------------------------------------------
//이미 적용 중인 버프일 경우
Buff buff = null;
if (buffBaseData.isUnique)
{
buff = buffList.Find(x => x.id == buffID && x.target == owner);
}
else
{
buff = buffList.Find(x => x.id == buffID && x.target == owner && x.owner == buffOwner);
}
if (buff == null)
{
buff = GetBuffFromPool(buffID);
}
if (buff == null)
{
return(null);
}
// maxStack일 경우 더 이상 접근하지 않는다.
if (buff.baseData != null && buff.stack == buff.baseData.maxStackCount)
{
return(null);
}
//Debug.Log("버프 적용 : " + buffOwner.heroData.heroName + " / " + buffID);
//버프 적용 or 갱신
buff.Init(buffOwner, owner, buffID, stack, refBuff);
//if(buff.baseData.id.Equals("Buff_Vampire_Passive3"))
//{
// if (owner.skillList.Find(x => x.skillData.id == "Skill_Vampire_NormalAttack"))
// {
// owner.skillList.Find(x => x.skillData.id == "Skill_Vampire_NormalAttack").skillData.maxTargetCount = 3;
// }
//}
if (buffList.Count > 0 && owner.buffController.buffList.Find(x => x.baseData.effect == "ImmuneCC") != null && (buff.baseData.blockMove || buff.baseData.blockAttack || buff.baseData.airborne))
{
if (owner.onHit != null)
{
owner.onHit(0d, "ImmuneDamage");
}
return(null);
}
//버프 적용될 때 효과
if (buff.attachBehavior != null)
{
buff.attachBehavior.ApplyEffect();
}
//지속시간 적용
if (buff.baseData.duration > 0f)
{
if (buff.coroutineDuration != null)
{
StopCoroutine(buff.coroutineDuration);
buff.coroutineDuration = null;
}
buff.coroutineDuration = StartCoroutine(ApplyDuration(buff));
}
//이동 불가, 공격 불가
if (buff.baseData.blockMove)
{
owner.isBlockMove = true;
}
if (buff.baseData.blockAttack)
{
owner.isBlockAttack = true;
}
//공중에 뜸
if (buff.baseData.airborne)
{
owner.airborne = true;
}
//타게팅 방어 효과
if (buff.baseData.notTargeting)
{
owner.notTargeting = true;
}
return(buff);
}
public virtual void Init(BattleUnit unit)
{
_unit = unit;
}
public virtual int CalculationOfInjury(BattleUnit attacker)
{
return(0);
}
public void OnInit(int id, BattleUnit owner)
{
mOwner = null;
mTable = SkillTableManager.instance.Find((uint)id);
CurTime = 0f;
Casting = false;
}
public HeroStateController(BattleUnit source, AnimationController animController)
{
//m_BattleEntity = source;
m_AnimController = animController;
}
bool _CheckTarget(BattleUnit unit)
{
if (unit == null)
return false;
if (unit.Dead)
return false;
// to do.
return true;
}
public UnitStateBase(BattleUnit unit)
{
mUnit = unit;
}
void _Reset()
{
mTable = null;
mOwner = null;
_ClearAtkDef();
Casting = false;
CastEndCallback = null;
CurTime = 0f;
mIsCrit = false;
mAtkDefIndex = 0;
HitedUnits.Clear();
}
public void OnHited(BattleUnit attacker, AttackDefinition attackData)
{
}
public void ChangeState(BattleUnit.EState type)
{
UnitStateMechine.SetActiveState((int)type);
}
private void UpdateUI()
{
// Update targetUnit and targetTile
hoverUnit = battle.GetUnit(transform.position);
targetTile = battle.GetTile(transform.position);
// Update UI for targetUnit
// UI: Unit Panel L
Animator uplAnim = unitPanelL.GetComponent <Animator>();
AnimatorStateInfo uplAnimState = uplAnim.GetCurrentAnimatorStateInfo(0);
// Update targetUnit
if (hoverUnit != targetUnit)
{
if (uplAnimState.IsName("SlideIn"))
{
// targetUnit = null;
float animTime = Mathf.Max(1f - uplAnimState.normalizedTime, 0f);
uplAnim.Play("SlideOut", -1, animTime);
}
if (uplAnimState.IsName("SlideOut") && uplAnimState.normalizedTime > 1f)
{
targetUnit = hoverUnit;
}
}
// When targetUnit is updated
if (hoverUnit == targetUnit)
{
bool showPanel = targetUnit != null && battle.ShowPanel();
if (showPanel && uplAnimState.IsName("SlideOut") && uplAnimState.normalizedTime > 1f)
{
targetUnit.unit.SetPanelUI(unitPanelL);
uplAnim.Play("SlideIn");
}
if (!showPanel && uplAnimState.IsName("SlideIn") && uplAnimState.normalizedTime > 1f)
{
targetUnit.unit.SetPanelUI(unitPanelL);
uplAnim.Play("SlideOut");
}
}
// UI: Unit Commands Menu
Animator ucmAnim = unitCommandsMenu.GetComponent <Animator>();
AnimatorStateInfo ucmAnimState = ucmAnim.GetCurrentAnimatorStateInfo(0);
if (!onUnitCommands && ucmAnimState.IsName("SlideIn"))
{
float animTime = Mathf.Max(1f - ucmAnimState.normalizedTime, 0f);
ucmAnim.Play("SlideOut", -1, animTime);
}
if (onUnitCommands && targetUnit == battle.currentUnit && ucmAnimState.IsName("SlideOut") && ucmAnimState.normalizedTime > 1f)
{
unitCommandsMenu.transform.Find("BackImage/MoveButton").gameObject.GetComponent <Button>().interactable = targetUnit.unit.apCur > 0;
unitCommandsMenu.transform.Find("BackImage/ActButton").gameObject.GetComponent <Button>().interactable = targetUnit.unit.apCur > 0;
unitCommandsMenu.transform.Find("BackImage/APImage/Text").gameObject.GetComponent <Text>().text = targetUnit.unit.apCur.ToString();
Color apColor = new Color(1f, 1f, 1f);
if (targetUnit.unit.apCur == 1)
{
apColor = new Color(1f, 196f / 256f, 0f);
}
if (targetUnit.unit.apCur == 0)
{
apColor = new Color(0.5f, 0.15f, 0.15f);
}
unitCommandsMenu.transform.Find("BackImage/APImage/Text").gameObject.GetComponent <Text>().color = apColor;
ucmAnim.Play("SlideIn");
}
// UI: Unit Wait
Animator uwAnim = unitWait.GetComponent <Animator>();
AnimatorStateInfo uwAnimState = uwAnim.GetCurrentAnimatorStateInfo(0);
if (!onUnitWait && uwAnimState.IsName("SlideIn"))
{
float animTime = Mathf.Max(1f - uwAnimState.normalizedTime, 0f);
uwAnim.Play("SlideOut", -1, animTime);
}
if (onUnitWait && targetUnit == battle.currentUnit && uwAnimState.IsName("SlideOut") && uwAnimState.normalizedTime > 1f)
{
uwAnim.Play("SlideIn");
}
// UI: Unit Look Status Key
Animator uskAnim = unitStatusKey.GetComponent <Animator>();
AnimatorStateInfo uskAnimState = uskAnim.GetCurrentAnimatorStateInfo(0);
if (!(onUnitLook && targetUnit != null) && uskAnimState.IsName("SlideIn"))
{
float animTime = Mathf.Max(1f - uskAnimState.normalizedTime, 0f);
uskAnim.Play("SlideOut", -1, animTime);
}
if ((onUnitLook && targetUnit != null) && uskAnimState.IsName("SlideOut") && uskAnimState.normalizedTime > 1f)
{
uskAnim.Play("SlideIn");
}
// UI: Cancel key
Animator uckAnim = unitCancelKey.GetComponent <Animator>();
AnimatorStateInfo uckAnimState = uckAnim.GetCurrentAnimatorStateInfo(0);
if (!(onUnitLook || onStatusScreen || onUnitMove || onUnitAction) && uckAnimState.IsName("SlideIn"))
{
float animTime = Mathf.Max(1f - uckAnimState.normalizedTime, 0f);
uckAnim.Play("SlideOut", -1, animTime);
}
if ((onUnitLook || onStatusScreen || onUnitMove || onUnitAction) && uckAnimState.IsName("SlideOut") && uckAnimState.normalizedTime > 1f)
{
uckAnim.Play("SlideIn");
}
// UI: Unit Move Key
Animator umkAnim = unitMoveKey.GetComponent <Animator>();
AnimatorStateInfo umkAnimState = umkAnim.GetCurrentAnimatorStateInfo(0);
if (!(onUnitMove && targetTiles.Contains(targetTile)) && umkAnimState.IsName("SlideIn"))
{
float animTime = Mathf.Max(1f - umkAnimState.normalizedTime, 0f);
umkAnim.Play("SlideOut", -1, animTime);
}
if ((onUnitMove && targetTiles.Contains(targetTile)) && umkAnimState.IsName("SlideOut") && umkAnimState.normalizedTime > 1f)
{
umkAnim.Play("SlideIn");
}
// UI: Unit Action Key
Animator uakAnim = unitActionKey.GetComponent <Animator>();
AnimatorStateInfo uakAnimState = uakAnim.GetCurrentAnimatorStateInfo(0);
bool canConfirmAction = (onUnitAction && (currentAction.GetActionType() == ActionType.Fixed ||
(currentAction.GetActionType() == ActionType.Targeted && targetTiles.Contains(targetTile))));
if (!canConfirmAction && uakAnimState.IsName("SlideIn"))
{
float animTime = Mathf.Max(1f - uakAnimState.normalizedTime, 0f);
uakAnim.Play("SlideOut", -1, animTime);
}
if (canConfirmAction && uakAnimState.IsName("SlideOut") && uakAnimState.normalizedTime > 1f)
{
uakAnim.Play("SlideIn");
}
// UI: Unit Status Screen
Animator usAnim = unitStatus.GetComponent <Animator>();
AnimatorStateInfo usAnimState = usAnim.GetCurrentAnimatorStateInfo(0);
if (!onStatusScreen && usAnimState.IsName("SlideIn"))
{
float animTime = Mathf.Max(1f - usAnimState.normalizedTime, 0f);
usAnim.Play("SlideOut", -1, animTime);
}
if (onStatusScreen && usAnimState.IsName("SlideOut") && usAnimState.normalizedTime > 1f)
{
hoverUnit.unit.SetStatusUI(unitStatus);
usAnim.Play("SlideIn");
}
// UI: Unit Action Menu
Animator uaAnim = unitActions.GetComponent <Animator>();
AnimatorStateInfo uaAnimState = uaAnim.GetCurrentAnimatorStateInfo(0);
if (!onUnitActions && uaAnimState.IsName("SlideIn"))
{
float animTime = Mathf.Max(1f - uaAnimState.normalizedTime, 0f);
uaAnim.Play("SlideOut", -1, animTime);
}
if (onUnitActions && uaAnimState.IsName("SlideOut") && uaAnimState.normalizedTime > 1f)
{
foreach (Transform action in unitActionsContent)
{
Destroy(action.gameObject);
}
foreach (Action action in targetUnit.unit.actions)
{
GameObject go = Instantiate(unitActionPrefab, unitActionsContent);
go.GetComponent <Text>().text = action.GetName();
go.GetComponent <Button>().onClick.AddListener(() => OnAction(action));
}
uaAnim.Play("SlideIn");
}
// UI: End Screen
endScreenWin.SetActive(onEndWin);
endScreenLose.SetActive(onEndLose);
}
public static bool CalcCrit(BattleUnit unit)
{
return Random.Range(0f, 1f) <= 0.2f;
}
