/// <summary>
/// Generate a hexagon element with match type from allowable color range.
/// If bomb has to be dropped it add bomb to the hexagon element.
/// </summary>
public void Generate(bool generateBomb = false)
{
Array array = Enum.GetValues(typeof(MatchType));
MatchType matchType = (MatchType)array.GetValue(UnityEngine.Random.Range(1, colorNo + 1)); // No empty
this.hexagonElement = new HexagonElement(matchType, new BombInfo(generateBomb, generateBomb ? this.bombLifeTime : 0));
}
/// <summary>
/// Check grid to decrease every bomb timer with every user action.
/// If any bomb timer reaches to 0, then send this information to end the game.
/// </summary>
public BombEvent BombCheck(ref HexagonGrid grid)
{
BombEvent bombEvent = new BombEvent(false, new List <BombElement>());
for (int x = 0; x < grid.width; x++)
{
for (int y = 0; y < grid.height; y++)
{
if (!(bool)grid.GetElement(x, y)?.bombInfo.hasBomb) // If hexagon element does not have bomb then continue
{
continue;
}
HexagonElement hexagonElement = (HexagonElement)grid.GetElement(x, y);
int bombTimer = hexagonElement.bombInfo.bombLeftMove;
bombTimer--;
if (bombTimer <= 0) // Bomb time reaches to zero end the game
{
bombEvent.isBombeExploded = true;
Debug.Log("Bomb exploded at: (" + x + ", " + y + ")");
}
grid.SetElement(x, y, new HexagonElement(hexagonElement.matchType, new BombInfo(hexagonElement.bombInfo.hasBomb, bombTimer)));
bombEvent.bombElements.Add(new BombElement(new Vector2(x, y), new BombInfo(true, bombTimer))); // Send list of bomb info with their timer to renew UI and such
}
}
return(bombEvent);
}
/// <summary>
/// Move grid element to new destination specified with offset values.
/// The left grid will become empty for the vacancy.
/// </summary>
public Tuple <int, int> Move(HexagonGrid grid, int x, int y, HexagonElement?hexagonElement = null)
{
HexagonElement element = hexagonElement == null ? new HexagonElement(MatchType.empty) : (HexagonElement)hexagonElement;
bool valid = grid.IsValid(x, y);
if (valid)
{
element = (HexagonElement)grid.GetElement(x, y);
}
if (element.matchType == MatchType.empty)
{
return(null);
}
foreach (Tuple <int, int> offset in offsets)
{
var dx = offset.Item1;
var dy = offset.Item2;
if (grid.GetMatchType(x + dx, y + dy) == MatchType.empty)
{
grid.SetElement(x + dx, y + dy, element);
if (valid)
{
grid.SetElement(x, y, new HexagonElement(MatchType.empty));
}
return(new Tuple <int, int>(x + dx, y + dy));
}
}
return(null);
}
/// <summary>
/// With match element, clone mock grids to simulate the situation if the match is valid or not.
/// Search mock grids to find a match with specified rules. If there is match, add matches to the explode events, send turn numbe rof the mock grid and bomb events.
/// </summary>
/// <param name="matchElement">Threee coord values for the match.</param>
/// <param name="simulate">If match is valid, make it a valid simulation by changing original grid with the mock one.</param>
/// <returns>Explode event</returns>
public ExplodeEvent Explode(MatchElement?matchElement, bool isTurnClockwise = false, bool simulate = true)
{
// Create mock grid to simulate request
List <HexagonGrid> mockGrids = new List <HexagonGrid>();
for (int i = 0; i < 2; i++)
{
mockGrids.Add((HexagonGrid)this.grid.Clone());
}
// Turn mock grids. First one with 120 degree, secone one with 240 degree.
if (matchElement != null && matchElement?.coords != null)
{
int firstIndex = isTurnClockwise ? 0 : 2;
int lastIndex = isTurnClockwise ? 2 : 0;
for (int mockIndex = 0; mockIndex < 2; mockIndex++)
{
for (int turn = 0; turn < mockIndex + 1; turn++)
{
HexagonElement element = (HexagonElement)mockGrids[mockIndex].GetElement((int)matchElement?.coords[firstIndex].x, (int)matchElement?.coords[firstIndex].y);
mockGrids[mockIndex].grid[(int)matchElement?.coords[firstIndex].x, (int)matchElement?.coords[firstIndex].y] = mockGrids[mockIndex].grid[(int)matchElement?.coords[1].x, (int)matchElement?.coords[1].y];
mockGrids[mockIndex].grid[(int)matchElement?.coords[1].x, (int)matchElement?.coords[1].y] = mockGrids[mockIndex].grid[(int)matchElement?.coords[lastIndex].x, (int)matchElement?.coords[lastIndex].y];
mockGrids[mockIndex].grid[(int)matchElement?.coords[lastIndex].x, (int)matchElement?.coords[lastIndex].y] = element;
}
}
}
// Check explode events on the mock grids to see if the action is valid or not.
// Every rule has to be tried to be sure the match.
List <ExplodeElement> explodeElements = new List <ExplodeElement>();
int selectedMockGridNo = 0;
CheckGridWithrulesToFindMatch(mockGrids, explodeElements, ref selectedMockGridNo);
// If action is valid and not for game over check
if (explodeElements.Count > 0 && simulate)
{
this.grid = mockGrids[selectedMockGridNo];
}
ExplodeEvent explodeEvent = new ExplodeEvent(explodeElements.Count > 0, selectedMockGridNo + 1, explodeElements);
// If action is valid and not for game over check
if (simulate)
{
scoring.SetScore(explodeEvent);
}
// If action is valid and done by user then check for bomb timers and explosion.
if (matchElement != null && matchElement?.coords != null && matchElement?.coords.Count > 0 && simulate)
{
BombEvent bombEvent = scoring.BombCheck(ref this.grid);
explodeEvent.bombEvent = bombEvent;
}
return(explodeEvent);
}
// 新建一个调试Hexagon对象aa
public static GameObject NewElement(Hexagon.Coord v, ushort height, float fWeight, int type)
{
if (vertex == null)
{
vertex = new Vector3[7];
float fSize = Hexagon.Manager.GetSingleton().GetHexagonSize() * 0.95f;
float halfSize = fSize * 0.5f;
float fSqrt12 = halfSize * 2.0f * Mathf.Sqrt(1.0f / 12.0f);
float fHeight = 0.1f;
vertex[0] = Vector3.zero;
vertex[1] = new Vector3(halfSize, fHeight, -fSqrt12);
vertex[2] = new Vector3(halfSize, fHeight, fSqrt12);
vertex[3] = new Vector3(0, fHeight, 2.0f * fSqrt12);
vertex[4] = new Vector3(-halfSize, fHeight, fSqrt12);
vertex[5] = new Vector3(-halfSize, fHeight, -fSqrt12);
vertex[6] = new Vector3(0, fHeight, -2.0f * fSqrt12);
face = new int[6 * 3]
{
0, 6, 5,
0, 5, 4,
0, 4, 3,
0, 3, 2,
0, 2, 1,
0, 1, 6
};
}
if (parent == null)
{
parent = new GameObject();
parent.transform.position = Vector3.zero;
parent.transform.rotation = Quaternion.identity;
}
Vector3 pos = Hexagon.Manager.GetSingleton().Coord_Position(v, height);
GameObject obj = new GameObject();
obj.name = v.x + "_" + v.z + "_" + v.y;
obj.transform.parent = parent.transform;
obj.transform.position = pos;
obj.transform.rotation = Quaternion.identity;;
HexagonElement ele = obj.AddComponent <HexagonElement>();
ele.Build(v, height, fWeight, type);
return(obj);
}
public int this[HexagonElement index]
{
get
{
if (ElementsAmount != null)
{
return(index != HexagonElement.None ? ElementsAmount[(int)index] : -1);
}
else
{
return(-1);
}
}
}
// 虚函数(继承自MonoBehaviour)
void Start()
{
mActor = gameObject.GetComponent <sdGameActor>();
if (mActor == null)
{
mActor = gameObject.GetComponent <sdGameMonster>();
}
Hexagon.Coord kCoord = new Hexagon.Coord();
for (int i = 0; i < 37; ++i)
{
mElementObjectList.Add(HexagonElement.NewElement(kCoord, 0, 0.0f, 3));
}
}
public LevelConditionInfo(HexagonElement element, int requiredAmount)
{
Element = element;
RequiredAmount = requiredAmount;
}
/// <summary>
/// Set hexagon element to the coords.
/// </summary>
public void SetElement(int x, int y, HexagonElement element)
{
this.grid[x, y] = element;
}
public MoveElement(HexagonElement hexagonElement, Vector2 from, Vector2 to)
{
this.hexagonElement = hexagonElement;
this.from = from;
this.to = to;
}
// Update is called once per frame
void Update()
{
if (SearchTest)
{
SearchTest = false;
//if(actor.actorType == ActorType.AT_Monster)
{
Hexagon.PathFinder.StaticWeightScale = StaticWeightScale;
Hexagon.PathFinder.DynamicWeightScale = DynamicWeightScale;
Hexagon.PathFinder.StraightWeightScale = StraightWeightScale;
Hexagon.PathFinder.HeuristicWeightScale = HeuristicWeightScale;
Hexagon.PathFinder.MiddlePointWeight = UseMiddlePointWeight;
foreach (GameObject o in lstObject)
{
GameObject.Destroy(o);
}
lstObject.Clear();
sdMainChar mc = sdGameLevel.instance.mainChar;
sdGameActor actor = GetComponent <sdGameActor>();
if (actor != null)
{
actor.UnInject(false);
}
mc.UnInject(false);
List <Hexagon.SearchNode> lstSearch = new List <Hexagon.SearchNode>();
BT.BinaryTree lstUnSearch = new BT.BinaryTree();
Hexagon.Manager.GetSingleton().DebugFindPath(transform.position, mc.transform.position, ref lstSearch, ref lstUnSearch);
mc.Inject(false);
if (actor != null)
{
actor.Inject(false);
}
Hexagon.SearchNode end = lstSearch[lstSearch.Count - 1];
for (int i = lstSearch.Count - 1; i >= 0; i--)
{
Hexagon.SearchNode n = lstSearch[i];
int type = 0;
if (n == end)
{
type = 2;
end = n.parent;
}
ushort tempHeight = Hexagon.Manager.GetSingleton().GetHeight(n.v);
Add(HexagonElement.NewElement(n.v, tempHeight, n.weight(), type));
}
Hexagon.SearchNode head = (Hexagon.SearchNode)lstUnSearch.Pop();
while (true)
{
if (head == null)
{
break;
}
ushort tempHeight = Hexagon.Manager.GetSingleton().GetHeight(head.v);
Add(HexagonElement.NewElement(head.v, tempHeight, head.weight(), 1));
head = (Hexagon.SearchNode)lstUnSearch.Pop();
}
}
}
}
public static Rectangle ElementSource(HexagonElement index)
{
int size = Elements.Height;
return(new Rectangle(size * (int)index, 0, size, size));
}
public HexagonContent(HexagonElement element)
{
type = HexagonType.Element;
this.element = element;
frozen = false;
}
public HexagonContent(HexagonType type = HexagonType.Empty, HexagonElement element = HexagonElement.None, bool frozen = false)
{
this.type = type;
this.element = element;
this.frozen = frozen;
}
