public SweetInfo Init(SweetsType _sweetsType, Transform itemRoot, int _x, int _y, float _time)
{
MoveComponent = GetComponent <SweetMove>();
ColorComponent = GetComponent <SweetColor>();
SwapComponent = GetComponent <SweetSwap>();
ClearComponent = GetComponent <SweetClear>();
SweetType = _sweetsType;
transform.SetParent(itemRoot);
if (CanSwap())
{
SwapComponent.Init(this);
}
if (CanMove())
{
Move(_x, _y, _time);
}
else
{
X = _x;
Y = _y;
}
if (_sweetsType == SweetsType.Normal)
{
SetColor();
}
return(this);
}
/// <summary>
/// 清除规则里物品的方法
/// </summary>
/// <returns></returns>
private bool ClearAllMatchedSweet()
{
bool needRefill = false; //是否需要填充
for (int y = 0; y < yHang; y++)
{
for (int x = 0; x < xLie; x++)
{
if (sweets[x, y].CanClear()) //如果可以清除
{
List <GameSweet> matchList = MatchSweets(sweets[x, y], x, y);
if (matchList != null) //需要消除
{
SweetsType specialSweetsType = SweetsType.COUNT; //定义一个枚举类型：COUNT——是否产生特殊甜品:默认是Count类型
GameSweet randomSweet = matchList[Random.Range(0, matchList.Count)]; //随机产生位置
int specialSweetX = randomSweet.X;
int specialSweetY = randomSweet.Y;
if (matchList.Count == 4) //消除的4个物品
{
specialSweetsType = (SweetsType)Random.Range((int)SweetsType.HANG_CLEAR, (int)SweetsType.LIE_CLEAR + 1); //特殊类型赋值:取左不取右，所以+1
}
else if (matchList.Count >= 5)
{
specialSweetsType = SweetsType.RAINBOWCANDY;
}
//5个
for (int i = 0; i < matchList.Count; i++) //遍历数组
{
if (ClearSweet(matchList[i].X, matchList[i].Y))
{
needRefill = true; //填充
}
}
if (specialSweetsType != SweetsType.COUNT) //有特殊类型
{
Destroy(sweets[specialSweetX, specialSweetY]); //删除空白物品
GameSweet newSweet = CreateNewSweet(specialSweetX, specialSweetY, specialSweetsType); //生成特殊甜品
if (specialSweetsType == SweetsType.HANG_CLEAR || specialSweetsType == SweetsType.LIE_CLEAR &&
newSweet.CanColor() &&
matchList[0].CanColor()) //种类的确定
{
newSweet.ColorComponet.SetColor(matchList[0].ColorComponet.Color); //给特殊物品，着色：第一个物品的颜色
}
else if (specialSweetsType == SweetsType.RAINBOWCANDY && newSweet.CanColor()) //如果是彩虹堂
{
newSweet.ColorComponet.SetColor(ColorSweet.ColorType.ANY);
}
}
}
}
}
}
return(needRefill);
}
public SweetInfo CreateNewSweet(SweetsType _sweetsType, int _x, int _y, SweetsSpawnPos posEnum = SweetsSpawnPos.Current, Transform _itemRoot = null)
{
Vector2 spawnPos = Vector2.zero;;
switch (posEnum)
{
case SweetsSpawnPos.Zero:
spawnPos = Vector2.zero;
break;
case SweetsSpawnPos.Up:
spawnPos = CorrectPosition(_x, _y - 1);
break;
case SweetsSpawnPos.Current:
spawnPos = CorrectPosition(_x, _y);
break;
default:
break;
}
return(Instantiate(SweetsPrefabDic[_sweetsType].prefab
, spawnPos, Quaternion.identity, _itemRoot ? _itemRoot : itemRoot)
.Init(_sweetsType, itemRoot, _x, _y, fillTime));
}
public bool UseSweets(int deck_id, SweetsType type)
{
if (!IsValidUseSweets(deck_id))
{
return(false);
}
HashSet <int> useitem_id;
if (type == SweetsType.Both)
{
HashSet <int> hashSet = new HashSet <int>();
hashSet.Add(54);
hashSet.Add(59);
useitem_id = hashSet;
}
else
{
HashSet <int> hashSet = new HashSet <int>();
hashSet.Add((int)type);
useitem_id = hashSet;
}
Api_Result <bool> api_Result = new Api_req_Member().itemuse_cond(deck_id, useitem_id);
return(api_Result.state == Api_Result_State.Success);
}
/// <summary>
/// 初始化属性
/// </summary>
/// <param name="_x">x坐标</param>
/// <param name="_y">y坐标</param>
/// <param name="_gameManager"></param>
/// <param name="_type">类型</param>
public void Init(int _x, int _y, GameManager _gameManager, SweetsType _type)
{
X = _x;
Y = _y;
gameManager = _gameManager;
Type = _type;
}
public void SetSweetsType(SweetsType type)
{
_type = type;
_SweetCon.SetSelectedIndex((int)type);
switch (type)
{
case SweetsType.EMPTY:
{
IsMove = false;
IsClear = false;
_color = ColorType.COUNT;
}
break;
case SweetsType.NORMAL:
{
IsMove = true;
IsClear = true;
_loader.alpha = 1;
Color = PlayerInfo.Instance.GetSweetColor();
}
break;
case SweetsType.ROW_CLEAR:
{
IsMove = true;
IsClear = true;
}
break;
case SweetsType.COLUMN_CLEAR:
{
IsMove = true;
IsClear = true;
}
break;
case SweetsType.EXPLOSION:
{
IsMove = true;
IsClear = true;
}
break;
case SweetsType.RAINBOWCANDY:
{
IsMove = true;
IsClear = true;
}
break;
case SweetsType.BARRIER:
{
IsMove = false;
_color = ColorType.COUNT;
}
break;
}
}
private bool ClearAllMatchedSweet()
{
bool needRefill = false;//默认不需要重新填充
for (int y = 0; y < yRow; y++)
{
for (int x = 0; x < xColumn; x++)
{
if (sweets[x, y].CanClear())
{
List <GameSweet> matchList = MatchSweets(sweets[x, y], x, y);
if (matchList != null)
{
SweetsType specialSweetsType = SweetsType.COUNT;//决定是否产生特殊甜品
GameSweet randomSweet = matchList[Random.Range(0, matchList.Count)];
int specialSweetX = randomSweet.X;
int specialSweetY = randomSweet.Y;
//四个产生行列消除
if (matchList.Count == 4)
{
specialSweetsType = (SweetsType)Random.Range((int)SweetsType.ROW_CLEAR, (int)SweetsType.COLUMN_CLEAR);
}
//五个产生彩虹糖
else if (matchList.Count >= 5)
{
specialSweetsType = SweetsType.RAINBOWCANDY;
}
for (int i = 0; i < matchList.Count; i++)
{
if (ClearSweet(matchList[i].X, matchList[i].Y))
{
needRefill = true;
}
}
if (specialSweetsType != SweetsType.COUNT)
{
Destroy(sweets[specialSweetX, specialSweetY]);
GameSweet newSweet = CreatNewSweet(specialSweetX, specialSweetY, specialSweetsType);
if ((specialSweetsType == SweetsType.ROW_CLEAR || specialSweetsType == SweetsType.COLUMN_CLEAR) &&
newSweet.CanColor() && matchList[0].CanColor())
{
newSweet.ColoredComponent.SetColor(matchList[0].ColoredComponent.Color);
}
//加上彩虹糖特殊类型的产生
else if (specialSweetsType == SweetsType.RAINBOWCANDY && newSweet.CanColor())
{
newSweet.ColoredComponent.SetColor(ColorSweet.ColorType.ANY);
}
}
}
}
}
}
return(needRefill);
}
public void InitSweet(GComponent parents)
{
_parents = parents;
_sweet.visible = true;
_type = SweetsType.EMPTY;
parents.AddChild(_sweet);
SetSweetsType(_type);
}
//安全检验。如果包含这个类型，就用这个类型对应的sprite来渲染
public void SetType(SweetsType newType)
{
type = newType;
if (typeSpriteDict.ContainsKey(newType))
{
sprite.sprite = typeSpriteDict[newType];
}
}
public bool UseSweets(SweetsType type)
{
if (!IsValidUseSweets())
{
return(false);
}
return(false);
}
public bool UseSweets(int deck_id, SweetsType type)
{
if (deck_id != _edit_deck.Id)
{
return(false);
}
return(UseSweets(type));
}
private bool ClearAllMatchedSweet()//清除所有块方法
{
if (isGameOver)
{
return(false);
}
print("清除所有块方法");
bool needRefill = false;
for (int y = 0; y < yRows; y++)
{
for (int x = 0; x < xColumns; x++)
{
if (sweetsarray[y, x].CanClear())
{
List <GameSweet> matchlist = MatchSweets(sweetsarray[y, x], x, y);
if (matchlist != null)
{
SweetsType specialSweetsType = SweetsType.COUNT;//特殊类甜品产生flag;
GameSweet randomSweet = matchlist[Random.Range(0, matchlist.Count)];
int specialSweetX = randomSweet.X;
int specialSweetY = randomSweet.Y;
if (matchlist.Count == 4)
{
specialSweetsType = (SweetsType)Random.Range((int)SweetsType.ROW_CLEAR, (int)SweetsType.COLUMN_CLEAR);
}
//5个同样块消除时判定是行还是列 RainbowSweet产生条件
else if (matchlist.Count > 4)
{
specialSweetsType = SweetsType.RAINBOWCANDY;
}
for (int i = 0; i < matchlist.Count; i++)//---清除符合条件的所有块
{
if (ClearSweet(matchlist[i].X, matchlist[i].Y))
{
needRefill = true;
}
}
if (specialSweetsType != SweetsType.COUNT)
{
Destroy(sweetsarray[specialSweetY, specialSweetX]);
GameSweet newsweet = CreateSweet(specialSweetX, specialSweetY, specialSweetsType);
if (newsweet.CanColor() && specialSweetsType == SweetsType.ROW_CLEAR || specialSweetsType == SweetsType.COLUMN_CLEAR)
{
newsweet.ColorComponent.SetColor(matchlist[0].ColorComponent.Color);
}
else if (specialSweetsType == SweetsType.RAINBOWCANDY && newsweet.CanColor())
{
newsweet.ColorComponent.SetColor(ColorSweet.ColorEnum.ANYCOLORS);
}
}
}
}
}
}
return(needRefill);
}
//Eliminate sweets in all range.
private bool EliminateAllMatchedSweets()
{
bool needFill = false;
for (int y = 0; y < rows; y++)
{
for (int x = 0; x < columns; x++)
{
if (sweets[x, y].Eliminable())
{
List <SweetsController> matchList = MatchSweets(sweets[x, y], x, y);
if (matchList != null)
{
SweetsType superSweets = SweetsType.COUNT;
SweetsController superSweetsPos = matchList[Random.Range(0, matchList.Count)];
if (matchList.Count == 4)
{
superSweets = (SweetsType)Random.Range(3, 5);
}
//matchList.Count >= 5 ... Rainbow Sweets
if (matchList.Count >= 5)
{
superSweets = SweetsType.RAINBOW_CANDY;
}
for (int i = 0; i < matchList.Count; i++)
{
if (EliminateSweet(matchList[i].X, matchList[i].Y))
{
needFill = true;
}
}
//Generate super sweets.
if (superSweets != SweetsType.COUNT)
{
Destroy(sweets[superSweetsPos.X, superSweetsPos.Y]);
SweetsController newSweets = CreateNewSweet(superSweetsPos.X, superSweetsPos.Y, superSweets);
if (matchList.Count == 4 && newSweets.ColorAble() && matchList[0].ColorAble())
{
newSweets.ColoredComponent.SetThisType(matchList[0].ColoredComponent.ThisType);
}
else if (superSweets == SweetsType.RAINBOW_CANDY && newSweets.ColorAble())
{
//Generate Rainbow Sweets
newSweets.ColoredComponent.SetThisType(SweetsColorType.ColorType.UNIVERSAL);
}
}
}
}
}
}
return(needFill);
}
//产生甜品的方法
public GameSweet CreateNewSweet(int x, int y, SweetsType type)
{
GameObject newSweet = Instantiate(sweetPrefabDict[type], CorrectPositon(x, y), Quaternion.identity);
newSweet.transform.SetParent(sweetsTransform);
sweets[x, y] = newSweet.GetComponent <GameSweet>();
sweets[x, y].Init(x, y, this, type);
return(sweets[x, y]);
}
/// <summary>
/// 清除全部完成匹配的甜品
/// </summary>
/// <returns></returns>
private bool ClearAllMatchedSweet()
{
bool needRefill = false;
for (int y = 0; y < yRow; y++)
{
for (int x = 0; x < xCol; x++)
{
if (sweetArr[x, y].CanClear())
{
List <GameSweet> matchList = MatchSweets(sweetArr[x, y], x, y);
if (matchList != null)
{
//确认是否产生特殊甜品
SweetsType sweetsType = SweetsType.Count;
//随机获取消除列表中的坐标
GameSweet randomSweet = matchList[Random.Range(0, matchList.Count)];
//消除4个生成行或列消除甜品
if (matchList.Count == 4)
{
sweetsType = (SweetsType)Random.Range((int)SweetsType.Row_Clear, (int)SweetsType.Column_Clear);
}
//消除5个生成彩虹糖
else if (matchList.Count >= 5)
{
sweetsType = SweetsType.RainbowCandy;
}
for (int i = 0; i < matchList.Count; i++)
{
if (ClearSweet(matchList[i].X, matchList[i].Y))
{
needRefill = true;
}
}
//创建行列消除特殊甜品
if (sweetsType != SweetsType.Count)
{
Destroy(sweetArr[randomSweet.X, randomSweet.Y]);
GameSweet newSweet = CreateNewSweet(randomSweet.X, randomSweet.Y, sweetsType);
if (sweetsType == SweetsType.Row_Clear || sweetsType == SweetsType.Column_Clear && newSweet.CanColor() && matchList[0].CanColor())
{
newSweet.colorSweet.SetSprite(matchList[0].colorSweet.colorType);
}
else if (sweetsType == SweetsType.RainbowCandy & newSweet.CanColor())
{
newSweet.colorSweet.SetSprite(ColorType.Any);
}
}
}
}
}
}
return(needRefill);
}
private bool ClearMatchedSweet()
{
bool isNeedFill = false;
for (int x = 0; x < xColumn; x++)
{
for (int y = 0; y < yRow; y++)
{
if (sweets[x, y].CanClear())
{
List <GameSweet> matchList = MatchSweets(sweets[x, y], x, y);
if (matchList != null)
{
SweetsType specialType = SweetsType.COUNT;
GameSweet randomSweet = matchList[Random.Range(0, matchList.Count)];
int specialX = randomSweet.X;
int specialY = randomSweet.Y;
if (matchList.Count == 4)
{
specialType = (SweetsType)Random.Range((int)SweetsType.ROW_CLEAR, (int)SweetsType.COLUMN_CLEAR);
}
if (matchList.Count == 5)
{
specialType = SweetsType.RAINBOWCANDY;
}
for (int i = 0; i < matchList.Count; i++)
{
ClearSweet(matchList[i].X, matchList[i].Y);
isNeedFill = true;
}
if (specialType != SweetsType.COUNT)
{
Destroy(sweets[specialX, specialY]);
GameSweet gameSweet = CreateNewSweet(specialX, specialY, specialType);
if ((gameSweet.Type == SweetsType.ROW_CLEAR || gameSweet.Type == SweetsType.COLUMN_CLEAR) &&
gameSweet.CanColor() && matchList[0].CanColor())
{
gameSweet.ColorCommpont.SetColor(matchList[0].ColorCommpont.Color);
}
else if (gameSweet.Type == SweetsType.RAINBOWCANDY)
{
gameSweet.ColorCommpont.SetColor(ColorSweet.ColorType.ANY);
}
}
}
}
}
}
return(isNeedFill);
}
public GameSweet CreateSweet(int x, int y, SweetsType type)
{
print(x + "x,y" + y);
GameSweet go = Instantiate(sweetPrefabDict[type], CorrectPosition(x, y), Quaternion.identity);
go.transform.parent = transform;
sweetsarray[y, x] = go;
sweetsarray[y, x].Init(x, y, Instance, type);
return(sweetsarray[y, x]);
}
//Create new Sweets Object.
public SweetsController CreateNewSweet(int x, int y, SweetsType type)
{
GameObject newSweet =
Instantiate(sweetsPrefabDic[type], CalibratePosition(x, y), Quaternion.identity);
newSweet.transform.parent = transform;
sweets[x, y] = newSweet.GetComponent <SweetsController>();
sweets[x, y].Init(x, y, this, type);
return(sweets[x, y]);
}
/// <summary>
/// 创建新甜品
/// </summary>
/// <param name="x">x坐标</param>
/// <param name="y">y坐标</param>
/// <param name="type">类型</param>
/// <returns></returns>
public GameSweet CreateNewSweet(int x, int y, SweetsType type)
{
//在当前x、y位置实例化甜品
GameObject newSweet = Instantiate(prefabDic[type], CorrectPos(x, y), Quaternion.identity);
//设置父对象
newSweet.transform.SetParent(transform);
//获取脚本并初始化属性
sweetArr[x, y] = newSweet.GetComponent <GameSweet>();;
sweetArr[x, y].Init(x, y, this, type);
return(sweetArr[x, y]);
}
public List <GameSweet> GetSweetsOfType(SweetsType type)
{
List <GameSweet> sweetsOfType = new List <GameSweet>();
for (int x = 0; x < xColumn; x++)
{
for (int y = 0; y < yRow; y++)
{
if (sweets[x, y].Type == type)
{
sweetsOfType.Add(sweets[x, y]);
}
}
}
return(sweetsOfType);
}
//创建一个甜品
private GameSweet CreateNewSweet(int x, int y, SweetsType type)
{
GameObject newObj = Instantiate(sweetPrefabDict[type], CorrectPosition(x, y), Quaternion.identity);
newObj.transform.SetParent(transform);
GameSweet gameSweet = newObj.GetComponent <GameSweet>();
gameSweet.Init(x, y, this, type);
//如果是普通类型就创建一个随机的颜色的甜品
if (type == SweetsType.NORMAL)
{
gameSweet.ColorComponent.SetColor((ColorSweet.ColorType)Random.Range(0, gameSweet.ColorComponent.numColors));
}
//数组赋值
sweets[x, y] = gameSweet;
return(gameSweet);
}
public void Clear()
{
if (!IsClear)
{
return;
}
switch (_type)
{
case SweetsType.NORMAL:
{
_normalClearTra.Play();
}
break;
case SweetsType.ROW_CLEAR:
{
_normalClearTra.Play();
}
break;
case SweetsType.COLUMN_CLEAR:
{
_normalClearTra.Play();
}
break;
case SweetsType.EXPLOSION:
{
_normalClearTra.Play();
}
break;
case SweetsType.RAINBOWCANDY:
{
_normalClearTra.Play();
}
break;
}
_type = SweetsType.EMPTY;
}
private bool ClearAllMatchedSweet()
{
bool needRefill = false;
for (int y = 0; y < yRow; y++)
{
for (int x = 0; x < xColumn; x++)
{
if (sweets[x, y].CanClear())
{
List <GameSweet> matchList = MatchSweets(sweets[x, y], x, y);
if (matchList != null)
{
SweetsType specialSweetsType = SweetsType.COUNT;
GameSweet randomSweet = matchList[Random.Range(0, matchList.Count)];
int specialSweetX = randomSweet.X;
int specialSweetY = randomSweet.Y;
if (matchList.Count == 4)
{
if (pressedSweet == null || enteredSweet == null)
{
specialSweetsType = (SweetsType)Random.Range((int)SweetsType.ROW_CLEAR, (int)SweetsType.COLUMN_CLEAR);
}
else if (pressedSweet.Y == enteredSweet.Y)
{
specialSweetsType = SweetsType.ROW_CLEAR;
}
else
{
specialSweetsType = SweetsType.COLUMN_CLEAR;
}
}
else if (matchList.Count >= 5)
{
specialSweetsType = SweetsType.RAINBOWCANDY;
}
for (int i = 0; i < matchList.Count; i++)
{
if (ClearSweet(matchList[i].X, matchList[i].Y))
{
needRefill = true;
if (matchList[i] == pressedSweet || matchList[i] == enteredSweet)
{
specialSweetX = matchList[i].X;
specialSweetY = matchList[i].Y;
}
}
}
if (specialSweetsType != SweetsType.COUNT)
{
Destroy(sweets[specialSweetX, specialSweetY]);
GameSweet newSweet = CreateNewSweet(specialSweetX, specialSweetY, specialSweetsType);
if (specialSweetsType == SweetsType.ROW_CLEAR || specialSweetsType == SweetsType.COLUMN_CLEAR && newSweet.CanColor() && matchList[0].CanColor())
{
newSweet.ColoredComponent.SetColor(matchList[0].ColoredComponent.Color);
}
else if (specialSweetsType == SweetsType.RAINBOWCANDY && newSweet.CanColor())
{
newSweet.ColoredComponent.SetColor(ColorSweet.ColorType.ANY);
}
}
}
}
}
}
return(needRefill);
}
public bool UseSweets(SweetsType type)
{
return(!this.IsValidUseSweets() && false);
}
public bool UseSweets(int deck_id, SweetsType type)
{
return(deck_id == this._edit_deck.Id && this.UseSweets(type));
}
