1714 lines
55 KiB
C#
1714 lines
55 KiB
C#
// EventCubeMeltManager.cs
|
||
// 锻刀大赛
|
||
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using System.Threading.Tasks;
|
||
using asap.core;
|
||
using cfg;
|
||
using EventCubeMelt;
|
||
using EventCubeMelt.Data;
|
||
using EventCubeMelt.ShapePlacement;
|
||
using EventCubeMelt.UI;
|
||
using EventCubeMelt.Utils;
|
||
using game;
|
||
using GameCore;
|
||
using Newtonsoft.Json;
|
||
using UnityEngine;
|
||
using Random = UnityEngine.Random;
|
||
|
||
|
||
public class EventCubeMeltManager
|
||
{
|
||
//
|
||
public const string SaveKey = "EventCubeMeltData";
|
||
|
||
#region 与外部交互函数
|
||
|
||
public void UpdateEventData(FishingEvent fishingEvent)
|
||
{
|
||
_fishingEvent = fishingEvent;
|
||
if (EventData != null && _fishingEvent != null && _fishingEvent.ID != EventData.EventId)
|
||
{
|
||
ClearData();
|
||
}
|
||
|
||
if (!_isInit || EventData == null)
|
||
{
|
||
_isInit = false;
|
||
Init();
|
||
}
|
||
else
|
||
{
|
||
UpdateTime();
|
||
SetRedPoint();
|
||
UpdateLocalData();
|
||
}
|
||
}
|
||
|
||
public void LoadData(string dataValue)
|
||
{
|
||
ELog($"LoadData-> {dataValue}");
|
||
|
||
if (!string.IsNullOrEmpty(dataValue))
|
||
{
|
||
EventData = JsonConvert.DeserializeObject<EventCubeMeltData>(dataValue);
|
||
|
||
// 可调试的在这里放数据
|
||
if (true)
|
||
{
|
||
// EventData.CurrentStagetId = 15;
|
||
// EventData.IsFinished = false;
|
||
// EventData.BoardData = new List<int>
|
||
// {
|
||
// 0,99,0,99,99,0,99,0,
|
||
// 99,0,99,99,0,99,0,99,
|
||
// 0,99,0,99,99,0,99,99,
|
||
// 99,0,99,0,99,0,99,99,
|
||
// 0,99,99,99,99,99,99,99,
|
||
// 99,0,99,99,99,99,99,99,
|
||
// 0,99,99,99,99,99,99,99,
|
||
// 99,0,99,0,99,99,5,99
|
||
// };
|
||
|
||
// EventData.CollectRewardsId.Remove(14);
|
||
// EventData.IsFinalRewardGet = false;
|
||
// EventData.CollectItems = new List<CollectItem>
|
||
// {
|
||
// new()
|
||
// {
|
||
// ItemId = 1, Count = 20, MaxCount = 20, Icon = null,
|
||
// },
|
||
// new()
|
||
// {
|
||
// ItemId = 4, Count = 15, MaxCount = 15, Icon = null,
|
||
// },
|
||
// new()
|
||
// {
|
||
// ItemId = 5, Count = 10, MaxCount = 10, Icon = null,
|
||
// }
|
||
// };
|
||
|
||
// EventData.BoardData = new List<int>()
|
||
// {
|
||
// 0, 0, 99, 99, 99, 0, 0, 0,
|
||
// 1, 0, 99, 0, 0, 99, 99, 2,
|
||
// 99, 99, 99, 88, 88, 2, 0, 99,
|
||
// 99, 2, 99, 99, 99, 99, 0, 99,
|
||
// 99, 99, 2, 99, 99, 0, 0, 0,
|
||
// 0,0,0,0, 0, 2, 0, 0,
|
||
// 99, 0, 0, 99, 99, 99, 2, 0,
|
||
// 99, 0, 0, 99, 99, 99, 2, 0
|
||
// };
|
||
// EventData.BoardData = new List<int>
|
||
// {
|
||
// 99, 99, 99, 99, 0, 99, 0, 0,
|
||
// 99, 99, 99, 99, 0, 99, 0, 0,
|
||
// 99, 99, 99, 99, 0, 99, 0, 0,
|
||
// 99, 99, 99, 99, 0, 99, 0, 0,
|
||
// 99, 99, 99, 99, 0, 99, 0, 0,
|
||
// 0,0,0,0, 0, 0, 0, 0,
|
||
// 99, 99, 99, 99, 0, 99, 0, 0,
|
||
// 99, 99, 99, 99, 0, 99, 0, 0,
|
||
// };
|
||
// EventData.PieceDatas = new List<List<int>>
|
||
// {
|
||
// new() {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,99,99,99,99,99},
|
||
// new() {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0},
|
||
// new() {0,0,0,0,0,0,0,0,0,0,0,0,99,99,0,0,0,99,0,0,0,0,99,0,0},
|
||
// };
|
||
}
|
||
}
|
||
}
|
||
|
||
public void ClearData()
|
||
{
|
||
EventData = null;
|
||
_isInit = false;
|
||
SaveData();
|
||
}
|
||
|
||
private void SaveData()
|
||
{
|
||
var eventDataJson = JsonConvert.SerializeObject(EventData);
|
||
if (ShouldBuildELog())
|
||
{
|
||
ELog($"SaveData()-> {eventDataJson}");
|
||
}
|
||
PlayFabMgr.Instance.UpdateUserDataValue(SaveKey, eventDataJson);
|
||
}
|
||
|
||
public void AddTicket(int costValue)
|
||
{
|
||
if (EventData != null)
|
||
{
|
||
EventData.TicketCount += costValue;
|
||
if (EventData.TicketCount < 0)
|
||
{
|
||
EventData.TicketCount = 0;
|
||
}
|
||
GContext.container.Resolve<FishingEventData>().SaveTransitionData(EventData.EventId, EventData.TicketCount);
|
||
GContext.Publish(new EventCubeMeltUpdateTicketCount());
|
||
SaveData();
|
||
}
|
||
SetRedPoint();
|
||
}
|
||
|
||
public int GetTicketCount()
|
||
{
|
||
return EventData.TicketCount;
|
||
}
|
||
|
||
#endregion
|
||
|
||
private bool _isInit;
|
||
private FishingEvent _fishingEvent;
|
||
[Inject] public Tables _tables { get; set; }
|
||
|
||
public EventCubeMeltData EventData { get; private set; }
|
||
|
||
public FishingEvent FishingEvent {get => _fishingEvent;set => _fishingEvent = value;}
|
||
|
||
|
||
// 锻刀大赛数据
|
||
public EventCubeMeltMain EventCubeMeltMainData { get; private set; }
|
||
|
||
// 配置
|
||
private List<List<int>> EventCubeMeltConfig { get; set; }
|
||
|
||
// 当前的配置数据
|
||
public EventCubeMeltStage EventCubeMeltStageData { get; private set; }
|
||
|
||
// 当前收集数据
|
||
public EventCubeMeltCollection EventCubeMeltCollectionData { get; private set; }
|
||
|
||
// 当前的Piece
|
||
public List<EventCubeMeltPiece> EventCubeMeltPieces { get; private set; }
|
||
|
||
//
|
||
// 读取表格，生成所有的Piece
|
||
private List<PieceItem> EventCubeMeltPieceItems { get; set; } = new();
|
||
|
||
// 当前的Item
|
||
public List<EventCubeMeltItem> EventCubeMeltItems { get; private set; }
|
||
|
||
// 收集的列表
|
||
public List<EventCubeMeltCollection> EventCubeMeltCollections { get; private set; }
|
||
|
||
//- 当前的StageList
|
||
public List<int> EventStageList { get; private set; }
|
||
//
|
||
public int StageCount { get; set; }
|
||
|
||
//-
|
||
// public Vector2Int BoardViewSize { get; private set; }
|
||
|
||
|
||
|
||
public DateTime StartTime;
|
||
|
||
// 结束时间
|
||
public DateTime EndTime;
|
||
|
||
public void Init()
|
||
{
|
||
if (_fishingEvent == null)
|
||
return;
|
||
if (_isInit)
|
||
return;
|
||
ELog("Init()-> ");
|
||
if (EventData == null)
|
||
{
|
||
CreateNewData();
|
||
}
|
||
|
||
UpdateLocalData();
|
||
UpdateTime();
|
||
SetRedPoint();
|
||
_isInit = true;
|
||
}
|
||
|
||
public void SetRedPoint()
|
||
{
|
||
if (EventData != null)
|
||
{
|
||
RedPointManager.Instance.SetRedPointState(RedPointName.Home_CubeMelt, EventData.TicketCount > 0,
|
||
EventData.TicketCount);
|
||
}
|
||
else
|
||
{
|
||
RedPointManager.Instance.SetRedPointState(RedPointName.Home_CubeMelt, false);
|
||
}
|
||
}
|
||
|
||
private void UpdateTime()
|
||
{
|
||
if (_fishingEvent != null)
|
||
{
|
||
var limitedTime = (LimitedTime)_fishingEvent.TimeDefinition;
|
||
var startTime = GlobalUtils.TryParseDateTime(limitedTime.StartTime, ZZTimeHelper.UtcNow());
|
||
var endTime = GlobalUtils.TryParseDateTime(limitedTime.EndTime, ZZTimeHelper.UtcNow().AddDays(-1));
|
||
if (EventData != null)
|
||
{
|
||
if (EventData.EventId == _fishingEvent.ID)
|
||
{
|
||
EventData.StartTime = startTime;
|
||
EventData.EndTime = endTime;
|
||
}
|
||
else
|
||
{
|
||
EventData.EndTime = DateTime.Now.AddDays(-1);
|
||
}
|
||
}
|
||
|
||
EndTime = endTime;
|
||
StartTime = startTime;
|
||
}
|
||
}
|
||
|
||
private void UpdateLocalData()
|
||
{
|
||
ELog("UpdateLocalData() -> ");
|
||
if (_fishingEvent == null)
|
||
return;
|
||
|
||
var fishingEventRedirectID = _fishingEvent.RedirectID;
|
||
var cycleItemData = _tables.TbFishingEventCycleItem.GetOrDefault(fishingEventRedirectID);
|
||
var dataList = _tables.TbEventCubeMeltMain.DataList;
|
||
|
||
// 设置内容
|
||
EventCubeMeltMainData = dataList.FirstOrDefault(data => data.ID == cycleItemData.RedirectID);
|
||
// 道具
|
||
EventCubeMeltItems = _tables.TbEventCubeMeltItem.DataList;
|
||
EventCubeMeltPieces = _tables.TbEventCubeMeltPiece.DataList;
|
||
EventCubeMeltCollections = _tables.TbEventCubeMeltCollection.DataList;
|
||
//- StageList
|
||
EventStageList = EventData.Cycle == 0 ? EventCubeMeltMainData?.StageFirstList :EventCubeMeltMainData?.StageLoopList ?? new List<int>();
|
||
// var stageListCount = EventData.Cycle == 0 ? EventCubeMeltMainData?.StageFirstList.Count : EventCubeMeltMainData?.StageLoopList.Count;
|
||
// var stageListCount = EventStageList ?.Count ?? 0;
|
||
StageCount = EventStageList ?.Count ?? 0;
|
||
// PieceItems
|
||
InitPieceItems();
|
||
SyncEventDataChange();
|
||
|
||
}
|
||
|
||
private void SyncEventDataChange()
|
||
{
|
||
//- EventData 结构变化了，放在 这里
|
||
if (EventData.CollectRewardsId is not { Count: > 0 })
|
||
{
|
||
EventData.CollectRewardsId = new List<int>();
|
||
SaveData();
|
||
}
|
||
}
|
||
|
||
public async Task PrepareData()
|
||
{
|
||
ELog("PrepareData-> ");
|
||
|
||
if(EventData.CurrentStagetId > 0)
|
||
SetIsInGuideAnim(false);
|
||
|
||
// if (true)
|
||
// {
|
||
// if (EventData.CurrentStagetId == 2)
|
||
// {
|
||
// EventData.CurrentStagetId = 1;
|
||
// GenerateNextStageData();
|
||
// }
|
||
// }
|
||
|
||
FixOverStage();
|
||
UpdateCurrentStage();
|
||
await UpdateBoardData();
|
||
}
|
||
|
||
private async Task UpdateBoardData()
|
||
{
|
||
var isSaveDataRequired = false;
|
||
if (EventData.BoardData is not { Count: > 0 })
|
||
{
|
||
CreateNewBoard();
|
||
isSaveDataRequired = true;
|
||
}
|
||
|
||
// if (EventData.PieceItems is not { Count: > 0 })
|
||
if(EventData.PieceDatas is not {Count: > 0})
|
||
{
|
||
await CreateNewPieces();
|
||
isSaveDataRequired = true;
|
||
}
|
||
|
||
if (EventData.CollectItems is not { Count: > 0 })
|
||
{
|
||
UpdateNewCollect();
|
||
isSaveDataRequired = true;
|
||
}
|
||
|
||
if (isSaveDataRequired)
|
||
{
|
||
SaveData();
|
||
}
|
||
|
||
for (var i = CurrentPieceItems.Count; i < EventData.PieceDatas.Count; ++i)
|
||
{
|
||
CurrentPieceItems.Add(new PieceItem());
|
||
}
|
||
}
|
||
|
||
// 生成Item
|
||
private void InitPieceItems()
|
||
{
|
||
EventCubeMeltPieceItems.Clear();
|
||
foreach (var eventCubeMeltPiece in EventCubeMeltPieces)
|
||
{
|
||
foreach (var pc in eventCubeMeltPiece.PieceConfig)
|
||
{
|
||
EventCubeMeltPieceItems.Add(new PieceItem
|
||
{
|
||
MeltId = eventCubeMeltPiece.ID,
|
||
Weight = eventCubeMeltPiece.Weight,
|
||
PieceConfig = pc,
|
||
});
|
||
}
|
||
}
|
||
var valueBuilder = new StringBuilder();
|
||
foreach (var values in EventCubeMeltPieceItems)
|
||
{
|
||
valueBuilder.Append($"{values.MeltId},");
|
||
}
|
||
ELog($"UpdatePieceItems - >{valueBuilder}");
|
||
}
|
||
|
||
|
||
//TODO:CM 改成一次更新，多次返回的情况，每次更新 stageIndex 数据全部更新
|
||
/// <summary>
|
||
/// Key 为盘面 CellType（typeItem.Type），Value 含配置 TypeKey 与需求数量。
|
||
/// </summary>
|
||
public Dictionary<int, EventCubeMeltCollectionItemInfo> GetCollectionItems()
|
||
{
|
||
var ls = new Dictionary<int, EventCubeMeltCollectionItemInfo>();
|
||
for (var i = 0; i < EventCubeMeltCollectionData!.CollectingCountRequirement.Count; ++i)
|
||
{
|
||
var typeKey = EventCubeMeltCollectionData.CollectingItemRequirement[i];
|
||
var typeItem = EventCubeMeltItems.FirstOrDefault(elem => elem.ID == typeKey);
|
||
if (typeItem is { Type: > 0 })
|
||
{
|
||
var count = EventCubeMeltCollectionData.CollectingCountRequirement[i];
|
||
ls[typeItem.Type] = new EventCubeMeltCollectionItemInfo(typeKey, count);
|
||
}
|
||
}
|
||
|
||
var valueBuilder = new StringBuilder();
|
||
foreach (var kv in ls)
|
||
{
|
||
valueBuilder.Append($"{kv.Key}(key:{kv.Value.TrueId}):{kv.Value.RequiredCount} ");
|
||
}
|
||
ELog($"GetCollectionItems - >{valueBuilder}");
|
||
return ls;
|
||
}
|
||
|
||
private void CreateNewBoard()
|
||
{
|
||
var idx = Random.Range(0, EventCubeMeltConfig.Count);
|
||
ELog($"CreateNewBoard {idx}");
|
||
EventData.BoardData = EventCubeMeltConfig[idx];
|
||
var size = EventCubeMeltStageData.BoardSize;
|
||
EventData.BoardViewSize= new Vector2Int(size[0], size[1]);
|
||
}
|
||
|
||
|
||
private readonly int _pieceCount = 3;
|
||
private List<PieceItem> CurrentPieceItems { get; set; } = new();
|
||
|
||
private async Task CreateNewPieces()
|
||
{
|
||
ELog("CreateNewPieces");
|
||
// EventData.PieceItems.Clear();
|
||
CurrentPieceItems.Clear();
|
||
EventData.PieceDatas ??= new List<List<int>>();
|
||
EventData.PieceDatas.Clear();
|
||
|
||
|
||
if (EventCubeMeltStageData.InitItem is { Count: > 0 })
|
||
{
|
||
//TODO:注意保证InitItem的有效
|
||
var pieceIds = EventCubeMeltStageData.InitItem[0];
|
||
var repValueIndexs = EventCubeMeltStageData.InitItem[1];
|
||
var ids = EventCubeMeltStageData.InitItem[2];
|
||
|
||
var hasPieceIds = new List<int>(pieceIds.Where(id => id != 0));
|
||
|
||
for (var i = 0; i < _pieceCount; ++i)
|
||
{
|
||
var validMeltPieces = await GetValidMeltPieceItem();
|
||
var pieceId = pieceIds?[i]??0;
|
||
if (pieceId == 0)
|
||
{
|
||
validMeltPieces = validMeltPieces.Where(item => !hasPieceIds.Contains(item.MeltId)).ToList();
|
||
validMeltPieces = DoFilterSecond(validMeltPieces, EventData.PieceDatas);
|
||
var randomItem = WeightedRandom(validMeltPieces);
|
||
pieceId = randomItem.MeltId;
|
||
hasPieceIds.Add(pieceId);
|
||
}
|
||
var pieceItems = validMeltPieces.Where(item => item.MeltId == pieceId).ToList();
|
||
|
||
if (pieceItems.Count == 0)
|
||
{
|
||
LogError($"CreateNewPiecesInvalid pieceId = {pieceId}");
|
||
pieceItems = await GetValidMeltPieceItem();
|
||
}
|
||
|
||
var repValueIndex = repValueIndexs[i] ;
|
||
if (repValueIndex >= pieceItems.Count)
|
||
{
|
||
LogError($"CreateNewPiecesInvalid pieceId = {pieceId} repValueIndex={repValueIndex} validItemCount={pieceItems.Count}");
|
||
}
|
||
|
||
if (repValueIndex >= 0 && repValueIndex < pieceItems.Count)
|
||
{
|
||
var entity = pieceItems[repValueIndex];
|
||
CurrentPieceItems.Add(entity);
|
||
}
|
||
else
|
||
{
|
||
var entity = pieceItems[Random.Range(0, pieceItems.Count)];
|
||
CurrentPieceItems.Add(entity);
|
||
}
|
||
EventData.PieceDatas.Add(GetMeltPieceReal(i,ids[i],isPowerSet:true));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var validMeltPieces = await GetValidMeltPieceItem();
|
||
var hasPieceIds = new List<int>();
|
||
for (var i = 0; i < _pieceCount; ++i)
|
||
{
|
||
validMeltPieces = validMeltPieces.Where(item => !hasPieceIds.Contains(item.MeltId)).ToList();
|
||
validMeltPieces = DoFilterSecond(validMeltPieces,EventData.PieceDatas);
|
||
var entity = WeightedRandom(validMeltPieces);
|
||
hasPieceIds.Add(entity.MeltId);
|
||
|
||
// var entity = validMeltPieces.FirstOrDefault(item => item.MeltId == pieceId);
|
||
// var entities = validMeltPieces.Where(item => item.MeltId == pieceId).ToList();
|
||
// var entity = entities[Random.Range(0, entities.Count)];
|
||
if (ShouldBuildELog())
|
||
{
|
||
ELog($"CreateNewPiece -> {entity?.MeltId} {string.Join(",", entity?.PieceConfig ?? new List<int>())}");
|
||
}
|
||
// EventData.PieceItems.Add(entity);
|
||
CurrentPieceItems.Add(entity);
|
||
EventData.PieceDatas.Add(GetMeltPieceReal(i));
|
||
}
|
||
}
|
||
|
||
|
||
// validMeltPieces = GetValidMeltPieceItem();
|
||
// for (var i = 0; i < _pieceCount; ++i)
|
||
// {
|
||
// validMeltPieces = DoFilterSecond(validMeltPieces,EventData.PieceDatas);
|
||
//
|
||
// var pieceId = WeightedRandom(validMeltPieces);
|
||
// // var entity = validMeltPieces.FirstOrDefault(item => item.MeltId == pieceId);
|
||
//
|
||
// var entities = validMeltPieces.Where(item => item.MeltId == pieceId).ToList();
|
||
// var entity = entities[Random.Range(0, entities.Count)];
|
||
// ELog($"CreateNewPiece -> {entity?.MeltId} {string.Join(",",entity?.PieceConfig ?? new List<int>())}");
|
||
// // EventData.PieceItems.Add(entity);
|
||
// CurrentPieceItems.Add(entity);
|
||
// EventData.PieceDatas.Add(GetMeltPieceReal(i));
|
||
// }
|
||
}
|
||
//-
|
||
private PieceItem WeightedRandom(List<PieceItem> pieceItems)
|
||
{
|
||
// return UnityEngine.Random.Range(0, pieceItems.Count);
|
||
// var totalWeight = pieceItems.Sum(pieceItem => pieceItem.Weight);
|
||
var totalWeight = pieceItems.Sum(item => item.ComplexityWeight);
|
||
|
||
// double min = 0.0;
|
||
// double max = 100.0;
|
||
var random = new System.Random();
|
||
double randomValue = (random.NextDouble() * (totalWeight - 0));
|
||
// var randomValue = Random.Range(0f, totalWeight);
|
||
var currentWeight = 0F;
|
||
foreach (var pieceItem in pieceItems)
|
||
{
|
||
currentWeight += (float)pieceItem.ComplexityWeight;
|
||
if (randomValue < currentWeight)
|
||
return pieceItem;
|
||
}
|
||
|
||
var item101 = pieceItems.Find(item => item.MeltId == 101);
|
||
// 默认返回一个点
|
||
// return 101 ; // 理论上不会执行到这里
|
||
return item101;
|
||
}
|
||
|
||
private void CreateNewData()
|
||
{
|
||
ELog("CreateNewData-> ");
|
||
var limitedTime = (LimitedTime)_fishingEvent.TimeDefinition;
|
||
var startTime = GlobalUtils.TryParseDateTime(limitedTime.StartTime, ZZTimeHelper.UtcNow());
|
||
var endTime = GlobalUtils.TryParseDateTime(limitedTime.EndTime, ZZTimeHelper.UtcNow());
|
||
var ticketCount = GContext.container.Resolve<FishingEventData>().GetInitWelcomeGift(_fishingEvent.ID);
|
||
// var ticketCount = GContext.container.Resolve<FishingEventData>().GetInitWelcomeGift(_fishingEvent.ID);
|
||
|
||
EventData = new EventCubeMeltData
|
||
{
|
||
FirstOpen = true,
|
||
EventId = _fishingEvent.ID,
|
||
TicketCount = ticketCount,
|
||
StartTime = startTime,
|
||
EndTime = endTime,
|
||
IsFinished = false,
|
||
CurrentStagetId = 0,
|
||
CollectItems = new List<CollectItem>(),
|
||
// PieceItems = new List<PieceItem>(),
|
||
PieceDatas = new List<List<int>>(),
|
||
CollectRewardsId = new List<int>(),
|
||
InflationRate = GContext.container.Resolve<PlayerData>().InflationRate
|
||
};
|
||
|
||
GContext.container.Resolve<FishingEventData>().SaveTransitionData(EventData.EventId, EventData.TicketCount);
|
||
// GContext.container.Resolve<GuideDataCenter>().ClearGuide(nameof(GroupName.Block01));
|
||
}
|
||
|
||
#region Log
|
||
|
||
private static void LogError(object message)
|
||
{
|
||
Debug.LogError($"<color=red>EventCubeMeltManager => {message} </color>");
|
||
}
|
||
|
||
private static bool ShouldBuildELog()
|
||
{
|
||
#if UNITY_EDITOR
|
||
return EventCubeMeltLogPolicy.EnableELog;
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
private static void ELog(object message)
|
||
{
|
||
#if UNITY_EDITOR
|
||
if (!EventCubeMeltLogPolicy.EnableELog) return;
|
||
Debug.Log($"<color=orange> EventCubeMeltManager => {message} </color>");
|
||
#endif
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 时间相关
|
||
|
||
public bool CheckOpen()
|
||
{
|
||
//
|
||
if (EventData == null)
|
||
return false;
|
||
//
|
||
if (!IsTimeAllow())
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
public bool IsTimeAllow()
|
||
{
|
||
var now = ZZTimeHelper.UtcNow();
|
||
return now >= StartTime && now <= EndTime;
|
||
}
|
||
|
||
public TimeSpan GetRemainingTime()
|
||
{
|
||
if (EventData == null)
|
||
return TimeSpan.Zero;
|
||
|
||
return EndTime - ZZTimeHelper.UtcNow();
|
||
}
|
||
|
||
#endregion
|
||
|
||
public void OnSettle()
|
||
{
|
||
//throw new NotImplementedException();
|
||
ELog("OnSettle");
|
||
}
|
||
|
||
private void AddItem(int itemId, int count)
|
||
{
|
||
if (EventData?.CollectItems == null)
|
||
return;
|
||
var item = EventData.CollectItems.FirstOrDefault(x => x.ItemId == itemId);
|
||
if (item != null)
|
||
{
|
||
item.Count += count;
|
||
if (item.Count >= item.MaxCount)
|
||
{
|
||
item.Count = item.MaxCount;
|
||
}
|
||
}
|
||
}
|
||
|
||
//- [0,1]
|
||
public float GetCollectProgress()
|
||
{
|
||
var iCount = EventData.CollectItems.Count;
|
||
var iMaxCount = 0;
|
||
var iCollCount = 0;
|
||
// for (var i = 0; i < iCount; ++i)
|
||
foreach (var item in EventData.CollectItems)
|
||
{
|
||
iCollCount += item.Count;
|
||
iMaxCount += item.MaxCount;
|
||
}
|
||
return iCollCount * 1f / iMaxCount;
|
||
}
|
||
|
||
// 获取数据
|
||
public async Task SpawnNewPieceData()
|
||
{
|
||
|
||
}
|
||
public async Task SpawnNewPiece(int index,int clearCount)
|
||
{
|
||
ELog("SpawnNewPiece-> ");
|
||
|
||
var validMeltPieces = await GetValidNewPiece(index,clearCount);
|
||
var pieceItem = WeightedRandom(validMeltPieces);
|
||
if (pieceItem != null && ShouldBuildELog())
|
||
{
|
||
ELog(
|
||
$"SpawnNewPiece slotIndex={index} meltId={pieceItem.MeltId} row={pieceItem?.Row} col={pieceItem?.Col} complexity={pieceItem?.Complexity} complexityWeight={pieceItem.ComplexityWeight} config={string.Join(",", pieceItem.PieceConfig)}");
|
||
}
|
||
|
||
// var entities = validMeltPieces.Where(item => item.MeltId == pieceId).ToList();
|
||
// var entity = entities[Random.Range(0, entities.Count)];
|
||
// var entity = validMeltPieces.Find(item => item.MeltId == pieceId);
|
||
// ELog($"TCM: SpawnNewPiece -> {index} {pieceId} ");
|
||
// EventData.PieceItems[index] = entity;
|
||
// await Task.Run(() =>
|
||
{
|
||
CurrentPieceItems[index] = pieceItem;
|
||
EventData.PieceDatas[index] = GetMeltPieceReal(index);
|
||
SaveData();
|
||
}
|
||
|
||
ELog("SpawnNewPiece-> Finished-> ");
|
||
}
|
||
|
||
private async Task<List<PieceItem>> GetValidNewPiece(int index,int clearCount)
|
||
{
|
||
var validMeltPieces = await GetValidMeltPieceItem(clearCount);
|
||
var lastMeltPiece = EventData.PieceDatas[index];
|
||
// 和上一个不同
|
||
var validMeltPieces1 = DoFilterFirst(validMeltPieces,lastMeltPiece);
|
||
if (validMeltPieces1.Count <= 0)
|
||
{
|
||
return validMeltPieces;
|
||
}
|
||
//- 和全部不同
|
||
var validMeltPieces2 = DoFilterSecond(validMeltPieces1, EventData.PieceDatas);
|
||
if (validMeltPieces2.Count <= 0)
|
||
{
|
||
return validMeltPieces1;
|
||
}
|
||
return validMeltPieces2;
|
||
}
|
||
private List<PieceItem> DoFilterFirst(List<PieceItem> pieceItems, List<int> ints)
|
||
{
|
||
var checkInts = ints.Select(value => value == 0 ? 0 : 99);
|
||
return pieceItems.Where(p => !p.PieceConfig.SequenceEqual(checkInts)).ToList();
|
||
}
|
||
private List<PieceItem> DoFilterSecond(List<PieceItem> pieceItems, List<List<int>> eventDataPieceDatas)
|
||
{
|
||
return pieceItems?.Where(p => !eventDataPieceDatas?.Any(target =>
|
||
{
|
||
var checkInts = target.Select(value => value == 0 ? 0 : 99);
|
||
return p.PieceConfig.SequenceEqual(checkInts);
|
||
}) ?? true)
|
||
.ToList() ?? new List<PieceItem>();
|
||
}
|
||
|
||
// private List<PieceItem> GetValidMeltPieceItemByInitItem(List<int> pieceId, List<int> repValues)
|
||
// {
|
||
// // throw new NotImplementedException();
|
||
// var list = new List<PieceItem>();
|
||
// var grid = ConvertListIntToShape(EventData.BoardData,_boardDimension.x ,_boardDimension.y);
|
||
//
|
||
// foreach (var piece in EventCubeMeltPieceItems)
|
||
// {
|
||
// if (CanPlace(grid, ConvertListIntToShape(piece.PieceConfig,_pieceDimension.x ,_pieceDimension.y),piece.MeltId,out var p ))
|
||
// {
|
||
// piece.Complexity = p.Complexity;
|
||
// list.Add(piece);
|
||
// }
|
||
// }
|
||
// return list;
|
||
// }
|
||
|
||
public static double GaussianWeight(float x, double center = 0.5, double sigma = 1.0)
|
||
{
|
||
var diff = x - center;
|
||
var exponent = -(diff * diff) / (2 * sigma * sigma);
|
||
return Math.Exp(exponent);
|
||
}
|
||
|
||
//[0,1]-> [1,100]
|
||
public static float CosineWeight(float x, float center = 0.5f, double frequency = 2.0 * Math.PI)
|
||
{
|
||
var scaledX = (x - center) * frequency;
|
||
var cosineWeight = (float)(Math.Cos(scaledX) + 1.0F) / 2.0F;
|
||
return cosineWeight * 99.0F + 1.0F;
|
||
}
|
||
|
||
|
||
private async Task<List<PieceItem>> GetValidMeltPieceItem(int clearCount = 0)
|
||
{
|
||
var list = new List<PieceItem>();
|
||
// this.BoardViewSize.x
|
||
|
||
var grid = ConvertListIntToShape(EventData.BoardData,EventData.BoardViewSize.x ,EventData.BoardViewSize.y);
|
||
|
||
ELog($"GetValidMeltPieceItem-> Count = {EventCubeMeltPieceItems.Count}");
|
||
var weightDifficultyParam = EventCubeMeltStageData.WeightDifficultyParam;
|
||
var wdParam1 = weightDifficultyParam[0];
|
||
var wdParam2 = weightDifficultyParam[1];
|
||
var wdParam3 = weightDifficultyParam[2];
|
||
|
||
var priorityList1 = EventCubeMeltPieceItems.Where(item => item.MeltId > 300).ToList();
|
||
await Task.Run(() =>
|
||
{
|
||
foreach (var piece in priorityList1)
|
||
{
|
||
if (CanPlace(grid,
|
||
ConvertListIntToShape(piece.PieceConfig, _pieceDimension.x, _pieceDimension.y),
|
||
piece.MeltId,
|
||
out var p))
|
||
{
|
||
piece.Complexity = p.Complexity;
|
||
piece.ComplexityWeight = piece.Weight +
|
||
(float)wdParam1 * Math.Exp(wdParam2 * p.Complexity + wdParam3 * clearCount);
|
||
piece.Row = p.Row;
|
||
piece.Col = p.Col;
|
||
list.Add(piece);
|
||
}
|
||
} //一次性返回
|
||
});
|
||
|
||
//
|
||
if (list.Count <= 0)
|
||
{
|
||
if (ShouldBuildELog())
|
||
{
|
||
ELog($"GetValidMeltPieceItem priority1Empty boardData={string.Join(",", EventData.BoardData)}");
|
||
}
|
||
// list.Add(EventCubeMeltPieceItems.Find(item => item.MeltId == 101));
|
||
var priorityList2 = EventCubeMeltPieceItems.Where(item => item.MeltId <= 300).ToList();
|
||
// foreach (var piece in priorityList2)
|
||
// {
|
||
// if (CanPlace(grid, ConvertListIntToShape(piece.PieceConfig,_pieceDimension.x ,_pieceDimension.y),piece.MeltId,out var p))
|
||
// {
|
||
// piece.Complexity = p.Complexity;
|
||
// piece.ComplexityWeight = piece.Weight + (float) wdParam1 * Math.Exp(wdParam2 * p.Complexity + wdParam3 * clearCount);
|
||
// piece.Row = p.Row;
|
||
// piece.Col = p.Col;
|
||
// list.Add(piece);
|
||
// }
|
||
// }
|
||
await Task.Run(() =>
|
||
{
|
||
// var tmp = new List<PieceOut>(); //线程内临时列表
|
||
foreach (var piece in priorityList2)
|
||
{
|
||
if (CanPlace(grid, ConvertListIntToShape(piece.PieceConfig, _pieceDimension.x, _pieceDimension.y),
|
||
piece.MeltId,
|
||
out var p))
|
||
{
|
||
piece.Complexity = p.Complexity;
|
||
piece.ComplexityWeight = piece.Weight +
|
||
(float)wdParam1 * Math.Exp(wdParam2 * p.Complexity + wdParam3 * clearCount);
|
||
piece.Row = p.Row;
|
||
piece.Col = p.Col;
|
||
list.Add(piece);
|
||
}
|
||
} //一次性返回
|
||
});
|
||
}
|
||
ELog($"ClearCount count={clearCount}");
|
||
// StringBuilder sb;
|
||
#if UNITY_EDITOR
|
||
var sb = new StringBuilder();
|
||
foreach (var item in list)
|
||
{
|
||
sb.Append(item.MeltId + $"({item.Complexity:F3} , {item.ComplexityWeight:F3}) " );
|
||
}
|
||
ELog($"TCM:GetValidMeltPieceItem-> {sb}");
|
||
#endif
|
||
return list;
|
||
}
|
||
private int[,] ConvertListIntToShape(List<int> listInt,int gridW,int gridH)
|
||
{
|
||
// var width = _pieceDimension.x;
|
||
// var height = _pieceDimension.y;
|
||
var width = gridW;
|
||
var height = gridH;
|
||
|
||
var shape = new int[height,width];
|
||
for (var row = 0; row < height; row++)
|
||
{
|
||
for (var col = 0; col < width; col++)
|
||
{
|
||
shape[row, col] = listInt[row * width + col];
|
||
}
|
||
}
|
||
return shape;
|
||
}
|
||
|
||
// private int[,] ConvertToShape(EventCubeMeltPiece piece)
|
||
// {
|
||
// var width = _pieceDimension.x;
|
||
// var height = _pieceDimension.y;
|
||
//
|
||
// var shape = new int[height,width];
|
||
// var pieceData = piece.PieceConfig[0];
|
||
// for (var row = 0; row < height; row++)
|
||
// {
|
||
// for (var col = 0; col < width; col++)
|
||
// {
|
||
// shape[row, col] = pieceData[row * width + col];
|
||
// }
|
||
// }
|
||
// return shape;
|
||
// }
|
||
|
||
// public void PrintShape(int[,] grid, string tag )
|
||
// {
|
||
// var sb = new StringBuilder();
|
||
// sb.Append(tag);
|
||
// var height = grid.GetLength(0);
|
||
// var width = grid.GetLength(1);
|
||
// for (var i = 0; i < height; i++)
|
||
// {
|
||
// sb.Append("<color=red>");
|
||
// for (var j = 0; j < width; j++)
|
||
// {
|
||
// sb.Append((int)grid[i,j]);
|
||
// if (j < width - 1)
|
||
// sb.Append(", ");
|
||
// }
|
||
// sb.Append("</color> \n");
|
||
// }
|
||
// Debug.Log(sb.ToString());
|
||
// }
|
||
// 方形的
|
||
// private bool CanPlaceDown(int[,] grid, int [,] shape)
|
||
// {
|
||
// ELog("CanPlaceDown -> ");
|
||
// var gridSize = grid.GetLength(0);
|
||
// var shapeSize = shape.GetLength(0);
|
||
// if (shapeSize > gridSize )
|
||
// return false;
|
||
//
|
||
// List<(int row, int col)> shapePositions = new();
|
||
// for (int i = 0; i < shapeSize; i++)
|
||
// {
|
||
// for (int j = 0; j < shapeSize; j++)
|
||
// {
|
||
// if (shape[i, j] != 0 )
|
||
// {
|
||
// shapePositions.Add((i, j));
|
||
// }
|
||
// }
|
||
// }
|
||
// // 如果形状是空的，总是可以放入
|
||
// if (shapePositions.Count == 0)
|
||
// return true;
|
||
//
|
||
// for (var gridRow = 0; gridRow < gridSize; gridRow++)
|
||
// {
|
||
// for (var gridCol = 0; gridCol < gridSize; gridCol++)
|
||
// {
|
||
// // 检查是否可以把形状放在某个位置，使得所有有效格子都在网格内且为空
|
||
// if (CanPlaceShapeAtPosition(grid, shapePositions, gridRow, gridCol))
|
||
// {
|
||
// return true;
|
||
// }
|
||
// }
|
||
// }
|
||
// return false;
|
||
// }
|
||
|
||
private bool CanPlace(int[,] grid, int[,] shape, int pieceId,out ShapePlacement bestPlacementResult)
|
||
{
|
||
ELog($" CanPlace -> {pieceId}");
|
||
|
||
var gridRow = grid.GetLength(0);
|
||
var gridCol = grid.GetLength(1);
|
||
var shapeRow = shape.GetLength(0);
|
||
var shapeCol = shape.GetLength(1);
|
||
|
||
// 收集形状中所有有效格子的位置
|
||
var cells = new List<(int r, int c)>(shapeRow * shapeCol);
|
||
int minR = int.MaxValue, maxR = int.MinValue;
|
||
int minC = int.MaxValue, maxC = int.MinValue;
|
||
|
||
for (int r = 0; r < shapeRow; r++)
|
||
{
|
||
for (int c = 0; c < shapeCol; c++)
|
||
{
|
||
if (shape[r, c] != 0)
|
||
{
|
||
cells.Add((r, c));
|
||
if (r < minR) minR = r;
|
||
if (r > maxR) maxR = r;
|
||
if (c < minC) minC = c;
|
||
if (c > maxC) maxC = c;
|
||
}
|
||
}
|
||
}
|
||
|
||
bestPlacementResult = new ShapePlacement()
|
||
{
|
||
Id = pieceId,
|
||
Shape = (int[,])shape.Clone(),
|
||
Col = int.MinValue,
|
||
Row = int.MinValue,
|
||
Weight = 0,
|
||
Complexity = float.MaxValue,
|
||
};
|
||
|
||
// 若形状没有有效格子，视为可放置
|
||
if (cells.Count == 0)
|
||
{
|
||
bestPlacementResult.Col = 0;
|
||
bestPlacementResult.Row = 0;
|
||
return true;
|
||
}
|
||
|
||
// 有效格子全部进网格的必要偏移范围：
|
||
// 0 <= r + dy <= gr-1 对所有有效 r
|
||
// 0 <= c + dx <= gc-1 对所有有效 c
|
||
var minDy = -minR;
|
||
var maxDy = (gridRow - 1) - maxR;
|
||
var minDx = -minC;
|
||
var maxDx = (gridCol - 1) - maxC;
|
||
|
||
// 无可行偏移的快速剪枝
|
||
if (minDy > maxDy || minDx > maxDx)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
for (int offY = minDy; offY <= maxDy; offY++)
|
||
{
|
||
for (int offX = minDx; offX <= maxDx; offX++)
|
||
{
|
||
bool ok = true;
|
||
|
||
// 检查所有有效格子在该偏移下是否都落在空位(0)
|
||
for (int i = 0; i < cells.Count; i++)
|
||
{
|
||
var cell = cells[i];
|
||
int rr = cell.r + offY;
|
||
int cc = cell.c + offX;
|
||
|
||
// 这里不需要再做边界判断（已由范围剪枝保证）
|
||
if (grid[rr, cc] != 0)
|
||
{
|
||
ok = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (ok)
|
||
{
|
||
var p = CreateNewShapePlacement(offY,offX,shape,grid);
|
||
p.Id = pieceId;
|
||
// ELog($" CanPlace -> p = {p} best = {bestPlacementResult}");
|
||
if (p.Complexity < bestPlacementResult.Complexity)
|
||
bestPlacementResult = p;
|
||
}
|
||
}
|
||
}
|
||
|
||
// ELog($" CanPlace -> {pieceId} bestPlacementResult = {bestPlacementResult}");
|
||
if (bestPlacementResult.Complexity < float.MaxValue)
|
||
{
|
||
// ELog($" CanPlace -> {pieceId} bestPlacementResult = {bestPlacementResult}");
|
||
return true;
|
||
}
|
||
|
||
// dx = 0; dy = 0;
|
||
return false;
|
||
}
|
||
|
||
private ShapePlacement CreateNewShapePlacement(int row, int col,int[,] shape,int [,] grid)
|
||
{
|
||
var simulatedBoard = SimulatePlacement(grid,shape, row, col);
|
||
var pf1 = Calculate(grid);
|
||
var pf = Calculate(simulatedBoard);
|
||
|
||
|
||
return new ShapePlacement()
|
||
{
|
||
Row = row,
|
||
Col = col,
|
||
Shape = shape,
|
||
Weight = 1,
|
||
Complexity = pf - pf1
|
||
};
|
||
}
|
||
|
||
|
||
public static float Calculate(int[,] matrix)
|
||
{
|
||
if (matrix == null)
|
||
return 0;
|
||
|
||
int height = matrix.GetLength(0);
|
||
int width = matrix.GetLength(1);
|
||
|
||
// 创建带边框的矩阵便于计算
|
||
int[,] paddedMatrix = new int[height + 2, width + 2];
|
||
|
||
// 复制原矩阵到中心
|
||
for (int i = 0; i < height; i++)
|
||
{
|
||
for (int j = 0; j < width; j++)
|
||
{
|
||
paddedMatrix[i + 1, j + 1] = matrix[i, j];
|
||
}
|
||
}
|
||
|
||
// 计算边界长度（相邻0-1边的数量）
|
||
int boundaryEdges = 0;
|
||
|
||
for (int i = 1; i <= height; i++)
|
||
{
|
||
for (int j = 1; j <= width; j++)
|
||
{
|
||
if (paddedMatrix[i, j] != 0)
|
||
{
|
||
// 检查四个邻居
|
||
if (paddedMatrix[i - 1, j] == 0) boundaryEdges++; // 上
|
||
if (paddedMatrix[i + 1, j] == 0) boundaryEdges++; // 下
|
||
if (paddedMatrix[i, j - 1] == 0) boundaryEdges++; // 左
|
||
if (paddedMatrix[i, j + 1] == 0) boundaryEdges++; // 右
|
||
}
|
||
}
|
||
}
|
||
|
||
// 计算面积
|
||
int area = 0;
|
||
for (int i = 0; i < height; i++)
|
||
{
|
||
for (int j = 0; j < width; j++)
|
||
{
|
||
if (matrix[i, j] != 0)
|
||
area++;
|
||
}
|
||
}
|
||
|
||
var p = (float)Math.Sqrt(area)* 4F;
|
||
// var x = Math.Exp(p);
|
||
// 边界复杂度 = 边界长度 / 面积
|
||
return area > 0 ? (float)boundaryEdges / p : 0.0F;
|
||
}
|
||
|
||
private int[,] SimulatePlacement(int[,] board, int[,] shape, int row, int col)
|
||
{
|
||
// 创建棋盘的副本
|
||
int[,] simulatedBoard = (int[,])board.Clone();
|
||
|
||
var height = shape.GetLength(0);
|
||
var width = shape.GetLength(1);
|
||
|
||
var boardH = simulatedBoard.GetLength(0);
|
||
var boardW = simulatedBoard.GetLength(1);
|
||
|
||
// 放置形状
|
||
for (int i = 0; i < height; i++)
|
||
{
|
||
for (int j = 0; j < width; j++)
|
||
{
|
||
var rowI = row + i;
|
||
var colJ = col + j;
|
||
if (rowI < 0 || rowI >= boardH)
|
||
continue;
|
||
if (colJ < 0 || colJ >= boardW)
|
||
continue;
|
||
|
||
if (shape[i, j] != 0)
|
||
{
|
||
simulatedBoard[rowI, colJ] = 1; // 模拟形状，都放置成 1 先
|
||
}
|
||
}
|
||
}
|
||
return simulatedBoard;
|
||
}
|
||
|
||
private static bool CanPlaceShapeAtPosition(int[,] grid, List<(int row, int col)> validCells, int referenceRow, int referenceCol)
|
||
{
|
||
var gridSize = grid.GetLength(0);
|
||
|
||
// 我们尝试把形状的某个有效格子对齐到网格的(referenceRow, referenceCol)
|
||
// 然后检查其他有效格子是否都在网格内且为空
|
||
|
||
// 对第一个有效格子作为对齐点
|
||
var firstCell = validCells[0];
|
||
|
||
// 计算偏移量：如果要把这个有效格子放在(referenceRow, referenceCol)
|
||
// 那么形状的左上角应该在：
|
||
int startRow = referenceRow - firstCell.row;
|
||
int startCol = referenceCol - firstCell.col;
|
||
|
||
// 检查所有有效格子
|
||
foreach (var (shapeRow, shapeCol) in validCells)
|
||
{
|
||
int gridRow = startRow + shapeRow;
|
||
int gridCol = startCol + shapeCol;
|
||
|
||
// 检查是否在网格内
|
||
if (gridRow < 0 || gridRow >= gridSize || gridCol < 0 || gridCol >= gridSize)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 检查网格位置是否为空
|
||
if (grid[gridRow, gridCol] != 0)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
// 调试用，看看
|
||
public static List<(int row, int col)> FindAllPositions(int[,] grid, int[,] shape)
|
||
{
|
||
int M = grid.GetLength(0);
|
||
int N = shape.GetLength(0);
|
||
List<(int row, int col)> positions = new List<(int, int)>();
|
||
|
||
if (N > M) return positions;
|
||
|
||
// 预计算形状的非空位置
|
||
List<(int row, int col)> shapePositions = new List<(int, int)>();
|
||
for (int i = 0; i < N; i++)
|
||
{
|
||
for (int j = 0; j < N; j++)
|
||
{
|
||
if (shape[i, j] != 0)
|
||
{
|
||
shapePositions.Add((i, j));
|
||
}
|
||
}
|
||
}
|
||
|
||
// 遍历所有可能的放置位置
|
||
for (int i = 0; i <= M - N; i++)
|
||
{
|
||
for (int j = 0; j <= M - N; j++)
|
||
{
|
||
bool canPlace = true;
|
||
|
||
foreach (var (si, sj) in shapePositions)
|
||
{
|
||
int gi = i + si;
|
||
int gj = j + sj;
|
||
|
||
if (grid[gi, gj] != 0)
|
||
{
|
||
canPlace = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (canPlace)
|
||
{
|
||
positions.Add((i, j));
|
||
}
|
||
}
|
||
}
|
||
|
||
return positions;
|
||
}
|
||
|
||
public List<int> GetMeltPieceReal(int index,int isRepValue = 1,bool isPowerSet = false)
|
||
{
|
||
var pieceItem = CurrentPieceItems[index];
|
||
var meltPiece = EventCubeMeltPieces.FirstOrDefault(meltPiece => meltPiece.ID == pieceItem.MeltId );
|
||
ELog($"GetMeltPieceReal-> 12 {index} {meltPiece.ID} ,{meltPiece?.PieceConfig} {EventCubeMeltPieces.Count}");
|
||
|
||
var prop = EventCubeMeltCollectionData.CollectingItemProb;
|
||
|
||
var meltPieceConfig = pieceItem.PieceConfig;
|
||
var rate = meltPiece?.DoubleItemProb ?? 0;
|
||
var num = 1;
|
||
if (isPowerSet)
|
||
{
|
||
prop = new List<float> { 1 };
|
||
rate = 0;
|
||
}
|
||
if (rate > 0)
|
||
{
|
||
var r = Random.value; // [0,1)
|
||
if (r < rate)
|
||
{
|
||
num = 2;
|
||
}
|
||
}
|
||
var rand = GetRepValue();
|
||
var collectIds = GetCollectionIds();
|
||
// var randWeight = GetRepValuesWithWeight(rand);
|
||
|
||
// var thePieceData = (isRepValue == 0) ?meltPieceConfig : SlotsGenerator.GenerateSlots(num,prop,meltPieceConfig, rand);
|
||
var thePieceData2 = (isRepValue == 0) ?meltPieceConfig : SlotsGenerator.GenerateSlots2(num,prop,meltPieceConfig,rand,collectIds);
|
||
return thePieceData2;
|
||
//return meltPieceConfig;
|
||
}
|
||
|
||
public List<int> GetMeltPieceData(int index)
|
||
{
|
||
var pieceData = EventData.PieceDatas.ElementAtOrDefault(index);
|
||
return pieceData;
|
||
}
|
||
|
||
private List<int> GetCollectionIds()
|
||
{
|
||
var set = new HashSet<int>();
|
||
var collectionItems = GetCollectionItems();
|
||
foreach (var kv in collectionItems)
|
||
{
|
||
for (var i = 0; i < kv.Value.RequiredCount; ++i)
|
||
{
|
||
set.Add(kv.Key);
|
||
}
|
||
}
|
||
return set.ToList();
|
||
}
|
||
// 返回可替换的有效材料值
|
||
private List<int> GetRepValue()
|
||
{
|
||
var set = new HashSet<int>();
|
||
var collectionItems = GetCollectionItems();
|
||
foreach (var kv in collectionItems)
|
||
{
|
||
for (var i = 0; i < kv.Value.RequiredCount; ++i)
|
||
{
|
||
set.Add(kv.Key);
|
||
}
|
||
}
|
||
|
||
//
|
||
|
||
// 删除已经收集完的Item
|
||
var hasCollectItems = EventData.CollectItems;
|
||
foreach (var item in hasCollectItems.Where(item => item.Count >= item.MaxCount))
|
||
{
|
||
set.Remove(item.ItemId);
|
||
}
|
||
if (ShouldBuildELog())
|
||
{
|
||
ELog($"GetRepValue candidates={string.Join(",", set)}");
|
||
}
|
||
return set.ToList();
|
||
}
|
||
|
||
public void UpdateCurrentStage()
|
||
{
|
||
var isFirstLoop = EventData.Cycle == 0 ;
|
||
var stageList = isFirstLoop ? EventCubeMeltMainData?.StageFirstList : EventCubeMeltMainData?.StageLoopList ?? new List<int>();
|
||
|
||
var stageId = stageList?.ElementAtOrDefault(EventData.CurrentStagetId);
|
||
ELog($"UpdateCurrentStage -> {EventData.CurrentStagetId}, {stageId}");
|
||
EventCubeMeltStageData = _tables.TbEventCubeMeltStage.DataList.FirstOrDefault(data => data.ID == stageId);
|
||
EventCubeMeltCollectionData = _tables.TbEventCubeMeltCollection.DataList.FirstOrDefault(data => data.ID == stageId);
|
||
EventCubeMeltConfig = EventCubeMeltStageData?.StageConfig ?? new List<List<int>>();
|
||
|
||
EventStageList = stageList;
|
||
StageCount = EventStageList?.Count ?? 0;
|
||
var boardSize = EventCubeMeltStageData?.BoardSize;
|
||
if (boardSize == null)
|
||
{
|
||
LogError("Error Board No BoardSize ");
|
||
boardSize = new List<int>{8,8};
|
||
}
|
||
// BoardViewSize = new Vector2Int(boardSize[0], boardSize[1]);
|
||
}
|
||
|
||
private void UpdateNewCollect()
|
||
{
|
||
EventData.CollectItems.Clear();
|
||
var items = GetCollectionItems();
|
||
foreach (var kv in items)
|
||
{
|
||
EventData.CollectItems.Add(new CollectItem
|
||
{
|
||
ItemId = kv.Key,
|
||
ItemTrueId = kv.Value.TrueId,
|
||
Count = 0,
|
||
MaxCount = kv.Value.RequiredCount
|
||
});
|
||
}
|
||
}
|
||
public string GetCollectIconByType(int typeId)
|
||
{
|
||
var item = EventCubeMeltItems.FirstOrDefault(elem => elem.Type == typeId);
|
||
return item != null ? item.Icon : string.Empty;
|
||
}
|
||
|
||
public string GetCollectIconById(int typeId)
|
||
{
|
||
var item = EventCubeMeltItems.FirstOrDefault(elem => elem.ID == typeId);
|
||
return item != null ? item.Icon : string.Empty;
|
||
}
|
||
|
||
|
||
// 收集
|
||
public void AddCollect(Dictionary<int,int> values)
|
||
{
|
||
if (values is not { Count: > 0 })
|
||
{
|
||
return;
|
||
}
|
||
if (ShouldBuildELog())
|
||
{
|
||
var valueStrings = string.Join(", ", values.Select(kv => $"{kv.Key}: {kv.Value}"));
|
||
ELog($"LCM-> AddCollect -> {valueStrings}");
|
||
}
|
||
foreach (var kv in values)
|
||
{
|
||
AddItem(kv.Key, kv.Value);
|
||
}
|
||
}
|
||
public bool IsThisCollectFinished()
|
||
{
|
||
var items = EventData.CollectItems;
|
||
var isFinish = items.All(item => item.Count >= item.MaxCount);
|
||
return isFinish;
|
||
}
|
||
|
||
public bool IsGetStageReward()
|
||
{
|
||
var isGet = EventData.CollectRewardsId.Contains(EventData.CurrentStagetId);
|
||
return isGet;
|
||
}
|
||
|
||
public bool IsGetFinalReward()
|
||
{
|
||
return EventData.IsFinalRewardGet;
|
||
}
|
||
|
||
private async Task UpdateNextBoardAndPieces()
|
||
{
|
||
ELog("UpdateNextBoardAndPieces()");
|
||
CreateNewBoard();
|
||
await CreateNewPieces();
|
||
UpdateNewCollect();
|
||
SaveData();
|
||
}
|
||
|
||
public bool IsFinishAllStage() => EventData.CurrentStagetId >= StageCount - 1;
|
||
|
||
public async void UpdateToNextStage()
|
||
{
|
||
EventData.CurrentStagetId++;
|
||
if (EventData.CurrentStagetId > StageCount -1)
|
||
{
|
||
OnFinish();
|
||
return;
|
||
}
|
||
|
||
|
||
UpdateCurrentStage();
|
||
await UpdateNextBoardAndPieces();
|
||
GContext.Publish(new EventCubeMeltForNextStage());
|
||
}
|
||
|
||
public void GenerateNextStageData()
|
||
{
|
||
EventData.CurrentStagetId++;
|
||
if (EventData.CurrentStagetId > StageCount -1)
|
||
{
|
||
// ClearData();
|
||
// Init();
|
||
GenerateNewLoopFirstData();
|
||
}
|
||
UpdateCurrentStage();
|
||
_ = UpdateNextBoardAndPieces();
|
||
}
|
||
|
||
private void GenerateNewLoopFirstData()
|
||
{
|
||
var tickCount = EventData.TicketCount;
|
||
var cycle = EventData.Cycle;
|
||
ClearData();
|
||
Init();
|
||
EventData.TicketCount = tickCount;
|
||
EventData.FirstOpen = false;
|
||
EventData.Cycle = cycle + 1;
|
||
GContext.container.Resolve<FishingEventData>().SaveTransitionData(EventData.EventId, EventData.TicketCount);
|
||
SaveData();
|
||
}
|
||
|
||
public bool PlayGetStageReward()
|
||
{
|
||
ELog("AddStageRewards");
|
||
var dropId = EventCubeMeltCollectionData.CollectingReward;
|
||
var playerItemData = GContext.container.Resolve<PlayerItemData>();
|
||
|
||
var changeSource = new ChangeSource(EventData.EventId, "Event_Minigame1", "Event_Minigame1_Block", "StageReward");
|
||
playerItemData.AddItemByDropLureInflation(EventData.InflationRate,dropId,changeSource);
|
||
GContext.Publish(new ShowData());
|
||
EventData.CollectRewardsId.Add(EventData.CurrentStagetId);
|
||
SaveData();
|
||
return true;
|
||
}
|
||
|
||
// public bool PlayGetFinalRewards()
|
||
// {
|
||
// ELog("PlayGetFinalRewards-> ");
|
||
//
|
||
// var dropId = EventCubeMeltMainData.FinalReward;
|
||
// var playerItemData = GContext.container.Resolve<PlayerItemData>();
|
||
// var changeSource = new ChangeSource(EventData.EventId, "Event_Minigame1", "Event_Minigame1_Block", "StageReward");
|
||
// playerItemData.AddItemByDropLureInflation(null, dropId,changeSource);
|
||
// GContext.Publish(new ShowData());
|
||
//
|
||
// EventData.IsFinalRewardGet = true;
|
||
// SaveData();
|
||
// return true;
|
||
// }
|
||
|
||
public void OnFinish()
|
||
{
|
||
ELog("OnFinsish()");
|
||
ReOpen();
|
||
}
|
||
|
||
public void ReOpen()
|
||
{
|
||
GenerateNewLoopFirstData();
|
||
GContext.Publish(new EventCubemeltExitAct());
|
||
}
|
||
|
||
public void UpdateGridData(List<int> gridData)
|
||
{
|
||
EventData.BoardData = gridData;
|
||
SaveData();
|
||
}
|
||
|
||
//-
|
||
// private Vector2Int _boardDimension;
|
||
private Vector2Int _pieceDimension;
|
||
// public void SetBoardDimension(Vector2Int dimension)
|
||
// {
|
||
// _boardDimension = dimension;
|
||
// }
|
||
|
||
public void SetPieceDimension(Vector2Int dimension)
|
||
{
|
||
_pieceDimension = dimension;
|
||
}
|
||
|
||
|
||
private EventCubeMeltData PrevData { get; set; }
|
||
|
||
private EventCubeMeltData NextData { get; set; }
|
||
|
||
//-
|
||
private List<int> PrevBoardData { get; set; }
|
||
|
||
public List<List<int>> PrevPieceDatas { set; get; }
|
||
|
||
private List<int> CurrentBoardData { get; set; }
|
||
|
||
public List<List<int>> CurrentPieceDatas { set; get; }
|
||
|
||
// -当前的索引
|
||
public int GuideIndex { get; set; }
|
||
|
||
public void SaveDataForPrev()
|
||
{
|
||
// PrevData = EventData.ShallowClone();
|
||
//ELog($"SaveDataForPrev()-> {JsonConvert.SerializeObject(PrevData)}");
|
||
#if UNITY_EDITOR
|
||
PrevBoardData = EventData.BoardData.ToList();
|
||
PrevPieceDatas = EventData.PieceDatas.Select(innerList => new List<int>(innerList)).ToList();
|
||
#endif
|
||
}
|
||
|
||
public void SaveDataForNow()
|
||
{
|
||
#if UNITY_EDITOR
|
||
CurrentBoardData = EventData.BoardData.ToList();
|
||
CurrentPieceDatas = EventData.PieceDatas.Select(innerList => new List<int>(innerList)).ToList();
|
||
SaveData();
|
||
#endif
|
||
}
|
||
|
||
public void RestoreData()
|
||
{
|
||
EventData.BoardData = CurrentBoardData.ToList();
|
||
EventData.PieceDatas = CurrentPieceDatas.Select(innerList => new List<int>(innerList)).ToList();
|
||
SaveData();
|
||
}
|
||
|
||
public void LoadPrevData()
|
||
{
|
||
EventData.BoardData = PrevBoardData.ToList();
|
||
EventData.PieceDatas = PrevPieceDatas.Select(innerList => new List<int>(innerList)).ToList();
|
||
if (ShouldBuildELog())
|
||
{
|
||
ELog($"LoadPrevData()-> {JsonConvert.SerializeObject(EventData)}");
|
||
}
|
||
|
||
SaveData();
|
||
}
|
||
|
||
public bool IsUnCollectValue(int valueType)
|
||
{
|
||
var typeItem = EventCubeMeltItems.FirstOrDefault(elem => elem.Type == valueType);
|
||
var param = typeItem?.Param ?? 0;
|
||
return param > 1;
|
||
}
|
||
|
||
public List<int> ReplaceValue(int valueType)
|
||
{
|
||
var typeItem = EventCubeMeltItems.FirstOrDefault(elem => elem.Type == valueType);
|
||
var param = typeItem?.Param ?? 0;
|
||
if (param <= 1)
|
||
{
|
||
var values = new List<int> { valueType };
|
||
if (ShouldBuildELog())
|
||
{
|
||
ELog($"LCM-> ReplaceValue -> {valueType} -> {string.Join(", ", values)}");
|
||
}
|
||
return values;
|
||
}
|
||
// else
|
||
// {
|
||
// return new List<int>();
|
||
// }
|
||
|
||
var list = new List<int>();
|
||
var validList = GetRepValue();
|
||
for (var i = 0; i < param; i++)
|
||
{
|
||
var va = validList[Random.Range(0, validList.Count)];
|
||
list.Add(va);
|
||
}
|
||
if (ShouldBuildELog())
|
||
{
|
||
ELog($"LCM-> ReplaceValue -> {valueType} -> {string.Join(", ", list)}");
|
||
}
|
||
return list;
|
||
}
|
||
|
||
//-
|
||
public List<List<int>> GetBombValues(List<int> bombValues)
|
||
{
|
||
var p = new List<List<int>>();
|
||
foreach (var bombValue in bombValues)
|
||
{
|
||
p.Add(ReplaceValue(bombValue));
|
||
}
|
||
return p;
|
||
}
|
||
public void JumpToStage(int newStep)
|
||
{
|
||
// // var newStep = newDisStep - 1;
|
||
ELog($"JumpToStage -> {newStep }");
|
||
if (newStep < 0)
|
||
return;
|
||
|
||
EventData.CurrentStagetId = newStep - 1;
|
||
|
||
GContext.Publish(new EventCubeMeltStageFinish());
|
||
UpdateToNextStage();
|
||
|
||
// EventData.CurrentStagetId = newStep;
|
||
// if (EventData.CurrentStagetId > StageCount -1)
|
||
// {
|
||
// OnFinish();
|
||
// return;
|
||
// }
|
||
// //-
|
||
// EventData.IsFinished = false;
|
||
// UpdateCurrentStage();
|
||
// UpdateNextBoardAndPieces();
|
||
// GContext.Publish(new EventCubeMeltForNextStage());
|
||
}
|
||
//-检查当前管卡是否已经完
|
||
public bool IsOverStage()
|
||
{
|
||
return EventData.CurrentStagetId >= StageCount;
|
||
}
|
||
|
||
public void FixOverStage()
|
||
{
|
||
if (IsOverStage())
|
||
{
|
||
EventData.CurrentStagetId = StageCount - 1;
|
||
}
|
||
|
||
var isFinishThisStage = IsThisCollectFinished();
|
||
var isGetStageReward = IsGetStageReward();
|
||
if (EventData.CurrentStagetId < StageCount - 1)
|
||
{
|
||
if (isFinishThisStage && isGetStageReward)
|
||
{
|
||
GenerateNextStageData();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// var isFinalGet = IsGetFinalReward();
|
||
if (isFinishThisStage && isGetStageReward)
|
||
{
|
||
GenerateNextStageData();
|
||
}
|
||
}
|
||
}
|
||
|
||
public bool CheckCollectFinish(List<int> listItems)
|
||
{
|
||
var items = EventData.CollectItems;
|
||
return items.Any(item => listItems.Contains(item.ItemId) && item.Count == item.MaxCount);
|
||
}
|
||
|
||
public bool CheckBombFinsh(List<int> listBomb)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
public bool IsInGuideAnim()
|
||
{
|
||
return EventData?.IsInGuide ?? false ;
|
||
}
|
||
|
||
public void SetIsInGuideAnim(bool isInGuide)
|
||
{
|
||
// IsInGuide = isInGuide;
|
||
EventData.IsInGuide = isInGuide;
|
||
SaveData();
|
||
}
|
||
|
||
public int GetFinalReward()
|
||
{
|
||
ELog("GetFinalReward");
|
||
var finalStage = StageCount - 1;
|
||
// var isFirstLoop = EventData.Cycle == 0 ;
|
||
// var stageList = isFirstLoop ? EventCubeMeltMainData?.StageFirstList : EventCubeMeltMainData?.StageLoopList;
|
||
// var stageId = stageList?.ElementAtOrDefault(finalStage);
|
||
var stageId = EventStageList?.ElementAtOrDefault(finalStage);
|
||
var cubeMeltData = _tables.TbEventCubeMeltCollection.DataList.FirstOrDefault(data => data.ID == stageId);
|
||
return cubeMeltData?.CollectingReward?? 0;
|
||
}
|
||
} |