public void Dead(int uniqId)
{
var sprite = GetSprite(uniqId);
if (BattleDictionary.IsActor(uniqId))
{
sprite.SpriteRenderer.material.EnableKeyword(ShaderProperties.GREYSCALE_ON);
}
else
{
sprite.SpriteRenderer.material.DisableKeyword(ShaderProperties.SHADOW_ON);
sprite.SpriteRenderer.material.EnableKeyword(ShaderProperties.FADE_ON);
sprite.Ui.HpBar.gameObject.SetActive(false);
float fade = 0f;
DOTween.To(() => fade,
(x) => fade = x, 1f, 0.8f).Play().OnUpdate(() =>
{
sprite.SpriteRenderer.GetPropertyBlock(sprite.MaterialPropertyBlock);
sprite.MaterialPropertyBlock.SetFloat(ShaderProperties.FadeAmount, fade);
sprite.SpriteRenderer.SetPropertyBlock(sprite.MaterialPropertyBlock);
}).OnComplete(
() =>
{
sprite.SpriteRenderer.enabled = false;
});
}
}
private GameObject CreateCard(TimelineSerializableData item)
{
GameObject turnCard;
if (BattleDictionary.IsActor(item.uniqId))
{
turnCard = Object.Instantiate((GameObject)Resources.Load("Prefabs/Battle/TurnCard"),
Vector3.zero, Quaternion.identity, GameObject.Find("Timeline/TurnCards").transform);
}
else
{
turnCard = Object.Instantiate((GameObject)Resources.Load("Prefabs/Battle/EnemyTurnCard"),
Vector3.zero, Quaternion.identity, GameObject.Find("Timeline/TurnCards").transform);
}
GameObject battlerImage = turnCard.transform.Find("Mask/BattlerImage").gameObject;
string monsterId = BattlerDictionary.GetBattlerByUniqId(item.uniqId).monsterId;
MonsterSerializable monster = MonsterDicionary.GetMonsterData(monsterId);
var sprite = Resources.Load <Sprite>(monster.imageData.spritePath);
//Sprite sprite = AssetDatabase.LoadAssetAtPath<Sprite>(monster.imageData.spritePath);
var image = battlerImage.GetComponent <Image>();
image.sprite = sprite;
battlerImage.GetComponent <RectTransform>().sizeDelta =
new Vector3(sprite.rect.width, sprite.rect.height);
battlerImage.GetComponent <RectTransform>().localPosition = new Vector3(monster.imageData.timelineCard.x,
monster.imageData.timelineCard.y, 0);
battlerImage.GetComponent <RectTransform>().localScale =
new Vector3(monster.imageData.timelineCard.scaleX, monster.imageData.timelineCard.scaleY, 0);
_turnCards.Add(new TimelineViewStruct()
{
Card = turnCard,
Id = item.id
});
return(turnCard);
}
public static AsyncSubject <Unit> SkillByAi(AiSelectSkillResultSerializableData ai, BattlerSerializable fromBattler)
{
AsyncSubject <Unit> subject = new AsyncSubject <Unit>();
if (ai == null)
{
ObservableUtils.AsyncSubjectTimeZeroCompleted(subject);
}
else
{
var skill = SkillsDicionary.GetSkillById(ai.SkillId);
if (SkillsDicionary.IsAll(skill))
{
List <BattlerSerializable> toBattlers = new List <BattlerSerializable>();
ai.TargetUniqIds.ForEach(x => { toBattlers.Add(BattlerDictionary.GetBattlerByUniqId(x)); });
SkillToAll(ai.SkillId, fromBattler, toBattlers).Subscribe(_ =>
{
subject.OnNext(Unit.Default);
subject.OnCompleted();
});
}
else
{
var uniqId = ai.TargetUniqIds.First();
var toBattler = BattlerDictionary.GetBattlerByUniqId(uniqId);
var targetTransform = BattleDictionary.GetTransformByUniqId(uniqId);
SkillToSingle(ai.SkillId, fromBattler, toBattler).Subscribe(_ =>
{
subject.OnNext(Unit.Default);
subject.OnCompleted();
});
}
}
return(subject);
}
public void EffectPlay(int targetUniqId)
{
Instantiate(effectPrefab, BattleDictionary.GetTransformByUniqId(targetUniqId).localPosition,
gameObject.transform.rotation);
PlaySound();
//TODO
ObservableUtils.Timer(400).Subscribe(_ => { Destroy(gameObject); });
}
private void BattlerSpriteSubscribe()
{
List <int> uniqIds = EnemyDataModel.Instance.UniqIds();
uniqIds.AddRange(MemberDataModel.Instance.UniqIds());
uniqIds.ForEach(uniqId =>
{
//アクティブ時
_container.Add(_battlerSpriteModel.GetData(uniqId).Active.Subscribe(isActive =>
{
if (isActive)
{
AnnounceTextView.Instance.TurnStartText(uniqId);
_battlerSpriteView.DeActiveOutline();
_battlerSpriteView.OnActiveOutline(uniqId);
//メンバーの場合
if (BattleDictionary.IsActor(uniqId))
{
_battleModel.ActiveUniqId = uniqId;
_skillsView.SkillView(uniqId);
}
//敵の場合
else
{
_skillsView.SkillHide();
_battleManager.AiAction(uniqId);
}
}
else
{
_battlerSpriteView.DeActiveOutline();
_skillsView.SkillHide();
}
}));
//HPに変動があった時
_container.Add(_battlerSpriteModel.GetData(uniqId).Hp.Subscribe(value =>
{
_battlerSpriteView.HpBarRefresh(uniqId);
}));
//死んだ時
_container.Add(_battlerSpriteModel.GetData(uniqId).Dead.Subscribe(isDead =>
{
if (isDead)
{
_battlerSpriteView.Dead(uniqId);
BattleLogic.Dead(BattlerDictionary.GetBattlerByUniqId(uniqId));
//PlaySe.GetInstance().Play("SE/Miscs/MonsterDie");
}
}));
//状態異常にかかった時
_container.Add(_battlerSpriteModel.GetData(uniqId).Status.Subscribe(_ =>
{
_battlerSpriteView.StatusIconRefresh(uniqId);
}));
});
}
public void Initialize(TimeLine timeline)
{
List <TimelineSerializableData> timelineData = timeline.TimelineData;
List <int> schedule = timeline.TimelineSchedule;
for (int v = 0; v < SCHEDULE_SIZE; v++)
{
var item = BattleDictionary.GetTimelineById(timelineData, schedule[v]);
AddCard(item);
}
}
/// <summary>
/// ランダムの対象にスキル発動
/// </summary>
/// <param name="skillId"></param>
/// <param name="fromBattler"></param>
/// <param name="uniqIds"></param>
/// <returns></returns>
public static AsyncSubject <Unit> SkillToRandom(string skillId, BattlerSerializable fromBattler,
List <int> uniqIds)
{
AsyncSubject <Unit> subject = new AsyncSubject <Unit>();
List <SkillDamages> damageses = new List <SkillDamages>();
var skill = SkillsDicionary.GetSkillById(skillId);
var strikeSize = 1;
if (skill.strikeSize.min != 0 && skill.strikeSize.max != 0)
{
strikeSize = Random.Range(skill.strikeSize.min, skill.strikeSize.max);
}
List <BattlerSerializable> toBattlers = new List <BattlerSerializable>();
uniqIds.ForEach(uniqId =>
{
toBattlers.Add(BattlerDictionary.GetBattlerByUniqId(uniqId));
});
for (int i = 0; i < strikeSize; i++)
{
var toBattler = BattleDictionary.GetAliveBattlerByRandom(toBattlers);
if (toBattler == null)
{
break;
}
var isHit = HitCheck(skillId, fromBattler, toBattler);
List <SkillDamage> damages = new List <SkillDamage>();
if (isHit)
{
damages = SkillToBattler(skillId, fromBattler, toBattler);
}
var isDead = DeadCheck(toBattler);
damageses.Add(new SkillDamages
{
SkillDamage = damages,
targetUniqId = toBattler.uniqId,
isHit = isHit,
isDead = isDead
});
}
//ダメージテキストの表示
AnnounceTextView.Instance.AddDamageText(fromBattler, skill.name, damageses);
EffectManager.Instance.SkillToTarget(skillId, damageses).Subscribe(_ =>
{
subject.OnNext(Unit.Default);
subject.OnCompleted();
});
return(subject);
}
private void SkillToSubscribe()
{
_container.Add(_battlerSpriteModel.SelectedSubject.Subscribe(_ =>
{
var skill = SkillsDicionary.GetSkillById(_skillModel.SkillId);
var battler = BattlerDictionary.GetBattlerByUniqId(_battleModel.ActiveUniqId);
switch (skill.target)
{
case SkillConsts.ENEMY:
case SkillConsts.MEMBER:
var uniqId = _battlerSpriteModel.SelectUniqId;
var toBattler = BattlerDictionary.GetBattlerByUniqId(uniqId);
BattleLogic.SkillToSingle(skill.skillId, battler, toBattler)
.Subscribe(
__ => { _battleModel.NextTurn.OnNext(Unit.Default); });
break;
case SkillConsts.ALL_ENEMY:
BattleLogic.SkillToAll(skill.skillId, battler,
BattleDictionary.GetRivalBattlers(battler.battlerType)).Subscribe(__ =>
{
_battleModel.NextTurn.OnNext(Unit.Default);
});
break;
case SkillConsts.ALL_MEMBER:
BattleLogic.SkillToAll(skill.skillId, battler,
BattleDictionary.GetMemberBattlers(battler.battlerType)).Subscribe(__ =>
{
_battleModel.NextTurn.OnNext(Unit.Default);
});
break;
case SkillConsts.RANDOM_ENEMY:
BattleLogic.SkillToRandom(skill.skillId, battler,
BattleDictionary.GetRivalUniqIds(BattlerEnum.BattlerType.Actor)).Subscribe(
__ =>
{
_battleModel.NextTurn.OnNext(Unit.Default);
});
break;
case SkillConsts.RANDOM_MEMBER:
BattleLogic.SkillToRandom(skill.skillId, battler,
BattleDictionary.GetMemberUniqIds(BattlerEnum.BattlerType.Actor)).Subscribe(
__ =>
{
_battleModel.NextTurn.OnNext(Unit.Default);
});
break;
}
}));
}
public static bool AllEnemyDeadCheck()
{
var battlers = BattleDictionary.GetRivalBattlers(BattlerEnum.BattlerType.Actor);
foreach (var battler in battlers)
{
if (DeadCheck(battler) == false)
{
return(false);
}
}
return(true);
}
public AsyncSubject <Unit> PoisonEffect(int uniqId, List <SkillDamages> damageses)
{
var targetTransform = BattleDictionary.GetTransformByUniqId(uniqId);
AsyncSubject <Unit> subject = new AsyncSubject <Unit>();
var poison = Instantiate((GameObject)Resources.Load("Prefabs/Status/Poison"));
var poisonEffect = poison.GetComponent <SkillBehavior>();
poisonEffect.Play(damageses);
poison.transform.localPosition = targetTransform.localPosition;
ObservableUtils.Timer(200).Subscribe(_ =>
{
subject.OnNext(Unit.Default);
subject.OnCompleted();
});
return(subject);
}
/// <summary>
/// タイムラインを次に送る
/// </summary>
public AsyncSubject <Unit> TimelineNext()
{
AsyncSubject <Unit> subject = new AsyncSubject <Unit>();
TimelineCalc();
_timelineSchedule.Remove(_timelineSchedule.First());
var id = TimeLineForward();
_timelineView.DepopSchedule();
_timelineView.AddCard(BattleDictionary.GetTimelineById(_timelineData, id)).Subscribe(_ =>
{
subject.OnNext(Unit.Default);
subject.OnCompleted();
});
return(subject);
}
public void OnActiveOutline(int uniqId)
{
var sprite = GetSprite(uniqId);
var spriteRenderer = sprite.SpriteRenderer;
var materialPropertyBlock = sprite.MaterialPropertyBlock;
spriteRenderer.material.EnableKeyword(ShaderProperties.OUTBASE_ON);
spriteRenderer.GetPropertyBlock(materialPropertyBlock);
if (BattleDictionary.IsActor(sprite.UniqId))
{
materialPropertyBlock.SetColor(ShaderProperties.OutlineColor, Color.yellow);
}
else
{
materialPropertyBlock.SetColor(ShaderProperties.OutlineColor, new Color(1f, 0.2758853f, 0.2f, 1f));
}
spriteRenderer.SetPropertyBlock(materialPropertyBlock);
}
private void SetHighestHp()
{
var hasPreviousHighestHp = BattleDictionary.TryGetValue("HighestHP", out var highestHpObject);
if (hasPreviousHighestHp)
{
var highestHp = (int)highestHpObject;
if (CurrentHp > highestHp)
{
Debug.Log($"{BattlerName} Highest HP: {CurrentHp}");
BattleDictionary["HighestHP"] = CurrentHp;
}
}
else
{
Debug.Log($"{BattlerName} Highest HP: {CurrentHp}");
BattleDictionary["HighestHP"] = CurrentHp;
}
}
public AiSelectSkillResultSerializableData SelectSkill(int uniqId)
{
BattlerSerializable battler = BattlerDictionary.GetBattlerByUniqId(uniqId);
//スキルを無造作に選ぶ、アタックの重みは少ない
var choice = new WeightChoice <string>();
foreach (var x in battler.skills)
{
var _skill = SkillsDicionary.GetSkillById(x);
if (_skill.skillId == SkillIds.ATTACK)
{
choice.Add(SkillWeights.VERY_LOW, x);
}
else if (battler.parameter.mp >= _skill.mp)
{
choice.Add(SkillWeights.NORMAL, x);
}
}
AiSelectSkillResultSerializableData result = new AiSelectSkillResultSerializableData();
var skill = SkillsDicionary.GetSkillById(choice.ChoiceOne());
if (battler.parameter.mp >= skill.mp)
{
switch (skill.target)
{
case SkillConsts.ENEMY:
case SkillConsts.MEMBER:
result.TargetUniqIds.Add(
AiLogic.ChoiceBattlerByHostile(BattleDictionary.GetAliveRivalBattlers(battler.battlerType)));
break;
case SkillConsts.ALL_ENEMY:
case SkillConsts.ALL_MEMBER:
result.TargetUniqIds = BattleDictionary.GetRivalUniqIds(battler.battlerType);
break;
}
result.SkillId = skill.skillId;
}
return(result);
}
/// <summary>
/// 全体にスキル発動
/// </summary>
/// <param name="skillId"></param>
/// <param name="fromBattler"></param>
/// <param name="toBattlers"></param>
/// <returns></returns>
public static AsyncSubject <Unit> SkillToAll(string skillId, BattlerSerializable fromBattler,
List <BattlerSerializable> toBattlers)
{
AsyncSubject <Unit> subject = new AsyncSubject <Unit>();
List <SkillDamages> damageses = new List <SkillDamages>();
var skill = SkillsDicionary.GetSkillById(skillId);
List <Transform> targetTransforms = new List <Transform>();
toBattlers.ForEach(battler =>
{
var targetTransform = BattleDictionary.GetTransformByUniqId(battler.uniqId);
var isHit = HitCheck(skillId, fromBattler, battler);
List <SkillDamage> damages = new List <SkillDamage>();
if (isHit)
{
damages = SkillToBattler(skillId, fromBattler, battler);
}
var isDead = DeadCheck(battler);
damageses.Add(new SkillDamages()
{
SkillDamage = damages,
targetUniqId = battler.uniqId,
isHit = isHit,
isDead = isDead
});
targetTransforms.Add(targetTransform);
});
//ダメージテキストの表示
AnnounceTextView.Instance.AddDamageText(fromBattler, skill.name, damageses);
EffectManager.Instance.SkillToAll(skillId, damageses).Subscribe(_ =>
{
subject.OnNext(Unit.Default);
subject.OnCompleted();
});
return(subject);
}
/// <summary>
/// ターン開始前の処理
/// </summary>
/// <returns></returns>
private SubjectContainer TurnAwake(int activeUniqId)
{
SubjectContainer subjects = new SubjectContainer();
//色々初期化
BattlePresenter.GetInstance().Refresh();
//味方の状態異常処理
BattleDictionary.GetAllAliveBattlers().ForEach(battler =>
{
var results = StatusLogic.StatusUpdate(battler);
if (results.Count != 0)
{
subjects.Add(StatusLogic.StatusEffect(results, battler.uniqId, activeUniqId));
}
DeadCheck(battler);
});
subjects.Add(BattleGuiManager.Instance.Timeline.TimelineScheduleRemove());
return(subjects);
}
/// <summary>
/// ターン開始
/// </summary>
private void TurnStart()
{
_disposableContainer = new IDisposableContainer();
TimelineSerializableData timelineData =
BattleDictionary.GetTimelineById(BattleGuiManager.Instance.Timeline.TimelineData, BattleGuiManager.Instance.Timeline.TimelineSchedule[0]);
TurnAwake(timelineData.uniqId).Play().Subscribe(_ =>
{
ObservableUtils.Timer(300).Subscribe(__ =>
{
//行動不能判定
if (StatusLogic.TurnSkipCheck(timelineData.uniqId))
{
TurnEnd();
}
else
{
//行動開始 アクターなら選択処理 エネミー、ミニオンならAI
BattlePresenter.GetInstance().BattlerSpriteModel.GetData(timelineData.uniqId).Active.OnNext(true);
}
});
});
}
public void Play(List<SkillDamages> damageses)
{
SubjectContainer container = new SubjectContainer();
if (isAll)
{
if (isAllOneEffect)
{
Instantiate(effectPrefab,
BattleDictionary.GetTransformByUniqId(damageses.First().targetUniqId).localPosition,
gameObject.transform.rotation);
}
else
{
damageses.ForEach(damage =>
{
if (BattlerDictionary.IsDead(damage.targetUniqId) == false)
{
Instantiate(effectPrefab,
BattleDictionary.GetTransformByUniqId(damage.targetUniqId).localPosition,
gameObject.transform.rotation);
}
});
}
}
var maxTime = damageses.Count * 300;
foreach (var (x, index) in damageses.Select((x, index) => (x, index)))
{
ObservableUtils.Timer(300 * index).Subscribe(_ =>
{
if (isAll == false)
{
Instantiate(effectPrefab, BattleDictionary.GetTransformByUniqId(damageses.First().targetUniqId).localPosition,
gameObject.transform.rotation);
}
if (x.isHit)
{
HitEffect(x.targetUniqId);
x.SkillDamage.ForEach(damage =>
{
DamagePopup(BattleDictionary.GetTransformByUniqId(damageses.First().targetUniqId), damage, x.targetUniqId);
});
hitSound.ForEach(item =>
{
ObservableUtils.Timer(frame * 100f).Subscribe(__ =>
{
if (item.pitch == 0)
item.pitch = 1;
if (item.volume == 0)
item.volume = 1;
item.volume = item.volume * _volumeRate;
_audioSource.pitch = item.pitch;
_audioSource.volume = item.volume;
_audioSource.PlayOneShot(item.sound);
});
});
}
else
{
DodgePopup(BattleDictionary.GetTransformByUniqId(damageses.First().targetUniqId));
}
});
}
if (maxTime < sound.Count * 100)
maxTime = sound.Count * 100;
PlaySound();
//TODO
ObservableUtils.Timer(maxTime + 100).Subscribe(_ =>
{
Destroy(gameObject);
});
}
/// <summary>
/// バトラー選択時
/// </summary>
private void BattlerSelectSubscribe()
{
_container.Add(BattlerSpriteModel.SkillSelectSubject.Subscribe(_ =>
{
_battlerSpriteView.DeActiveOutline();
}));
//全体選択時
_container.Add(BattlerSpriteModel.AllSelectSubject.Subscribe(_ =>
{
var skill = SkillsDicionary.GetSkillById(_skillModel.SkillId);
BattlerSpriteView.Sprites.ForEach(sprite =>
{
var battler = BattlerDictionary.GetBattlerByUniqId(sprite.UniqId);
if ((skill.target == SkillConsts.ALL_ENEMY || skill.target == SkillConsts.RANDOM_ENEMY) && battler.battlerType == BattlerEnum.BattlerType.Enemy ||
(skill.target == SkillConsts.ALL_MEMBER || skill.target == SkillConsts.RANDOM_MEMBER) && battler.battlerType == BattlerEnum.BattlerType.Actor)
{
_battlerSpriteView.SelectOutline(sprite);
}
});
}));
BattlerSpriteView.Sprites.ForEach(sprite =>
{
//ホバー時
_container.Add(sprite.SpriteObject.OnMouseOverAsObservable().Subscribe(_ =>
{
if (_skillModel.ActiveIndex != -1 && _battlerSpriteModel.HoverUniqId != sprite.UniqId)
{
var skill = SkillsDicionary.GetSkillById(_skillModel.SkillId);
if (SkillsDicionary.IsSingle(skill))
{
_battlerSpriteModel.HoverUniqId = sprite.UniqId;
var targetBattler = BattlerDictionary.GetBattlerByUniqId(sprite.UniqId);
_battlerSpriteView.DeSelectOutlineByBattlerType(targetBattler.battlerType);
if (BattleDictionary.IsAppropriate(skill.skillId, _battleModel.ActiveUniqId, sprite.UniqId))
{
_battlerSpriteView.SelectOutline(sprite);
}
}
}
}));
//ターゲット選択時の処理、選択したスキルが発動する
_container.Add(sprite.SpriteObject.OnMouseUpAsButtonAsObservable().Subscribe(_ =>
{
if (_skillModel.ActiveIndex != -1)
{
_skillsView.SkillHide();
var skill = SkillsDicionary.GetSkillById(_skillModel.SkillId);
if (BattleDictionary.IsAppropriate(skill.skillId, _battleModel.ActiveUniqId, sprite.UniqId))
{
_skillModel.ActiveIndex = -1;
switch (skill.target)
{
case SkillConsts.MEMBER:
case SkillConsts.ENEMY:
_battlerSpriteView.DeSelectOutline(sprite);
_battlerSpriteModel.SelectUniqId = sprite.UniqId;
break;
case SkillConsts.ALL:
case SkillConsts.ALL_ENEMY:
case SkillConsts.ALL_MEMBER:
case SkillConsts.RANDOM_ENEMY:
case SkillConsts.RANDOM_MEMBER:
BattlerSpriteView.Sprites.ForEach(x =>
{
_battlerSpriteView.DeSelectOutline(x);
});
break;
}
_battlerSpriteModel.SelectedSubject.OnNext(Unit.Default);
}
}
}));
});
}
