public void SetType(TileTypes.ESubState setType)
{
curType = setType;
_type.Type = setType;
_image.sprite = _type.HexSprite;
//Debug.Log(gameObject.name + " is now " + setType);
}
public float GetFillRequirementByType(TileTypes.ESubState state)
{
float returnValue = 0;
switch (state)
{
case TileTypes.ESubState.yellow:
returnValue = _yellowFillRequirement;
break;
case TileTypes.ESubState.blue:
returnValue = _blueFillRequirement;
break;
case TileTypes.ESubState.green:
returnValue = _greenFillRequirement;
break;
case TileTypes.ESubState.red:
returnValue = _redFillRequirement;
break;
}
return(returnValue);
}
public bool TileAtPositionIsBooster(Vector2 position, int totalCount, TileTypes.ESubState requestedType)
{
bool isBooster = false;
HexTile tile = FindHexTileAtPosition(position);
if (tile)
{
if (tile.type.Type == requestedType)
{
if (tile.gameObject.GetComponent <BoosterThreeHexTile>() && totalCount >= Constants.BoosterThreeThreshhold)
{
isBooster = true;
}
if (tile.gameObject.GetComponent <BoosterTwoHexTile>() && totalCount >= Constants.BoosterTwoThreshhold)
{
isBooster = true;
}
if (tile.gameObject.GetComponent <BoosterOneHexTile>() && totalCount >= Constants.BoosterOneThreshhold)
{
isBooster = true;
}
}
}
return(isBooster);
}
private void RpcAddTile(TileTypes.ESubState type, int rowNo, string direction)
{
if (!isServer)
{
HexRow row = rows[rowNo];
GameObject newTile = Instantiate(Resources.Load("HexTile")) as GameObject;
newTile.transform.SetParent(row.transform, false);
if (direction == "top" || direction == "left")
{
newTile.transform.SetAsFirstSibling();
}
HexTile tile = newTile.GetComponent <HexTile>();
tile.InitWithType(type);
if (direction == "top" || direction == "left")
{
row.tiles.Insert(0, tile);
}
else
{
row.tiles.Add(tile);
}
//Debug.Log("Client added tile to Row " + row.number + " w index: " + row.tiles.IndexOf(tile));
foreach (HexTile otherTiles in row.tiles)
{
otherTiles.transform.name = "Tile (" + row.number + ", " + row.tiles.IndexOf(otherTiles) + ")"; //F.e. Tile (0,7)
otherTiles.xy = new Vector2(row.number, row.tiles.IndexOf(otherTiles));
}
}
}
public void EmptyPower(TileTypes.ESubState type)
{
if (type1.Type == type)
{
type1Power = 0;
}
if (type2.Type == type)
{
type2Power = 0;
}
if (type3.Type == type)
{
type3Power = 0;
}
if (type4.Type == type)
{
type4Power = 0;
}
transform.Find("Color1").GetComponent <SpecialPowerUI>().UpdateText(type1Power);
transform.Find("Color2").GetComponent <SpecialPowerUI>().UpdateText(type2Power);
transform.Find("Color3").GetComponent <SpecialPowerUI>().UpdateText(type3Power);
transform.Find("Color4").GetComponent <SpecialPowerUI>().UpdateText(type4Power);
transform.Find("Color1").GetComponent <SpecialPowerUI>().SetNotReady();
transform.Find("Color2").GetComponent <SpecialPowerUI>().SetNotReady();
transform.Find("Color3").GetComponent <SpecialPowerUI>().SetNotReady();
transform.Find("Color4").GetComponent <SpecialPowerUI>().SetNotReady();
}
// Update is called once per frame
protected override void Update()
{
base.Update();
if (_type.Type != _originalType)
{
_image.sprite = type.HexSprite;
_originalType = _type.Type;
}
}
public void SetColorType(TileTypes.ESubState state, Player myPlayer)
{
_type.Type = state;
GetComponent <Image>().sprite = _type.HexSprite;
_player = myPlayer;
/*if (myPlayer.selectedType.Type == state)
* {
* GetComponent<Image>().sprite = _type.SpecialitySprite;
* }*/
}
public Transform GetPowerObjectByType(TileTypes.ESubState type)
{
Transform returnTransform = null;
foreach (Transform color in colors)
{
if (color.GetComponent <SpecialPowerUI>().Type == type)
{
return(color);
}
}
return(returnTransform);
}
public void FillPower(TileTypes.ESubState type, int comboSize)
{
float multiplier = 1f;
//if (selectedType.Type == type)
//multiplier = settings.SpecialityMultiplier; //multiplier = Constants.SpecialMoveMultiplier;
if (type1.Type == type)
{
type1Power += (comboSize * multiplier);
type1Power = Mathf.Min(settings.GetFillRequirementByType(type1.Type), type1Power);
}
else if (type2.Type == type)
{
type2Power += (comboSize * multiplier);
type2Power = Mathf.Min(settings.GetFillRequirementByType(type2.Type), type2Power);
}
else if (type3.Type == type)
{
type3Power += (comboSize * multiplier);
type3Power = Mathf.Min(settings.GetFillRequirementByType(type3.Type), type3Power);
}
else if (type4.Type == type)
{
type4Power += (comboSize * multiplier);
type4Power = Mathf.Min(settings.GetFillRequirementByType(type4.Type), type4Power);
}
transform.Find("Color1").GetComponent <SpecialPowerUI>().UpdateText(type1Power);
transform.Find("Color2").GetComponent <SpecialPowerUI>().UpdateText(type2Power);
transform.Find("Color3").GetComponent <SpecialPowerUI>().UpdateText(type3Power);
transform.Find("Color4").GetComponent <SpecialPowerUI>().UpdateText(type4Power);
if (CheckPowerLevel_1())
{
transform.Find("Color1").GetComponent <SpecialPowerUI>().SetReady();
}
if (CheckPowerLevel_2())
{
transform.Find("Color2").GetComponent <SpecialPowerUI>().SetReady();
}
if (CheckPowerLevel_3())
{
transform.Find("Color3").GetComponent <SpecialPowerUI>().SetReady();
}
if (CheckPowerLevel_4())
{
transform.Find("Color4").GetComponent <SpecialPowerUI>().SetReady();
}
}
private void CmdDamageTarget(int targetNumber, TileTypes.ESubState type)
{
PlayerEntity targetPE = RootController.Instance.GetPlayerEntity(targetNumber);
int damage = 0;
if (type == TileTypes.ESubState.red)
{
damage = (int)RootController.Instance.NextPE(targetNumber).RedValue;
}
else
{
damage = (int)RootController.Instance.NextPE(targetNumber).YellowValue;
}
targetPE.ReceiveDamage(damage);
RpcDamageTarget(targetNumber, type);
}
public void CreateBoosterAt(BaseTile tile, int totalCount, TileTypes.ESubState requestedType)
{
_boosterRequest = tile.xy;
_boosterType = requestedType;
if (totalCount >= Constants.BoosterThreeThreshhold)
{
_boosterPath = "BoosterThreeTile";
}
else if (totalCount >= Constants.BoosterTwoThreshhold)
{
_boosterPath = "BoosterTwoTile";
}
else if (totalCount >= Constants.BoosterOneThreshhold)
{
_boosterPath = "BoosterOneTile";
}
}
public void CreateBoosterAt(Vector2 position, int totalCount, TileTypes.ESubState requestedType)
{
Debug.Log(position + " Booster requested (" + totalCount + ") of type " + requestedType);
_boosterRequest = position;
_boosterType = requestedType;
if (totalCount >= Constants.BoosterThreeThreshhold)
{
_boosterPath = "BoosterThree";
}
else if (totalCount >= Constants.BoosterTwoThreshhold)
{
_boosterPath = "BoosterTwo";
}
else if (totalCount >= Constants.BoosterOneThreshhold)
{
_boosterPath = "BoosterOne";
}
}
private void RpcDamageTarget(int targetNumber, TileTypes.ESubState type)
{
PlayerEntity targetPE = RootController.Instance.GetPlayerEntity(targetNumber);
int damage = 0;
if (type == TileTypes.ESubState.yellow)
{
targetPE.SpecialExplosion("YellowTileExplosion");
damage = (int)RootController.Instance.NextPE(targetNumber).YellowValue;
}
else
{
targetPE.SpecialExplosion("RedTileExplosion");
damage = (int)RootController.Instance.NextPE(targetNumber).RedValue;
}
targetPE.ReceiveDamage(damage);
}
public void CreateBoosterAt(HexTile tile, int totalCount, TileTypes.ESubState requestedType)
{
Debug.Log(tile.xy + " Booster requested of type " + requestedType);
_boosterRequest = tile.xy;
_boosterType = requestedType;
if (totalCount >= Constants.BoosterThreeThreshhold)
{
_boosterPath = "BoosterThree";
}
else if (totalCount >= Constants.BoosterTwoThreshhold)
{
_boosterPath = "BoosterTwo";
}
else if (totalCount >= Constants.BoosterOneThreshhold)
{
_boosterPath = "BoosterOne";
}
}
public float GetDamageValueByType(TileTypes.ESubState state)
{
float returnValue = 0;
switch (state)
{
case TileTypes.ESubState.yellow:
returnValue = _yellowValue;
break;
case TileTypes.ESubState.green:
returnValue = _greenValue;
break;
case TileTypes.ESubState.red:
returnValue = _redValue;
break;
}
return(returnValue);
}
private void ConvertTileToBooster(Vector2 position, TileTypes.ESubState requestedType, string path)
{
TileColumn column = columns[(int)position.x];
BaseTile targetTile = column.tiles.Find(item => item.x == position.x && item.y == position.y);
if (targetTile)
{
int index = column.tiles.IndexOf(targetTile);
GameObject newTile = Instantiate(Resources.Load(path)) as GameObject;
newTile.transform.SetParent(column.transform, false);
column.tiles.RemoveAt(index);
Destroy(targetTile.gameObject);
column.tiles.Insert(index, newTile.GetComponent <BaseTile>());
newTile.GetComponent <BaseTile>().type.Type = requestedType;
newTile.transform.SetSiblingIndex(index);
newTile.GetComponent <BaseTile>().xy = new Vector2(column.number, index);
newTile.transform.name = "Tile (" + column.number + ", " + index + ")"; //F.e. Tile (0,7)
GameObject boosterIcon = Instantiate(Resources.Load(path + "Icon")) as GameObject;
boosterIcon.transform.SetParent(newTile.transform, false);
}
}
private void ConvertTileToBooster(Vector2 position, TileTypes.ESubState requestedType, string path)
{
Debug.Log("Converting tile at " + position + " to " + path + " of type " + requestedType);
HexRow row = rows[(int)position.x];
HexTile targetTile = row.tiles.Find(item => item.x == position.x && item.y == position.y);
if (targetTile)
{
int index = row.tiles.IndexOf(targetTile);
GameObject newTile = Instantiate(Resources.Load(path + "HexTile")) as GameObject;
newTile.transform.SetParent(row.transform, false);
row.tiles.RemoveAt(index);
Destroy(targetTile.gameObject);
row.tiles.Insert(index, newTile.GetComponent <HexTile>());
newTile.GetComponent <HexTile>().SetType(requestedType);
newTile.transform.SetSiblingIndex(index);
newTile.GetComponent <HexTile>().xy = new Vector2(row.number, index);
newTile.transform.name = "Tile (" + row.number + ", " + index + ")"; //F.e. Tile (0,7)
GameObject boosterIcon = Instantiate(Resources.Load(path + "TileIcon")) as GameObject;
boosterIcon.transform.SetParent(newTile.transform, false);
}
}
public void SetColorType(TileTypes.ESubState state, PlayerEntity myPlayer)
{
_type.Type = state;
GetComponent <Image>().sprite = _type.HexSprite;
_player = myPlayer;
}
public void Init()
{
_image.sprite = _type.HexSprite;
MoveToPosition();
curType = _type.Type;
}
public void InitWithType(TileTypes.ESubState type)
{
_type.Type = type;
Init();
}
protected override void Awake()
{
base.Awake();
_originalType = _type.Type;
_image.sprite = type.Sprite;
}
void RpcUpdateTileType(Vector2 xy, TileTypes.ESubState type)
{
//Debug.Log(xy.x + "|" + xy.x + " setting to " + type);
FindHexTileAtPosition(xy).SetType(type);
}
