public void CalculcateScore(BrickTypes brickTypes)
{
if (brickTypes == BrickTypes.GREEN)
{
AddScore(100);
}
if (brickTypes == BrickTypes.YELLOW)
{
AddScore(250);
}
if (brickTypes == BrickTypes.ORANGE)
{
AddScore(500);
}
if (brickTypes == BrickTypes.RED)
{
AddScore(500);
}
if (brickTypes == BrickTypes.PURPLE)
{
AddScore(1000);
}
if (brickTypes == BrickTypes.BLUE)
{
AddScore(1500);
}
}
void SetRandomBrick()
{
int weightCounter = 0;
int r = spawner.RandomInt(totalWeight);
if (activeBrickTypes.Count == 0)
{
Debug.LogError("activeBrickTypes.Count = " + activeBrickTypes.Count);
}
foreach (var b in activeBrickTypes)
{
Ability a = Store.abilities[Store.bricks[b].brickAbility];
weightCounter += a.probabilityWeight[a.level];
if (r < weightCounter)
{
brickType = b;
brick = Store.bricks[brickType];
if (brick == null)
{
Debug.LogError("brick is null brickType is " + brickType);
}
PScolor.color = brick.gradient;
sr.color = brick.color;
sr.sprite = brick.sprite;
break;
}
}
if (brick == null)
{
Debug.LogError("BrickBoss::SetRandombrick brick is null. brickType is " + brickType + " and Store.bricks[brickType]=" + Store.bricks[brickType]);
}
}
public static Color ChooseColor(GameObject temp, BrickTypes brickTypes)
{
if (brickTypes == BrickTypes.GREEN)
{
return(temp.GetComponent <SpriteRenderer>().color = Color.green);
}
if (brickTypes == BrickTypes.YELLOW)
{
return(temp.GetComponent <SpriteRenderer>().color = Color.yellow);
}
if (brickTypes == BrickTypes.ORANGE)
{
return(temp.GetComponent <SpriteRenderer>().color = new Color(252f, 150f, 17f));
}
if (brickTypes == BrickTypes.RED)
{
return(temp.GetComponent <SpriteRenderer>().color = Color.red);
}
if (brickTypes == BrickTypes.PURPLE)
{
return(temp.GetComponent <SpriteRenderer>().color = Color.magenta);
}
if (brickTypes == BrickTypes.BLUE)
{
return(temp.GetComponent <SpriteRenderer>().color = Color.blue);
}
return(temp.GetComponent <SpriteRenderer>().color = Color.white);
}
public static List <Brick> GetLevelBrickMap(Arkanoid game, PlayArena playArena, Level map)
{
var by = map.BricksHigh;
var bx = map.BricksWide;
var bricks = new BrickTypes[by][];
var chances = new int[by][];
var powers = new CapsuleTypes[by][];
for (var y = 0; y < by; y++)
{
bricks[y] = new BrickTypes[bx];
chances[y] = new int[bx];
powers[y] = new CapsuleTypes[bx];
for (var x = 0; x < bx; x++)
{
BrickTypes bt;
if (!Enum.TryParse(Enum.GetNames(typeof(BrickTypes))[map.GetBrickValue(y, x)], out bt))
{
bt = BrickTypes.Empty;
}
bricks[y][x] = bt;
CapsuleTypes p;
if (!Enum.TryParse(Enum.GetNames(typeof(CapsuleTypes))[map.GetPowerValue(y, x)], out p))
{
p = CapsuleTypes.Slow; //todo make random
}
bricks[y][x] = bt;
chances[y][x] = map.GetChanceValue(y, x);
powers[y][x] = p;
}
}
var bm = new List <Brick>();
for (var y = 0; y < bricks.Length; y++)
{
for (var x = 0; x < bricks[y].Length; x++)
{
var b = bricks[y][x];
if (b != BrickTypes.Empty)
{
bm.Add(Types.GetBrick(b, game, playArena, GetBrickLocation(game, x, y), chances[y][x],
powers[y][x]));
}
}
}
return(bm);
}
public void UpdateObject()
{
theBrickType = myScript.BrickType;
switch (theBrickType)
{
case BrickTypes.Normal:
myScript.GetComponent <SpriteRenderer>().sprite = myScript.NormalBrick;
break;
case BrickTypes.Hard:
myScript.GetComponent <SpriteRenderer>().sprite = myScript.HardBrick;
break;
case BrickTypes.Indestructible:
myScript.GetComponent <SpriteRenderer>().sprite = myScript.IndesBrick;
break;
default:
break;
}
}
int GetRewardForBrick(BrickTypes brickType)
{
int reward = 0;
switch (brickType)
{
case BrickTypes.Easy:
reward = 10;
break;
case BrickTypes.Medium:
reward = 25;
break;
case BrickTypes.Hard:
reward = 50;
break;
default:
break;
}
return(reward);
}
public void Collided(BrickTypes bt, int scoreToAdd, int earnings, Vector3 loc)
{
moneyManager.Pay(earnings, loc);
scoreKeeper.IncrementScoreBy(scoreToAdd);
GameObject g = ObjectPooler.SharedInstance.GetPooledObject("BrickDeath");
if (g == null)
{
Debug.LogError("CollisionTracker::Collided g is null");
}
else
{
g.SetActive(true);
g.transform.position = loc;
g.GetComponent <BrickDeath> ().PlayDeath(bt);
}
Ability a = abilityForBrick [(int)bt];
int t = (int)a.type;
if (endPoints[t].Count == 0)
{
a.TriggerAbility();
time[t] = 0f;
expectedDuration [t] = 0f;
endPoints [t] = new Queue <float> ();
if (usesIcon[t])
{
displayer.DisplayAbility(a.type, a.sprite);
}
}
expectedDuration [t] += a.duration [a.level];
endPoints[t].Enqueue(time[t] + a.duration [a.level]);
}
public SimpleBrick(BrickController brickController)
{
this._brickController = brickController;
this._brickType = brickController.brickType;
switch (_brickType)
{
case BrickTypes.Easy:
Hp = 1;
break;
case BrickTypes.Medium:
Hp = 2;
break;
case BrickTypes.Hard:
Hp = 3;
break;
default:
break;
}
onBrickDestroy += GameMaster.instance.BricksDecrement;
}
public static Brick GetBrick(BrickTypes type, Arkanoid game, PlayArena playArena, Vector2 location, int chance,
CapsuleTypes capsuleType)
{
switch (type)
{
case BrickTypes.White:
{
return(new Brick(game, playArena, Sprites.BrkWhite, Sprites.BrkFlash, location, Scoring.White, 1,
chance, capsuleType));
}
case BrickTypes.Yellow:
{
return(new Brick(game, playArena, Sprites.BrkYellow, Sprites.BrkFlash, location, Scoring.Yellow, 1,
chance, capsuleType));
}
case BrickTypes.Pink:
{
return(new Brick(game, playArena, Sprites.BrkPink, Sprites.BrkFlash, location, Scoring.Pink, 1,
chance, capsuleType));
}
case BrickTypes.Blue:
{
return(new Brick(game, playArena, Sprites.BrkBlue, Sprites.BrkFlash, location, Scoring.Blue, 1,
chance, capsuleType));
}
case BrickTypes.Red:
{
return(new Brick(game, playArena, Sprites.BrkRed, Sprites.BrkFlash, location, Scoring.Red, 1, chance,
capsuleType));
}
case BrickTypes.Green:
{
return(new Brick(game, playArena, Sprites.BrkGreen, Sprites.BrkFlash, location, Scoring.Green, 1,
chance, capsuleType));
}
case BrickTypes.SkyBlue:
{
return(new Brick(game, playArena, Sprites.BrkSkyBlue, Sprites.BrkFlash, location, Scoring.SkyBlue, 1,
chance, capsuleType));
}
case BrickTypes.Orange:
{
return(new Brick(game, playArena, Sprites.BrkOrange, Sprites.BrkFlash, location, Scoring.Orange, 1,
chance, capsuleType));
}
case BrickTypes.Silver:
{
return(new Brick(game, playArena, Sprites.BrkSilver, Sprites.BrkFlash, location, Scoring.Silver, 2,
chance, capsuleType));
}
case BrickTypes.Gold:
{
return(new Brick(game, playArena, Sprites.BrkGold, Sprites.BrkFlash, location, 0, -1, chance,
capsuleType));
}
case BrickTypes.Regen:
{
return(new Brick(game, playArena, Sprites.BrkRegen, Sprites.BrkFlash, location, Scoring.Silver, -2,
chance, capsuleType));
}
case BrickTypes.Teleport:
{
return(new Brick(game, playArena, Sprites.BrkTeleport, Sprites.BrkFlash, location, 0, -3, chance,
capsuleType));
}
case BrickTypes.SilverSwap:
{
return(new Brick(game, playArena, Sprites.BrkSilverSwap, Sprites.BrkFlash, location, Scoring.Silver,
-4, chance, capsuleType));
}
case BrickTypes.GoldSwap:
{
return(new Brick(game, playArena, Sprites.BrkGoldSwap, Sprites.BrkFlash, location, 0, -5, chance,
capsuleType));
}
case BrickTypes.BlueSwap:
{
return(new Brick(game, playArena, Sprites.BrkBlueSwap, Sprites.BrkFlash, location, Scoring.Blue, -6,
chance, capsuleType));
}
case BrickTypes.Black:
{
return(new Brick(game, playArena, Sprites.BrkBlack, Sprites.BrkFlash, location, Scoring.Black, 4,
chance, capsuleType));
}
case BrickTypes.DarkRed:
{
return(new Brick(game, playArena, Sprites.BrkDarkRed, Sprites.BrkFlash, location, Scoring.DarkRed, 1,
chance, capsuleType));
}
case BrickTypes.DarkBlue:
{
return(new Brick(game, playArena, Sprites.BrkDarkBlue, Sprites.BrkFlash, location, Scoring.DarkBlue, 1,
chance, capsuleType));
}
case BrickTypes.BlackRegen:
{
return(new Brick(game, playArena, Sprites.BrkBlackRegen, Sprites.BrkFlash, location, Scoring.Black,
-7, chance, capsuleType));
}
case BrickTypes.Transmit:
{
return(new Brick(game, playArena, Sprites.BrkTransmit, Sprites.BrkFlash, location, Scoring.Transmit,
-8, chance, capsuleType));
}
case BrickTypes.HorizonalMove:
{
return(new Brick(game, playArena, Sprites.BrkGold, Sprites.BrkFlash, location, 0, -9, chance,
capsuleType));
}
default:
{
return(new Brick(game, playArena, Sprites.BrkWhite, Sprites.BrkFlash, location, 0, -1, chance,
capsuleType));
}
}
}
public bool IsUnlocked(BrickTypes bt)
{
return(data.unlockedBricks.Contains(bt));
}
public void SetBrick(UnityEngine.GameObject go, BrickTypes _brickTypes)
{
this.brickTypes = _brickTypes;
UtilityThings.ChooseColor(go, _brickTypes);
}
public static Sprite GetBrickTexture(BrickTypes type)
{
switch (type)
{
case BrickTypes.White:
{
return(Sprites.BrkWhite);
}
case BrickTypes.Yellow:
{
return(Sprites.BrkYellow);
}
case BrickTypes.Pink:
{
return(Sprites.BrkPink);
}
case BrickTypes.Blue:
{
return(Sprites.BrkBlue);
}
case BrickTypes.Red:
{
return(Sprites.BrkRed);
}
case BrickTypes.Green:
{
return(Sprites.BrkGreen);
}
case BrickTypes.SkyBlue:
{
return(Sprites.BrkSkyBlue);
}
case BrickTypes.Orange:
{
return(Sprites.BrkOrange);
}
case BrickTypes.Silver:
{
return(Sprites.BrkSilver);
}
case BrickTypes.Gold:
{
return(Sprites.BrkGold);
}
case BrickTypes.DarkRed:
{
return(Sprites.BrkDarkRed);
}
case BrickTypes.DarkBlue:
{
return(Sprites.BrkDarkBlue);
}
case BrickTypes.Regen:
{
return(Sprites.BrkRegen);
}
case BrickTypes.Teleport:
{
return(Sprites.BrkTeleport);
}
case BrickTypes.SilverSwap:
{
return(Sprites.BrkSilverSwap);
}
case BrickTypes.GoldSwap:
{
return(Sprites.BrkGoldSwap);
}
case BrickTypes.BlueSwap:
{
return(Sprites.BrkBlueSwap);
}
case BrickTypes.Black:
{
return(Sprites.BrkBlack);
}
case BrickTypes.BlackRegen:
{
return(Sprites.BrkBlackRegen);
}
case BrickTypes.Transmit:
{
return(Sprites.BrkTransmit);
}
default:
{
return(Sprites.BrkEmpty);
}
}
}
public bool IsBrickType(BrickTypes bt)
{
return(bt == brickType);
}
public void PlayDeath(BrickTypes bt)
{
standardDeath.Play();
Audio.Instance.PlayBrickDeath();
}
