498 lines
21 KiB
C#
498 lines
21 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using Code.Game.OfficeGame.BattleMode;
|
|
using Code.Game.OfficeGame.Entities;
|
|
using Code.Infrastructure.Camera;
|
|
using Code.Infrastructure.Particles;
|
|
using Code.OfficeGame.BattleMode.Actions;
|
|
using Code.OfficeGame.BattleMode.Actions.AI;
|
|
using Code.OfficeGame.BattleMode.Actions.Deciders;
|
|
using Code.OfficeGame.BattleMode.Health;
|
|
using Code.OfficeGame.BattleMode.HitBoxes;
|
|
using Code.OfficeGame.BattleMode.UI;
|
|
using Cysharp.Threading.Tasks;
|
|
using R3;
|
|
using UnityEngine;
|
|
|
|
namespace Code.OfficeGame.BattleMode.Timeline
|
|
{
|
|
public sealed class BattleTimeline : IDisposable
|
|
{
|
|
public const int TicksPerSecond = BattleSimulator.TicksPerSecond;
|
|
public const float TickDelta = BattleSimulator.FixedTickDelta;
|
|
|
|
public static float PlaybackSpeed { get; set; } = 1f;
|
|
|
|
// Реактивное состояние для UI (ползунок, маркеры, HP-бары)
|
|
private readonly ReactiveProperty<int> _displayFrame = new(0);
|
|
private readonly ReactiveProperty<int> _committedFrame = new(0);
|
|
private readonly ReactiveProperty<int> _maxFrame = new(0);
|
|
private readonly ReactiveProperty<TimelineMode> _mode = new(TimelineMode.Idle);
|
|
private readonly Subject<BattleTimelineTrack> _onTrackRebaked = new();
|
|
private readonly Subject<TimelineEvent> _onRealEvent = new();
|
|
|
|
public ReadOnlyReactiveProperty<int> DisplayFrame => _displayFrame;
|
|
public ReadOnlyReactiveProperty<int> CommittedFrame => _committedFrame;
|
|
public ReadOnlyReactiveProperty<int> MaxFrame => _maxFrame;
|
|
public ReadOnlyReactiveProperty<TimelineMode> Mode => _mode;
|
|
public Observable<BattleTimelineTrack> OnTrackRebaked => _onTrackRebaked;
|
|
public Observable<TimelineEvent> OnRealEvent => _onRealEvent;
|
|
|
|
public BattleTimelineTrack Track { get; } = new();
|
|
|
|
private readonly BattleTimelinePanel _timelinePanel;
|
|
private readonly BattleActionDecisionPanel _decisionPanel;
|
|
private readonly HealthPanelsHolder _healthPanelsHolder;
|
|
private readonly CameraStateMachine _cameraStateMachine;
|
|
private readonly IParticleService _particleService;
|
|
|
|
private readonly Dictionary<BattleActionType, BattleAction> _battleActions;
|
|
private readonly Dictionary<DeciderType, BattleActionDecider> _battleActionDeciders;
|
|
private readonly Dictionary<EnemyDeciderTypes, EnemyDecider> _enemyDeciders;
|
|
private readonly BattleSimulator _simulator;
|
|
|
|
private EntityProperties[] _entities;
|
|
private CancellationTokenSource _previewLoopCts;
|
|
private bool _previewVisualsEnabled;
|
|
|
|
public BattleTimeline(
|
|
BattleTimelinePanel timelinePanel,
|
|
IEnumerable<BattleAction> battleActions,
|
|
IEnumerable<BattleActionDecider> battleActionDeciders,
|
|
IEnumerable<EnemyDecider> enemyDeciders,
|
|
BattleActionDecisionPanel battleActionDecisionPanel,
|
|
HealthPanelsHolder healthPanelsHolder,
|
|
CameraStateMachine cameraStateMachine,
|
|
IParticleService particleService)
|
|
{
|
|
_timelinePanel = timelinePanel;
|
|
_decisionPanel = battleActionDecisionPanel;
|
|
_healthPanelsHolder = healthPanelsHolder;
|
|
_cameraStateMachine = cameraStateMachine;
|
|
_particleService = particleService;
|
|
|
|
_battleActions = battleActions.ToDictionary(x => x.ActionType);
|
|
_battleActionDeciders = battleActionDeciders.ToDictionary(x => x.DeciderType);
|
|
_enemyDeciders = enemyDeciders.ToDictionary(x => x.EnemyDeciderType);
|
|
|
|
_simulator = new BattleSimulator(_battleActions);
|
|
foreach (var action in _battleActions.Values)
|
|
action.SetSimulationContext(_simulator);
|
|
}
|
|
|
|
public int GetSlotIndex(EntityId id) => _simulator.GetSlotIndex(id);
|
|
|
|
// =================== УПРАВЛЕНИЕ ПОЛЗУНКОМ И ПЛЕЕРОМ ===================
|
|
|
|
public void ScrubToFrame(int targetFrame)
|
|
{
|
|
if (_mode.Value == TimelineMode.BattlePlaying || Track.FrameCount == 0)
|
|
return;
|
|
|
|
StopPreviewLoop();
|
|
_mode.Value = TimelineMode.Scrubbing;
|
|
|
|
int clamped = Mathf.Clamp(targetFrame, 0, Track.LastFrame);
|
|
ApplyFrame(clamped, playOneShotVfx: false);
|
|
}
|
|
|
|
public void StepFrame(int delta)
|
|
{
|
|
if (_mode.Value == TimelineMode.BattlePlaying || Track.FrameCount == 0)
|
|
return;
|
|
|
|
ScrubToFrame(_displayFrame.Value + delta);
|
|
}
|
|
|
|
public void TogglePreviewPlayPause()
|
|
{
|
|
if (_mode.Value == TimelineMode.BattlePlaying || Track.FrameCount == 0)
|
|
return;
|
|
|
|
if (_mode.Value == TimelineMode.PreviewPlaying)
|
|
{
|
|
StopPreviewLoop();
|
|
_mode.Value = TimelineMode.Scrubbing;
|
|
}
|
|
else if (Track.LastFrame > _committedFrame.Value)
|
|
{
|
|
StartPreviewLoop(_committedFrame.Value, Track.LastFrame, _battleLoopCt);
|
|
}
|
|
}
|
|
|
|
public void ReturnToCommittedFrame()
|
|
{
|
|
if (_mode.Value == TimelineMode.BattlePlaying || Track.FrameCount == 0)
|
|
return;
|
|
|
|
StopPreviewLoop();
|
|
ApplyFrame(_committedFrame.Value, playOneShotVfx: false);
|
|
_mode.Value = TimelineMode.Deciding;
|
|
}
|
|
|
|
// =================== ОСНОВНОЙ ЦИКЛ БОЯ ===================
|
|
|
|
private CancellationToken _battleLoopCt;
|
|
|
|
public async UniTask RunBattleLoopAsync(List<EntityProperties> entities, CancellationToken ctx)
|
|
{
|
|
_battleLoopCt = ctx;
|
|
_entities = entities.ToArray();
|
|
_simulator.BindEntities(_entities);
|
|
|
|
var initialSlots = new EntityActionSlotSnapshot[_entities.Length];
|
|
for (int i = 0; i < _entities.Length; i++)
|
|
initialSlots[i] = EntityActionSlotSnapshot.CreateNone(0);
|
|
|
|
var frameZero = _simulator.CaptureCurrentFrame(
|
|
frame: 0,
|
|
interruptionStage: 0,
|
|
slots: initialSlots,
|
|
readySlotsMask: 0UL,
|
|
events: Array.Empty<TimelineEvent>(),
|
|
hitboxVisuals: Array.Empty<FrameHitboxVisual>());
|
|
|
|
Track.Initialize(frameZero);
|
|
_committedFrame.Value = 0;
|
|
_displayFrame.Value = 0;
|
|
_maxFrame.Value = 0;
|
|
|
|
using var uiBinding = _timelinePanel.BindTimeline(this);
|
|
using var hpBinding = _healthPanelsHolder.BindToTimeline(this);
|
|
using var vfxSub = _onRealEvent.Subscribe(HandleRealEvent);
|
|
|
|
try
|
|
{
|
|
while (!ctx.IsCancellationRequested)
|
|
{
|
|
var readySlots = Track.GetReadySlotsAt(_committedFrame.Value);
|
|
if (readySlots.Count == 0) break;
|
|
|
|
// 1. Собираем приказы для всех освободившихся бойцов
|
|
await DecideActionsForSlots(readySlots, ctx);
|
|
|
|
// 2. Финально запекаем будущее со всеми утверждёнными приказами (без слепков)
|
|
_previewVisualsEnabled = false;
|
|
HideAllPreviewVisuals();
|
|
RebakeFromCommitted(recordGhosts: false);
|
|
|
|
int nextPauseFrame = Track.FindNextPauseFrame(_committedFrame.Value);
|
|
if (nextPauseFrame <= _committedFrame.Value)
|
|
{
|
|
await UniTask.Yield(PlayerLoopTiming.Update, ctx);
|
|
continue;
|
|
}
|
|
|
|
// 3. Плавно проигрываем готовые кадры до ближайшего прерывания
|
|
await PlayBakedRangeAsync(_committedFrame.Value + 1, nextPauseFrame, ctx);
|
|
|
|
// Синхронизируем физику и HP строго на новом CommittedFrame
|
|
_simulator.RestoreSimulationToWorld(Track.GetFrame(_committedFrame.Value));
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
StopPreviewLoop();
|
|
HideAllPreviewVisuals();
|
|
HitboxDrawer.Clear();
|
|
_mode.Value = TimelineMode.Idle;
|
|
}
|
|
}
|
|
|
|
private async UniTask PlayBakedRangeAsync(int startFrame, int endFrame, CancellationToken ctx)
|
|
{
|
|
StopPreviewLoop();
|
|
_previewVisualsEnabled = false;
|
|
HideAllPreviewVisuals();
|
|
_mode.Value = TimelineMode.BattlePlaying;
|
|
|
|
float accumulator = 0f;
|
|
int frame = startFrame;
|
|
|
|
while (frame <= endFrame && !ctx.IsCancellationRequested)
|
|
{
|
|
await UniTask.Yield(PlayerLoopTiming.Update, ctx);
|
|
|
|
accumulator += Mathf.Min(Time.unscaledDeltaTime, 0.1f) * PlaybackSpeed;
|
|
|
|
while (accumulator >= TickDelta && frame <= endFrame && !ctx.IsCancellationRequested)
|
|
{
|
|
accumulator -= TickDelta;
|
|
|
|
_committedFrame.Value = frame;
|
|
ApplyFrame(frame, playOneShotVfx: true);
|
|
frame++;
|
|
}
|
|
}
|
|
}
|
|
|
|
private async UniTask DecideActionsForSlots(List<int> readySlots, CancellationToken ctx)
|
|
{
|
|
_mode.Value = TimelineMode.Deciding;
|
|
|
|
// Сначала решения принимают ИИ — игрок сразу увидит их запечённый план на таймлайне
|
|
var orderedSlots = readySlots
|
|
.OrderBy(slot => _entities[slot].TeamData.Team == EntityTeam.Good ? 1 : 0)
|
|
.ToList();
|
|
|
|
foreach (int slotIndex in orderedSlots)
|
|
{
|
|
_simulator.RestoreSimulationToWorld(Track.GetFrame(_committedFrame.Value));
|
|
ApplyFrame(_committedFrame.Value, playOneShotVfx: false);
|
|
|
|
EntityActionSlotSnapshot chosenSlot = await DecideForSingleSlot(slotIndex, ctx);
|
|
|
|
Track.GetFrame(_committedFrame.Value).Entities[slotIndex].ActionSlot = chosenSlot;
|
|
RebakeFromCommitted(recordGhosts: false);
|
|
}
|
|
}
|
|
|
|
private async UniTask<EntityActionSlotSnapshot> DecideForSingleSlot(int slotIndex, CancellationToken ctx)
|
|
{
|
|
var entity = _entities[slotIndex];
|
|
|
|
if (entity.TeamData.Team == EntityTeam.ChaoticEvil)
|
|
{
|
|
var (enemyRes, enemyData) = await _enemyDeciders[entity.TeamData.DeciderType]
|
|
.DecideEnemy(ctx, entity, _battleActions);
|
|
|
|
return new EntityActionSlotSnapshot
|
|
{
|
|
ActionType = enemyRes.ActionType,
|
|
DecisionResult = enemyRes,
|
|
ActionData = enemyData,
|
|
LastCompletedActionType = Track.GetFrame(_committedFrame.Value).Entities[slotIndex].ActionSlot.LastCompletedActionType,
|
|
ActionStartFrame = _committedFrame.Value,
|
|
EstimatedEndFrame = _committedFrame.Value + enemyData.TotalFrames
|
|
};
|
|
}
|
|
|
|
if (entity.TeamData.Team == EntityTeam.Good)
|
|
return await DecideForPlayerSlot(slotIndex, ctx);
|
|
|
|
return EntityActionSlotSnapshot.CreateNone(_committedFrame.Value);
|
|
}
|
|
|
|
private async UniTask<EntityActionSlotSnapshot> DecideForPlayerSlot(int slotIndex, CancellationToken ctx)
|
|
{
|
|
var entity = _entities[slotIndex];
|
|
var lastCompleted = Track.GetFrame(_committedFrame.Value).Entities[slotIndex].ActionSlot.LastCompletedActionType;
|
|
|
|
_decisionPanel.SetEntityInfo(entity.battleActionTypes);
|
|
_timelinePanel.SetPreviousActionText(lastCompleted.ToString());
|
|
|
|
// Сразу запекаем прогноз с текущими действиями врагов — ползунок доступен уже в меню выбора!
|
|
_previewVisualsEnabled = true;
|
|
RebakeFromCommitted(recordGhosts: true);
|
|
ApplyFrame(_committedFrame.Value, playOneShotVfx: false);
|
|
|
|
var cameraBattleState = _cameraStateMachine.CurrentBaseState as CameraBattleModeState;
|
|
|
|
while (!ctx.IsCancellationRequested)
|
|
{
|
|
Cursor.lockState = CursorLockMode.Confined;
|
|
if (cameraBattleState != null) cameraBattleState.battleDeciding = true;
|
|
await _decisionPanel.Open(ctx);
|
|
|
|
BattleActionType decidedType = await _decisionPanel.GetDecision(ctx);
|
|
if (decidedType == BattleActionType.None) continue;
|
|
|
|
var deciderType = _battleActions[decidedType].DeciderType;
|
|
var decider = _battleActionDeciders[deciderType];
|
|
|
|
StopPreviewLoop();
|
|
_simulator.RestoreSimulationToWorld(Track.GetFrame(_committedFrame.Value));
|
|
ApplyFrame(_committedFrame.Value, playOneShotVfx: false);
|
|
|
|
decider.MountDecider(entity);
|
|
bool waitingForFirstTarget = true;
|
|
|
|
try
|
|
{
|
|
while (!ctx.IsCancellationRequested)
|
|
{
|
|
// Пока цель ещё не выбрана — курсор залочен под прицеливание камеры.
|
|
// Как только цель выбрана (идёт превью) — курсор свободен (Confined),
|
|
// чтобы игрок мог двигать ползунок таймлайна (а вращать камеру через ПКМ).
|
|
Cursor.lockState = waitingForFirstTarget ? CursorLockMode.Locked : CursorLockMode.Confined;
|
|
if (cameraBattleState != null) cameraBattleState.battleDeciding = !waitingForFirstTarget;
|
|
|
|
await _decisionPanel.Close(ctx);
|
|
|
|
var decisionResult = await decider.GetDecision();
|
|
decisionResult.ActionType = decidedType;
|
|
|
|
StopPreviewLoop();
|
|
_simulator.RestoreSimulationToWorld(Track.GetFrame(_committedFrame.Value));
|
|
|
|
if (decisionResult.ResultCode == BattleActionDecisionResultCode.CancelDecision)
|
|
{
|
|
RebakeFromCommitted(recordGhosts: true);
|
|
ApplyFrame(_committedFrame.Value, playOneShotVfx: false);
|
|
break;
|
|
}
|
|
|
|
var actionData = _battleActions[decidedType].MountAndGetFrames(entity, decisionResult);
|
|
var candidateSlot = new EntityActionSlotSnapshot
|
|
{
|
|
ActionType = decidedType,
|
|
DecisionResult = decisionResult,
|
|
ActionData = actionData,
|
|
LastCompletedActionType = lastCompleted,
|
|
ActionStartFrame = _committedFrame.Value,
|
|
EstimatedEndFrame = _committedFrame.Value + actionData.TotalFrames
|
|
};
|
|
|
|
if (decisionResult.ResultCode == BattleActionDecisionResultCode.Deciding)
|
|
{
|
|
waitingForFirstTarget = false;
|
|
_previewVisualsEnabled = true;
|
|
|
|
RebakeFromCommitted(
|
|
recordGhosts: true,
|
|
overrideSlot: slotIndex,
|
|
overrideAction: candidateSlot);
|
|
|
|
StartPreviewLoop(_committedFrame.Value, Track.LastFrame, ctx);
|
|
}
|
|
else // BattleActionDecisionResultCode.Decided
|
|
{
|
|
_previewVisualsEnabled = false;
|
|
HideAllPreviewVisuals();
|
|
return candidateSlot;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
StopPreviewLoop();
|
|
decider.UnmountDecider();
|
|
}
|
|
}
|
|
|
|
return EntityActionSlotSnapshot.CreateNone(_committedFrame.Value, lastCompleted);
|
|
}
|
|
|
|
// =================== ЗАПЕКАНИЕ И ПРИМЕНЕНИЕ КАДРОВ ===================
|
|
|
|
private void RebakeFromCommitted(
|
|
bool recordGhosts,
|
|
int overrideSlot = -1,
|
|
EntityActionSlotSnapshot? overrideAction = null)
|
|
{
|
|
_simulator.BakeFrom(Track, _committedFrame.Value, recordGhosts, overrideSlot, overrideAction);
|
|
_maxFrame.Value = Track.LastFrame;
|
|
_onTrackRebaked.OnNext(Track);
|
|
}
|
|
|
|
private void StartPreviewLoop(int startFrame, int endFrame, CancellationToken battleCtx)
|
|
{
|
|
StopPreviewLoop();
|
|
if (endFrame <= startFrame) return;
|
|
|
|
_mode.Value = TimelineMode.PreviewPlaying;
|
|
_previewLoopCts = CancellationTokenSource.CreateLinkedTokenSource(battleCtx);
|
|
RunPreviewPlaybackAsync(startFrame, endFrame, _previewLoopCts.Token).Forget();
|
|
}
|
|
|
|
private async UniTaskVoid RunPreviewPlaybackAsync(int startFrame, int endFrame, CancellationToken ctx)
|
|
{
|
|
float accumulator = 0f;
|
|
int current = startFrame;
|
|
|
|
while (!ctx.IsCancellationRequested)
|
|
{
|
|
bool canceled = await UniTask.Yield(PlayerLoopTiming.Update, ctx).SuppressCancellationThrow();
|
|
if (canceled) break;
|
|
|
|
accumulator += Mathf.Min(Time.unscaledDeltaTime, 0.1f) * PlaybackSpeed;
|
|
|
|
while (accumulator >= TickDelta && !ctx.IsCancellationRequested)
|
|
{
|
|
accumulator -= TickDelta;
|
|
current++;
|
|
if (current > endFrame) current = startFrame;
|
|
|
|
ApplyFrame(current, playOneShotVfx: false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void StopPreviewLoop()
|
|
{
|
|
if (_previewLoopCts == null) return;
|
|
_previewLoopCts.Cancel();
|
|
_previewLoopCts.Dispose();
|
|
_previewLoopCts = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Единая точка отображения любого кадра (бой, превью и скраббинг ползунком).
|
|
/// </summary>
|
|
private void ApplyFrame(int frame, bool playOneShotVfx)
|
|
{
|
|
var snapshot = Track.GetFrame(frame);
|
|
_simulator.ApplyVisualFrameToWorld(snapshot);
|
|
_displayFrame.Value = snapshot.Frame;
|
|
|
|
// Обновляем многоступенчатые слепки и цвет проекции ТОЛЬКО для кадров будущего (> CommittedFrame)
|
|
for (int i = 0; i < _entities.Length; i++)
|
|
{
|
|
_entities[i].EntityPreviewVisuals?.UpdateForTimelineFrame(
|
|
viewFrame: snapshot.Frame,
|
|
committedFrame: _committedFrame.Value,
|
|
interruptionStage: snapshot.InterruptionStage,
|
|
showPreviewVisuals: _previewVisualsEnabled);
|
|
}
|
|
|
|
// Хитбоксы текущего кадра не исчезают, даже если ползунок остановлен!
|
|
HitboxDrawer.Clear();
|
|
var hitboxes = snapshot.HitboxVisuals;
|
|
if (hitboxes != null)
|
|
{
|
|
for (int i = 0; i < hitboxes.Length; i++)
|
|
HitboxDrawer.DrawMatrix(hitboxes[i].Matrix, hitboxes[i].Color, duration: 999f);
|
|
}
|
|
|
|
// События VFX стреляют только в реальном воспроизведении
|
|
if (playOneShotVfx && snapshot.Events is { Length: > 0 })
|
|
{
|
|
for (int i = 0; i < snapshot.Events.Length; i++)
|
|
_onRealEvent.OnNext(snapshot.Events[i]);
|
|
}
|
|
}
|
|
|
|
private void HandleRealEvent(TimelineEvent ev)
|
|
{
|
|
if (ev.EventType == TimelineEventType.HitLanded)
|
|
{
|
|
_particleService.EmitOneShot(
|
|
new ParticlePartitionIDPair(ParticlePartition.HitParticles, 0),
|
|
15,
|
|
ev.WorldPosition,
|
|
Quaternion.identity);
|
|
}
|
|
}
|
|
|
|
private void HideAllPreviewVisuals()
|
|
{
|
|
if (_entities == null) return;
|
|
for (int i = 0; i < _entities.Length; i++)
|
|
_entities[i].EntityPreviewVisuals?.HidePreviewState();
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
StopPreviewLoop();
|
|
HitboxDrawer.Clear();
|
|
_displayFrame.Dispose();
|
|
_committedFrame.Dispose();
|
|
_maxFrame.Dispose();
|
|
_mode.Dispose();
|
|
_onTrackRebaked.Dispose();
|
|
_onRealEvent.Dispose();
|
|
}
|
|
}
|
|
} |