shandong/back_cantanBuilding
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

备份CatanBuilding瘦身独立工程

Browse Source
This commit is contained in:
JSD\13999
2026-05-26 16:15:54 +08:00
commit 2d0e6a61b7
12001 changed files with 2431925 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

806
Assets/Scripts/InfiniteBuilding/InfiniteBuildingAct.cs Normal file
View File

@@ -0,0 +1,806 @@
using System.Collections.Generic;
using UnityEngine;
using asap.core;
using UnityEngine.AddressableAssets;
using GameCore;
using cfg;
using UniRx;
using UnityEngine.ResourceManagement.AsyncOperations;
using Game;
public class InfiniteBuildingAct : AGameAct
{
private PlayerData _playerData;
private InfiniteBuildingData _data;
private InfiniteBuildingConf _cfg;
private class FSM : AFSM<EInfiniteBuildingState>
{
}
private IFSM<EInfiniteBuildingState> _sm;
private FSMHandler<IFSM<EInfiniteBuildingState>, EInfiniteBuildingState> _smHandler;
[SerializeField] private CraneCtrl _crane;
[SerializeField] private BlockManager _blockManager;
private Tables _tables;
[SerializeField] private CameraCtrl _cam;
private const int blockDepth = 20;
private CampSkyscraperPanel _mainPanel;
[SerializeField] private Transform _focus;
[SerializeField] private BlockDeathNotifier _deathWall;
private PlayerItemData _playerItemData;
private readonly EventAggregator _eventAggregator = new EventAggregator();
private float BlockRestingHeight => _cfg.blockRestingOffset + _focus.position.y;
[SerializeField] private MeshRenderer _skyLoop;
private HashSet<string> _collisionSounds;
private int _EVConstructionState, _EVRetryType, _EVHookRewardGot, _EVCashRewardGot, _EVRating, _EVCombo;
private ulong _EVCost, _EVCashBack;
[SerializeField] GameObject _light;
GameObject Building999Main;
private CompositeDisposable _disposables = new CompositeDisposable();
//IDisposable disposable;
private const string ComboKey = "InfiniteBuildingCombo";
public override async System.Threading.Tasks.Task<bool> StartAsync()
{
Building999Main = transform.GetChild(0).gameObject;
//Debug.Log($"<color=red>Main thread id: {Thread.CurrentThread.ManagedThreadId}</color>");
_collisionSounds = new HashSet<string>();
_data = new InfiniteBuildingData();
_sm = new FSM();
_smHandler = new FSMHandler<IFSM<EInfiniteBuildingState>, EInfiniteBuildingState>(this, _sm);
_cfg = (InfiniteBuildingConf)await Addressables.LoadAssetAsync<System.Object>("InfiniteBuildingConf").Task;
_playerData = GContext.container.Resolve<PlayerData>();
_tables = GContext.container.Resolve<Tables>();
_playerItemData = GContext.container.Resolve<PlayerItemData>();
_disposables.Add(GContext.OnEvent<InGradeAquariumEvent>().Subscribe(OnInAquariumEnevt));
_disposables.Add(GContext.OnEvent<EventMainBGM>().Subscribe(OnEventMainBGM));
GContext.OnEvent<MapShowEvent>().Subscribe(e =>
{
SetMapShow(e.isShow);
}).AddTo(_disposables);
_data.DownloadData(_playerData.InfiniteBuildingData);
// Debug.Log($"<color=red>Debug in progress!!!!!!!!!!!!!!!!</color>");
// _data.DownloadData("0,0,1,-1");
//_data.DownloadData("1199,0,1,-1," +
// "209,-0.9679986,1191.69006," +
// "212,-0.9312674,1192.70402," +
// "1201,-0.1499511,1193.71932," +
// "103,-0.288533,1195.73021," +
// "211,-0.03252038,1196.74632," +
// "203,-0.06627272,1197.76019," +
// "201,0.08355299,1198.77346," +
// "101,-0.3572269,1199.79065");
_crane.Init(_cfg, _focus, _data, _eventAggregator);
_eventAggregator.GetEvent<EventInfiniteBuildingAlign>()
.Subscribe(async _ => await TryAlignBlocks()).AddTo(_disposables);
_eventAggregator.GetEvent<EventInfiniteBuildingRetry>()
.Subscribe(_ =>
{
_EVRetryType = 1;
_sm.SetState(EInfiniteBuildingState.InitLoop);
UIManager.Instance.DestroyUI(UITypes.CampSettlementPanel);
}).AddTo(_disposables);
_eventAggregator.GetEvent<EventInfiniteBuildingConstruct>()
.Subscribe(e =>
{
_sm.SetState(EInfiniteBuildingState.BlockFall);
_EVCost = e.ConstructionCost;
}).AddTo(_disposables);
_eventAggregator.GetEvent<EventInfiniteBuildingBlockDeath>()
.Subscribe(e => HandleBlockDeath(e)).AddTo(_disposables);
_eventAggregator.GetEvent<EventInfiniteBuildingFail>()
.Subscribe(_ => _sm.SetState(EInfiniteBuildingState.Failure)).AddTo(_disposables);
_eventAggregator.GetEvent<EventInfiniteBuildingSucceed>()
.Subscribe(_ => _sm.SetState(EInfiniteBuildingState.Success)).AddTo(_disposables);
_eventAggregator.GetEvent<EventInfiniteBuildingPlayAudio>()
.Subscribe(async e => await PlayAudio(e.AudioName)).AddTo(_disposables);
_eventAggregator.GetEvent<EventInfiniteBuildingCollisionSound>()
.Subscribe(e => OnCollisionSound(e.Hash)).AddTo(_disposables);
_eventAggregator.GetEvent<EventInfiniteBuildingFirstCollision>()
.Subscribe(e => HandleFirstCollision(e.block)).AddTo(_disposables);
_eventAggregator.GetEvent<EventInfiniteBuildingGetReward>()
.Subscribe(e => HandleReceiveReward(e)).AddTo(_disposables);
await LoadAudioClips();
PlayBGM();
//Debug.Log($"<color=red>{_pd.InfiniteBuildingData}</color>");
_mainPanel = (await UIManager.Instance.ShowUI(UITypes.CampSkyscraperPanel))
.GetComponent<CampSkyscraperPanel>();
_mainPanel.Init(_data, _eventAggregator);
BoxCollider2D initBC =
transform.Find("Building999Main/static/B999_initial/Collision2D").GetComponent<BoxCollider2D>();
_focus.position = initBC.transform.position + new Vector3(initBC.offset.x, initBC.offset.y) +
initBC.size.y / 2f * Vector3.up;
_blockManager.Init(_cfg, _data, _eventAggregator);
await _blockManager.RebuildAllBlocks();
_deathWall.Init(_eventAggregator);
GetFX();
_sm.SetState(EInfiniteBuildingState.Init);
return await base.StartAsync();
}
void SetMapShow(bool isShow)
{
if (Building999Main != null)
{
Building999Main.SetActive(isShow);
}
}
void OnInAquariumEnevt(InGradeAquariumEvent e)
{
Debug.Log("OnInAquariumEnevt");
if (_light != null)
{
_light.SetActive(e.type == 1);
}
}
void OnEventMainBGM(EventMainBGM e)
{
PlayBGM();
}
public override async System.Threading.Tasks.Task StopAsync()
{
UIManager.Instance.DestroyUI(UITypes.CampSkyscraperPanel);
await base.StopAsync();
}
private void FixedUpdate()
{
if (_sm == null)
return;
if (_sm.State == EInfiniteBuildingState.PlayerCtrl
#if UNITY_EDITOR
&& !_cfg.FreezeCrane
#endif
)
{
_crane.PlayerCtrlFixedUpdate();
}
#if UNITY_EDITOR
float v = 0.2f;
if (Input.GetKeyDown(KeyCode.A) && _sm.State == EInfiniteBuildingState.PlayerCtrl)
{
_crane.Rb.position += v * Vector2.left;
}
if (Input.GetKeyUp(KeyCode.D) && _sm.State == EInfiniteBuildingState.PlayerCtrl)
{
_crane.Rb.position += v * Vector2.right;
}
#endif
else if (_sm.State == EInfiniteBuildingState.BlockFall)
{
_blockManager.BlockFallFixedUpdate();
}
}
private void LateUpdate()
{
_collisionSounds?.Clear();
}
protected override void OnDestroy()
{
Debug.Log("Act Destroyed!");
}
#if UNITY_EDITOR
private void OnGUI()
{
if (_sm != null)
GUI.Box(new Rect(20, 40, 200, 20), _sm.State.ToString());
//Debug.DrawLine(new Vector3(-10, _cam.LowerLimit.y, blockDepth),
//new Vector3(10, _cam.LowerLimit.y, blockDepth), Color.red);
if (_blockManager.CurrentBlock != null)
{
GUI.Box(new Rect(20, 60, 200, 20), $"Acc: {_blockManager.CurrentBlock.Acc.magnitude}");
GUI.Box(new Rect(20, 90, 200, 20), $"Angular Acc: {_blockManager.CurrentBlock.AngularAcc}");
}
else
{
GUI.Box(new Rect(20, 60, 200, 20), $"Empty");
GUI.Box(new Rect(20, 90, 200, 20), $"Empty");
}
}
private void OnDrawGizmos()
{
if (_focus != null && _cfg != null)
Debug.DrawLine(new Vector3(-10, BlockRestingHeight, blockDepth),
new Vector3(10, BlockRestingHeight, blockDepth), Color.red);
//Debug.DrawLine(new Vector3(-20, _cam.LowerLimit.y, blockDepth),
// new Vector3(-20, _cam.LowerLimit.y, blockDepth), Color.red);
}
#endif
private void UpdateLastHangingBlock()
{
_data.LastHangingBlock = _blockManager.CurrentBlock.Idx;
_data.UploadData();
}
private void UpdateData(int lvlDelta = 0)
{
_data.Lvl += lvlDelta;
_data.Record = new List<InfiniteBuildingData.BlockRecord>();
foreach (var block in _blockManager.Blocks)
{
//Debug.Log($"{block}");
//Debug.Log($"{block.Rb.position}");
//Debug.Log($"{block.transform.position}");
_data.Record.Add(new InfiniteBuildingData.BlockRecord(block.Idx, block.Rb.position));
}
_data.UploadData();
}
protected override void OnStopped()
{
//_data.LastHangingBlock = _blockManager.CurrentBlock.Idx;
//UpdateData();
foreach (var e in _audioClips)
{
Addressables.Release(e.Value.Op);
}
_disposables.Dispose();
base.OnStopped();
}
public void HandleBlockDeath(EventInfiniteBuildingBlockDeath e)
{
PlayFX("collapse", _focus.position + _cfg.fxCollapse);
if (_sm.State != EInfiniteBuildingState.BlockFall)
{
PlayFX("replay",
Camera.main.ViewportToWorldPoint(new Vector3(0.5f, 1f, _cfg.blockDepth)));
_blockManager.RebuildBlocks(true);
return;
}
if (e.stateBeforeDeath == BlockState.Free)
_eventAggregator.Publish(new EventInfiniteBuildingFail());
if (e.stateBeforeDeath == BlockState.Resting)
{
_eventAggregator.Publish(new EventInfiniteBuildingFail());
PlayFX("replay",
Camera.main.ViewportToWorldPoint(new Vector3(0.5f, 1f, Camera.main.nearClipPlane)));
_blockManager.RebuildAllBlocks();
}
}
private async System.Threading.Tasks.Task TryAlignBlocks()
{
int alignCost = _tables.TbConstructionInfiniteConfig.ResetCost;
if (_playerData.diamond < alignCost)
{
//Debug.LogWarning("inssuficient diamond");
GameObject ui = await UIManager.Instance.ShowUI(UITypes.LackOfResourceConfirmPopupPanel);
//ui.GetComponent<CampSettlementPanel>().Init(_eventAggregator);
return;
}
_EVRetryType = 2;
PlayAudio("Reset");
PlayFX("reset", Camera.main.ViewportToWorldPoint(new Vector3(0.5f, 0f, _cfg.blockDepth)));
_playerData.AddDiamond(-alignCost);
_blockManager.AlignBlocks(_eventAggregator);
UpdateData();
_sm.SetState(EInfiniteBuildingState.InitLoop);
UIManager.Instance.DestroyUI(UITypes.CampSettlementPanel);
}
private void HandleFirstCollision(Block b)
{
//Debug.Log($"name: {b.name}");
PlayFX("fall", b.transform.position + _cfg.fxFall);
_blockManager.StartDestroyCountDown();
//PlayAudio("BlockFall");
}
private void HandleReceiveReward(EventInfiniteBuildingGetReward e)
{
var drop = _tables.TbDrop[e.DropID];
if (drop.DropList.DropIDList[0] == 1001)
_EVHookRewardGot = drop.DropList.DropCountList[0];
else if (drop.DropList.DropIDList[0] == 1002)
_EVCashRewardGot = _playerItemData.GetExtraCoinMag(drop.DropList.DropCountList[0]);
}
private int GetConstructionPrice()
{
int price = _data.ConstructPrice;
var buffTimeData = GContext.container.Resolve<BuffDataCenter>().GetWeelyBuffTimeData<ConstructionCost>();
bool isConstructionCost = buffTimeData != null;
if (isConstructionCost)
{
price = (int)(price * (1 - buffTimeData.Param));
}
return price;
}
private int GetRating()
{
int excellentScore = _blockManager.GetExcellentScore();
if (excellentScore >= _tables.TbConstructionInfiniteConfig.GoodRankClamp[0] &&
excellentScore <= _tables.TbConstructionInfiniteConfig.GoodRankClamp[1])
{
Debug.Log($"<color=red>Good.</color>");
return 1;
}
// else if (excellentScore >= _tables.TbConstructionInfiniteConfig.GreatRankClamp[0] &&
// excellentScore <= _tables.TbConstructionInfiniteConfig.GreatRankClamp[1])
// Debug.Log($"<color=red>Great.</color>");
if (excellentScore >= _tables.TbConstructionInfiniteConfig.FantasticRankClamp[0] &&
excellentScore <= _tables.TbConstructionInfiniteConfig.FantasticRankClamp[1])
{
Debug.Log($"<color=red>Fantastic.</color>");
return 2;
}
Debug.Log($"<color=red>Undefined.</color>");
return 0;
}
private int CountCombo(bool doesComboContinue = true)
{
if (!doesComboContinue)
{
PlayerPrefs.SetInt(ComboKey, 0);
Debug.Log($"<color=red>Combo reset.</color>");
return 0;
}
int comboCount = PlayerPrefs.GetInt(ComboKey) + 1;
PlayerPrefs.SetInt(ComboKey, comboCount);
// if (comboCount >= 2)
// Debug.Log($"<color=red>Combo: {comboCount}</color>");
return comboCount;
}
#region Audio
private readonly Dictionary<string, string> _audioAliases = new Dictionary<string, string>()
{
["CraneRise"] = "audio_ui_skyscraper_1",
["CraneDescend"] = "audio_ui_skyscraper_2",
["BlockFall"] = "audio_ui_skyscraper_3",
["BlockHit"] = "audio_ui_skyscraper_4",
["BlockPerfect"] = "audio_ui_skyscraper_5",
["Collapse"] = "audio_ui_skyscraper_6",
["Reset"] = "audio_ui_skyscraper_7",
["BGM"] = "audio_ui_skyscraper_bgm"
};
private readonly Dictionary<string, InfiniteBuildingAudioClip> _audioClips =
new Dictionary<string, InfiniteBuildingAudioClip>();
private struct InfiniteBuildingAudioClip
{
public string Name;
public string Address;
public AudioClip Clip;
public AsyncOperationHandle Op;
public InfiniteBuildingAudioClip(string name, string addr, AudioClip clip, AsyncOperationHandle op)
{
Name = name;
Clip = clip;
Address = addr;
Op = op;
}
}
private async System.Threading.Tasks.Task LoadAudioClips()
{
foreach (var e in _audioAliases)
{
AsyncOperationHandle<AudioClip> op = Addressables.LoadAssetAsync<AudioClip>(e.Value);
_audioClips.Add(e.Key, new InfiniteBuildingAudioClip(e.Key, e.Value, await op.Task, op));
}
}
private async System.Threading.Tasks.Task PlayAudio(string audioName)
{
if (!_audioAliases.ContainsKey(audioName))
{
Debug.LogError($"Audio name {audioName} not found in dictionary.");
return;
}
Sound s = GContext.container.Resolve<ISoundService>()
.GetNewFishingSound(clip: _audioClips[audioName].Clip);
s.soundMainType = SoundMainType.Fishing;
s.audioSource.Play();
await System.Threading.Tasks.Task.Delay((int)(_audioClips[audioName].Clip.length * 1000));
s.ReturnPool();
}
private void PlayBGM()
{
GContext.Publish(new EventBGMSound(_audioAliases["BGM"]));
}
private void OnCollisionSound(string hash)
{
if (_sm.State != EInfiniteBuildingState.BlockFall || _collisionSounds.Contains(hash))
return;
_collisionSounds.Add(hash);
PlayAudio("BlockHit");
}
#endregion
#region FX
private readonly List<string> _fxNames = new List<string>()
{
"fx_infinitebuilding_cloud",
"fx_infinitebuilding_collapse",
"fx_infinitebuilding_reset",
"fx_infinitebuilding_replay",
"fx_infinitebuilding_fall",
"fx_infinitebuilding_fallperfact"
};
[SerializeField] private Dictionary<string, GameObject> _fxDic = new Dictionary<string, GameObject>();
private void GetFX()
{
foreach (string name in _fxNames)
{
_fxDic.Add(name.Split('_')[^1], transform.Find("Building999Main/fx/" + name).gameObject);
}
}
private void PlayFX(string name, Vector3 pos)
{
_fxDic[name].transform.position = pos;
_fxDic[name].SetActive(false);
_fxDic[name].SetActive(true);
}
private void MoveFx(string name, Vector3 pos)
{
_fxDic[name].transform.position = pos;
}
#endregion
#region State Machine Driver
private void Init_Enter()
{
//Debug.Log("Init_Enter!");
//Debug.Log($"<color=red>Init_Enter thread id: {Thread.CurrentThread.ManagedThreadId}</color>");
InitEnterAsync();
//GenerateBlock().ContinueWith(_ => _sm.SetState(EInfiniteBuildingState.PlayerCtrl));
}
private async System.Threading.Tasks.Task InitEnterAsync()
{
//Debug.Log($"<color=red>InitEnterAsync thread id: {Thread.CurrentThread.ManagedThreadId}</color>");
await _blockManager.RebuildBlocks();
_cam.Init(_focus, _cfg, _skyLoop, _data);
_deathWall.transform.position = _focus.position + Vector3.up * _cfg.deathWallOffset;
_crane.ResetPosition();
Block b = await _blockManager.GenerateBlock(_crane.transform.position + _cfg.blockSpawnOffset, true);
_blockManager.CurrentBlock = b;
_data.LastHangingBlock = b.Idx;
UpdateData();
_crane.AttachJoints(b);
if (_focus.position.y > _cfg.fxCloudAppearHeight)
PlayFX("cloud", _focus.position + _cfg.fxCloud);
_sm.SetState(EInfiniteBuildingState.PlayerCtrl);
}
private void Init_Exit()
{
//Debug.Log("Init_Exit!");
}
private void InitLoop_Enter()
{
//Debug.Log("InitLoop_Enter!");
//GenerateBlock().ContinueWith(_ => _sm.SetState(EInfiniteBuildingState.PlayerCtrl));
InitLoopEnterAsync();
}
private async System.Threading.Tasks.Task InitLoopEnterAsync()
{
// Debug.Log($"construction_state: {_EVConstructionState}");
// Debug.Log($"construction_lvl: {_data.Lvl}");
// Debug.Log($"retry_type: {_EVRetryType}");
// Debug.Log($"hook_count: {_playerData.GetEnergyRM()}");
// Debug.Log($"cost_cash: {_EVCost}");
// Debug.Log($"reward_hook: {_EVHookRewardGot}");
// Debug.Log($"reward_cash: {_EVCashRewardGot}");
// Debug.Log($"rating: {_EVRating}");
// Debug.Log($"combo_count: {_EVCombo}");
// Debug.Log($"cash_back: {_EVCashBack}");
#if AGG
using (var e = GEvent.GameEvent("infinite_construction"))
{
e.AddContent("construction_state", _EVConstructionState)
.AddContent("construction_lv", _data.Lvl)
.AddContent("retry_type", _EVRetryType)
.AddContent("hook_count", _playerData.GetEnergyRM())
.AddContent("cost_cash", _EVCost)
.AddContent("reward_hook", _EVHookRewardGot)
.AddContent("reward_cash", _EVCashRewardGot)
.AddContent("rating", _EVRating)
.AddContent("combo_count", _EVCombo)
.AddContent("cash_back", _EVCashBack);
}
#endif
var b = await _blockManager.GenerateBlock(_crane.transform.position + _cfg.blockSpawnOffset);
_blockManager.CurrentBlock = b;
_data.LastHangingBlock = b.Idx;
UpdateData();
_crane.AttachJoints(b);
_sm.SetState(EInfiniteBuildingState.PlayerCtrl);
}
private void InitLoop_Exit()
{
//Debug.Log("InitLoop_Exit!");
}
private void PlayerCtrl_Enter()
{
//Debug.Log("PlayerCtrl_Enter!");
//Debug.Log($"<color=red>Player Ctrl thread id: {Thread.CurrentThread.ManagedThreadId}</color>");
PlayerCtrlEnterAsync();
//Debug.Log(_crane.gameObject);
}
private async System.Threading.Tasks.Task PlayerCtrlEnterAsync()
{
await _crane.Descend();
_crane.Kick();
_mainPanel.ActivateBtns();
}
private void PlayerCtrl_Exit()
{
//Debug.Log("PlayerCtrl_Exit!");
_mainPanel.DeactivateBtns();
}
private void BlockFall_Enter()
{
//Debug.Log("BlockFall_Enter!");
//Debug.Log($"<color=red>Block Fall thread id: {Thread.CurrentThread.ManagedThreadId}</color>");
StartCoroutine(_crane.DropBlockAndRise());
_blockManager.CurrentBlock.Drop();
//_currentBlock.Drop();
//DestroyCountDown();
}
private void BlockFall_Exit()
{
//Debug.Log("BlockFall_Exit!");
_blockManager.ResetDestroyCountDown();
}
private void Success_Enter()
{
//Debug.Log("Success_Enter!");
SuccessEnterAsync();
}
private async System.Threading.Tasks.Task SuccessEnterAsync()
{
int newHeight = (int)_blockManager.CurrentBlock.WorldHeight;
int oldHeight = (int)_focus.position.y;
int deltaLvl = newHeight > oldHeight ? (int)_blockManager.CurrentBlock.Height : 0;
//_blockManager.CurrentBlock.Rb.position =
// new Vector2(_blockManager.CurrentBlock.Rb.position.x, _focus.position.y);
_blockManager.CurrentBlock.PlayFurnitureAnimation();
int combo = CountCombo();
int rating = GetRating();
bool isPerfect = _blockManager.TrySnap();
_EVCombo = combo;
_EVRating = rating;
if (isPerfect)
{
_ = PlayAudio("BlockPerfect");
PlayFX("fallperfact", _blockManager.CurrentBlock.transform.position + _cfg.fxPerfect);
_EVConstructionState = 2;
}
else
{
_EVConstructionState = 1;
}
float refundRatio = 0.0f;
if (combo >= 2)
refundRatio += Mathf.Min(combo - 1, _tables.TbConstructionInfiniteConfig.ComboReturnMaxCount) *
_tables.TbConstructionInfiniteConfig.ComboOnceReturnPoint;
if (rating != 0)
refundRatio += rating == 1
? _tables.TbConstructionInfiniteConfig.GoodReturnPoint
: _tables.TbConstructionInfiniteConfig.FantasticReturnPoint;
if (isPerfect)
refundRatio += _tables.TbConstructionInfiniteConfig.PerfectReturnPoint;
// Debug.Log($"<color=red>RefundRatio: {refundRatio}</color>");
_mainPanel.PlayRatingFx(rating);
_mainPanel.PlayComboFx(combo);
_EVCashBack = 0;
if (refundRatio != 0.0f)
{
int price = GetConstructionPrice();
int amount = (int)(refundRatio * price);
_EVCashBack = (ulong)amount;
_playerData.SetGold(_playerData.gold + (ulong)amount);
await _mainPanel.PlayCashFlyAnimation(amount);
}
_EVRetryType = 0;
_EVHookRewardGot = 0;
_EVCashRewardGot = 0;
_data.Step++;
if (await _mainPanel.UpdateUIWhenSuccess())
{
await _mainPanel.ReceiveReward();
}
if (newHeight > oldHeight)
_focus.position = new Vector3(_focus.position.x, _blockManager.CurrentBlock.WorldHeight, _focus.position.z);
_cam.FollowFocus();
_blockManager.AddCurrentBlock();
_blockManager.LockOrClearBlocks(true);
UpdateData(deltaLvl);
//leyuanniubi!!!
if (deltaLvl > 0)
{
GContext.Publish(new ConditionTypeEvent(ConditionType.ConstructionCount, deltaLvl));
GContext.container.Resolve<LeadboardData>().AwaitSetLvData();
}
_deathWall.transform.position += deltaLvl * Vector3.up;
MoveFx(name: "cloud", pos: _focus.position + _cfg.fxCloud);
_sm.SetState(EInfiniteBuildingState.InitLoop);
}
private void Success_Exit()
{
//Debug.Log("Success_Exit!");
}
private void Failure_Enter()
{
//Debug.Log("Failure_Enter!");
FailureEnterAsync();
}
private async System.Threading.Tasks.Task FailureEnterAsync()
{
_EVCombo = CountCombo(false);
_EVConstructionState = 0;
_EVRating = 0;
_EVCashBack = 0;
PlayAudio("Collapse");
CampSettlementPanel ui = (await UIManager.Instance.ShowUI(UITypes.CampSettlementPanel))
.GetComponent<CampSettlementPanel>();
ui.Init(_eventAggregator);
await _blockManager.RebuildAllBlocks();
_blockManager.LockOrClearBlocks();
}
private void Failure_Exit()
{
//Debug.Log("Failure_Exit!");
}
//private void BlockDestroy_Enter()
//{
// Debug.Log("BlockDestroy_Enter!");
// //UIManager.Instance.ShowUI(UITypes.CampSettlementPanel);
// EnterBlockDestroyAsync();
// //_sm.SetState(EInfiniteBuildingState.InitLoop);
//}
//private void BlockDestroy_Exit()
//{
// Debug.Log("BlockDestroy_Exit!");
//}
#endregion
}
public enum EInfiniteBuildingState
{
Default,
Init,
InitLoop,
PlayerCtrl,
BlockFall,
Success,
Failure
}
public class EventInfiniteBuildingRetry
{
}
public class EventInfiniteBuildingAlign
{
}
public class EventInfiniteBuildingBlockDeath
{
public BlockState stateBeforeDeath { get; set; }
public EventInfiniteBuildingBlockDeath(BlockState stateBeforeDeath)
{
this.stateBeforeDeath = stateBeforeDeath;
}
}
public class EventInfiniteBuildingConstruct
{
public ulong ConstructionCost;
public EventInfiniteBuildingConstruct(ulong cost)
{
ConstructionCost = cost;
}
}
public class EventInfiniteBuildingFail
{
}
public class EventInfiniteBuildingSucceed
{
}
public class EventInfiniteBuildingPlayAudio
{
public string AudioName { get; set; }
public EventInfiniteBuildingPlayAudio(string audioName)
{
AudioName = audioName;
}
}
public class EventInfiniteBuildingCollisionSound
{
public string Hash { get; set; }
public EventInfiniteBuildingCollisionSound(string hash)
{
Hash = hash;
}
}
public class EventInfiniteBuildingFirstCollision
{
public readonly Block block;
public EventInfiniteBuildingFirstCollision(Block b)
{
block = b;
}
}
public class EventInfiniteBuildingGetReward
{
public readonly int DropID;
public EventInfiniteBuildingGetReward(int dropID)
{
DropID = dropID;
}
}