public string Evaluate(PieceData pieceData)
{
if (pieceData == null)
{
return(null);
}
if (m_checked.Contains(pieceData))
{
return(null);
}
string color = pieceData.m_color;
HashSet <PieceData> group = CombinationUtility.GetGroup(pieceData, x => x.m_color == color);
m_checked.UnionWith(group);
if (group.Count >= MinCount)
{
return(string.Format(KeyFormat, color, group.Count));
}
else
{
return(null);
}
}
public Piece Create(PieceData pieceData)
{
if (pieceData == null)
{
return(null);
}
var blockPrefab = m_blockPrefabs.FirstOrDefault(b => b.m_colorName == pieceData.m_color && b.m_shapeName == pieceData.m_shape);
if (blockPrefab?.m_prefab == null)
{
return(null);
}
var parent = Instantiate(m_parentPrefab, Vector3.zero, Quaternion.identity);
parent.m_pieceData = pieceData;
foreach (var pos in pieceData.m_positions)
{
var position = new Vector3(pos.x, pos.y, 0f) * m_blockSize;
var block = Instantiate(blockPrefab.m_prefab, position, Quaternion.identity, parent.transform);
}
return(parent);
}
public Piece Create(PieceData pieceData)
{
if (pieceData == null)
{
return(null);
}
var targetBlockInfo = m_blockInfoHolderList.FirstOrDefault(b => b.m_colorName == pieceData.m_color && b.m_shapeName == pieceData.m_shape);
if (targetBlockInfo == null)
{
return(null);
}
var parent = Instantiate(m_parentPrefab, Vector3.zero, Quaternion.identity);
parent.m_pieceData = pieceData;
foreach (var pos in pieceData.m_positions)
{
var position = new Vector3(pos.x, pos.y, 0f) * m_blockSize;
var blockSr = Instantiate(m_blockPrefab, position, Quaternion.identity, parent.transform);
blockSr.sprite = targetBlockInfo.m_sprite;
var frameSprites = GetNeedFrameList(pos, pieceData.m_positions);
foreach (var frameSprite in frameSprites)
{
var frameObj = Instantiate(m_framePrefab, Vector3.zero, Quaternion.identity, blockSr.transform);
frameObj.sprite = frameSprite;
frameObj.transform.localPosition = Vector3.zero;
}
}
return(parent);
}
public Piece Create(PieceData pieceData)
{
if (pieceData == null)
{
return(null);
}
var targetBlockInfo = m_blockInfoHolderList.FirstOrDefault(b => b.BlockInfo.m_colorName == pieceData.m_color && b.BlockInfo.m_shapeName == pieceData.m_shape).BlockInfo;
if (targetBlockInfo == null)
{
return(null);
}
var parent = Instantiate(m_parentPrefab, Vector3.zero, Quaternion.identity);
parent.m_pieceData = pieceData;
foreach (var pos in pieceData.m_positions)
{
var position = new Vector3(pos.x, pos.y, 0f) * m_blockSize;
var blockSr = Instantiate(m_blockPrefab, position, Quaternion.identity, parent.transform);
blockSr.sprite = GetAppropriateSprite(pos, pieceData.m_positions, targetBlockInfo);
}
return(parent);
}
public void PlacePiece(Piece piece, Vector2Int[] positions)
{
PieceData pieceData = GetPieceData(piece, positions);
Services.PieceConnection.Add(pieceData);
Services.Board.Place(positions);
}
private bool GetOrigin(PieceData pieceData, out Vector2Int origin)
{
List <Vector2Int> origins = new List <Vector2Int>();
for (int x = m_rangeX.x; x < m_rangeX.y; x++)
{
for (int y = m_rangeY.x; y < m_rangeY.y; y++)
{
var o = new Vector2Int(x, y);
if (!Services.Board.CanPlace(pieceData.m_positions.Select(p => p + o)))
{
continue;
}
origins.Add(o);
}
}
if (origins.Count > 0)
{
origin = origins[Random.Range(0, origins.Count)];
return(true);
}
else
{
origin = Vector2Int.zero;
return(false);
}
}
/// <summary>
/// 色と形はこちらで決定する
/// 配置は 「大きさは指定のものだけをしてい」「候補の配置をランダムに回転したものを指定」
/// </summary>
/// <returns></returns>
public IEnumerable <PieceData> GetCandidates()
{
var enableColorList = m_colorList.Where(x => x.Value == true).ToArray();
var enablShapeList = m_shapeList.Where(x => x.Value == true).ToArray();
//色と形の決定
int enableColorIndex = UnityEngine.Random.Range(0, enableColorList.Length);
var colorIndex = m_colorList.IndexOf(enableColorList[enableColorIndex]);
int enableShapeIndex = UnityEngine.Random.Range(0, enablShapeList.Length);
var shapeIndex = m_shapeList.IndexOf(enablShapeList[enableShapeIndex]);
//候補の決定
for (int i = 0; i < m_sizeList.Count; i++)
{
if (!m_sizeList[i])
{
continue;
}
foreach (var data in m_positions[i])
{
var posShape = RotateRandom(data);
yield return(PieceData.Create(Constants.ColorNames[colorIndex], Constants.ShapeNames[shapeIndex], posShape));
}
}
}
private void Start()
{
Services.BonusSpaceInfo = this;
//ピースの配置データはIPieceDataList継承クラスで生成 現状登録されているtextを書き換えると変わるようになっている
m_PositionDataList = GetComponent <IPieceDataList>().m_PositionDataList;
m_nowPieceData = CreateRandomPiece();
m_OnSubmitListener.Subscribe(() => m_nowPieceData = CreateRandomPiece()).DisposeOnDestroy(gameObject);
}
public IEnumerable <PieceData> GetCandidates()
{
yield return(PieceData.Create(Constants.ColorNames[0], Constants.ShapeNames[0], new Vector2Int[]
{
new Vector2Int(0, 0),
new Vector2Int(1, 0),
new Vector2Int(2, 0),
}));
}
private bool IsContact(PieceData piece1, PieceData piece2)
{
foreach (var pos in piece1.m_positions)
{
if (piece2.m_positions.Any(p => IsNeighbor(p, pos)))
{
return(true);
}
}
return(false);
}
public void PlacePiece(Piece piece, Vector2Int[] positions, bool applyBonusSpace = true)
{
PieceData pieceData = GetPieceData(piece, positions);
Services.PieceConnection.Add(pieceData);
Services.Board.Place(positions);
if (applyBonusSpace)
{
ApplyBonusSpace();
}
}
private void CheckCombinations(PieceData piece, ref Dictionary <string, int> combinations)
{
foreach (var combo in Services.Combinations)
{
var result = combo.Evaluate(piece);
if (result == null)
{
continue;
}
combinations[result] = (combinations.ContainsKey(result)) ? combinations[result] + 1 : 1;
}
}
PieceData CreateRandomPiece()
{
int colorIndex = UnityEngine.Random.Range(0, Constants.ColorNames.Count);
int shapeIndex = UnityEngine.Random.Range(0, Constants.ShapeNames.Count);
int positionDataIndex = UnityEngine.Random.Range(0, m_PositionDataList.Count);
if (m_isOutLog)
{
OutLog(m_PositionDataList[positionDataIndex]);
}
return(PieceData.Create(Constants.ColorNames[colorIndex], Constants.ShapeNames[shapeIndex], m_PositionDataList[positionDataIndex]));
}
public void Remove(PieceData piece)
{
if (!m_pieces.Contains(piece))
{
return;
}
foreach (var neighbor in m_neighbors[piece])
{
m_neighbors[neighbor].Remove(piece);
}
m_neighbors.Remove(piece);
m_pieces.Remove(piece);
}
public void Add(PieceData piece)
{
if (m_pieces.Contains(piece))
{
return;
}
m_pieces.Add(piece);
m_neighbors[piece] = CreateNeighborList(piece);
foreach (var neighbor in m_neighbors[piece])
{
m_neighbors[neighbor].Add(piece);
}
}
private PieceData GetPieceData(Piece piece, Vector2Int[] positions)
{
if (m_pieceData.ContainsKey(piece))
{
var data = m_pieceData[piece];
data.m_positions = positions;
}
else
{
var data = PieceData.Create(piece.m_pieceData, positions);
m_pieceData.Add(piece, data);
}
return(m_pieceData[piece]);
}
private void ApplyBonusSpace()
{
foreach (var space in m_spaces)
{
Services.Board.Remove(space.m_positions);
Services.PieceConnection.Remove(space);
}
m_spaces.Clear();
foreach (var bonus in Services.BonusSpaceInfo.GetBonusPiece())
{
if (bonus == null)
{
continue;
}
var origins = Services.BonusSpaceChecker.GetBonusSpaceOrigins(bonus.m_positions);
if (origins == null)
{
continue;
}
foreach (var origin in origins)
{
var space = PieceData.Create(bonus, bonus.m_positions.Select(p => p + origin).ToArray());
m_spaces.Add(space);
Services.PieceConnection.Add(space);
}
}
Debug.Log($"Bonus: {m_spaces.Count}");
// 盤面の評価を行う.
m_combinations.Clear();
Services.Combinations.ForEach(x => x.SetupBeforeEvaluate());
foreach (var piece in m_pieceData.Values)
{
CheckCombinations(piece, ref m_combinations);
}
foreach (var space in m_spaces)
{
CheckCombinations(space, ref m_combinations);
}
m_combinationCalculator.UpdateBoardScore(m_combinations);
}
private List <PieceData> CreateNeighborList(PieceData pieceData)
{
List <PieceData> neighbors = new List <PieceData>();
foreach (var p in m_pieces)
{
if (p == pieceData)
{
continue;
}
if (!IsContact(p, pieceData))
{
continue;
}
neighbors.Add(p);
}
return(neighbors);
}
private List <Vector2Int> GetEnablePlaces(PieceData piece)
{
List <Vector2Int> places = new List <Vector2Int>();
for (int x = m_rangeX.x; x <= m_rangeX.y; x++)
{
for (int y = m_rangeY.x; y <= m_rangeY.y; y++)
{
var pos = new Vector2Int(x, y);
if (DisablePlaces?.Any(p => p == pos) == true)
{
continue;
}
if (Services.Board.CanPlace(piece.m_positions.Select(p => p + pos)))
{
places.Add(pos);
}
}
}
return(places);
}
public static HashSet <PieceData> GetGroup(PieceData pieceData, Func <PieceData, bool> filter)
{
HashSet <PieceData> group = new HashSet <PieceData>();
Queue <PieceData> pieces = new Queue <PieceData>();
pieces.Enqueue(pieceData);
while (pieces.Count != 0)
{
var piece = pieces.Dequeue();
if (!filter.Invoke(piece))
{
continue;
}
group.Add(piece);
var neighbors = Services.PieceConnection.GetNeighbors(piece);
if (neighbors == null)
{
continue;
}
foreach (var neighbor in neighbors)
{
if (neighbor == null)
{
continue;
}
if (group.Contains(neighbor))
{
continue;
}
pieces.Enqueue(neighbor);
}
}
return(group);
}
public IEnumerable <Piece> CreateInitialPieces()
{
if (m_colors.All(x => !x))
{
yield break;
}
if (m_shapes.All(x => !x))
{
yield break;
}
if (m_sizes.All(x => !x))
{
yield break;
}
List <PieceData> pieces = new List <PieceData>();
for (int i = 0; i < m_count; i++)
{
var color = Constants.ColorNames[GetRandomIndex(m_colors)];
var shape = Constants.ShapeNames[GetRandomIndex(m_shapes)];
var positionGroups = m_positions[GetRandomIndex(m_sizes)];
var positions = RotateRandom(positionGroups[Random.Range(0, positionGroups.Length)]);
pieces.Add(PieceData.Create(color, shape, positions));
}
foreach (var data in pieces)
{
if (!GetOrigin(data, out Vector2Int origin))
{
continue;
}
var piece = Services.PieceObjectFactory.Create(data);
Services.PiecePosition.SetPiecePosition(piece, origin);
yield return(piece);
}
}
/// <summary>常にred, 0の1マス</summary>
public IEnumerable <PieceData> GetBonusPiece()
{
yield return(PieceData.Create(Constants.ColorNames[0], Constants.ShapeNames[0], new Vector2Int[] { Vector2Int.zero, }));
}
/// <summary>typeは同じ, positionsは違うものをnewして作成</summary>
public static PieceData Create(PieceData piece, Vector2Int[] positions)
{
return(new PieceData(piece.m_color, piece.m_shape, positions));
}
public IEnumerable <PieceData> GetNeighbors(PieceData piece)
{
return((m_neighbors.ContainsKey(piece)) ? m_neighbors[piece]: null);
}
