private void OnTriggerEnter2D(Collider2D other)
{
if (other.tag == "Player")
{
IPowerUp IPowerUp = other.GetComponent <IPowerUp>();
if (IPowerUp != null)
{
AudioSource.PlayClipAtPoint(_clip, transform.position);
switch (powerupID)
{
case 0:
IPowerUp.TripleLaserBoost();
break;
case 1:
IPowerUp.SpeedBoost();
break;
case 2:
IPowerUp.ShieldBoost();
break;
default:
break;
}
}
Destroy(this.gameObject);
}
}
public void assign()
{
dic = new Dictionary <IPowerUp, int>();
track = new Dictionary <int, IPowerUp>();
pBlock = new PBlock();
pChangeNumber = new PChangeNumber();
pFreeze = new PFreeze();
pNone = new PNone();
pShow = new PShow();
pShuffle = new PShuffle();
pShuffleAll = new PShuffleAll();
dic.Add(pBlock, 2);
dic.Add(pChangeNumber, 2);
dic.Add(pFreeze, 2);
dic.Add(pNone, 2);
dic.Add(pShow, 2);
dic.Add(pShuffle, 2);
dic.Add(pShuffleAll, 2);
track.Add(pBlock.getProbability(), pBlock);
track.Add(pChangeNumber.getProbability(), pChangeNumber);
track.Add(pFreeze.getProbability(), pFreeze);
track.Add(pNone.getProbability(), pNone);
track.Add(pShow.getProbability(), pShow);
track.Add(pShuffle.getProbability(), pShuffle);
track.Add(pShuffleAll.getProbability(), pShuffleAll);
}
public void ActivateStoredPowerUp()
{
// If we don't have any stored PowerUps, then nothing to do
if (storedPowerUps.Count == 0)
{
Debug.Log("No Stored PowerUps");
return;
}
// Check if any active PowerUps are blocking the
// activation of the next PowerUp
IPowerUp nextPwrUp = storedPowerUps.Peek();
bool isBlocked = false;
activePowerUps.ForEach(delegate(IPowerUp pwrUp) {
isBlocked |= pwrUp.IsBlockingPowerUpActivation(nextPwrUp);
});
// If next PowerUp is not blocked, we can activate
// it and remove it from the stored PowerUp queue
if (!isBlocked)
{
storedPowerUps.Dequeue();
ActivatePowerUp(nextPwrUp);
}
}
// Use this for initialization
public override void Start()
{
base.Start();
// Randomize color
mainRenderer.color = IPowerUp.FromHSV(Random.value, IEnemy.saturation, IEnemy.brightness);
if ((ShipController.Instance != null) && (IGameManager.Instance != null))
{
// Check if we need to fling this enemy towards the player
if (IGameManager.Instance is ObjectSpawner)
{
// Calculate where to aim for
mSpawnPosition = ShipController.Instance.transform.position;
mRandomOffset = Random.insideUnitCircle.normalized * spawnParams.aimRange;
mSpawnPosition.x += mRandomOffset.x;
mSpawnPosition.y += mRandomOffset.y;
mSpawnPosition -= transform.position;
mSpawnPosition.Normalize();
// Face the direction of velocity
transform.rotation = ShipController.LookRotation2D(mSpawnPosition);
// Randomize force
mSpawnPosition *= Random.Range(spawnParams.speedRange.x, spawnParams.speedRange.y);
rigidbody2D.velocity = mSpawnPosition;
}
// Setup detection
detection.detectRange *= detection.detectRange;
}
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.Minus))
{
ChangeLifeAction(-1);
}
if (Input.GetKeyDown(KeyCode.Space))
{
if (HeldPowerUp != null)
{
HeldPowerUp.Use();
HeldPowerUp = null;
UIManager.UpdateUI_ClearPowerUp();
}
}
if (Input.GetKeyDown(KeyCode.Escape))
{
if (!IsPaused)
{
IsPaused = true;
Time.timeScale = 0f;
}
else if (IsPaused)
{
IsPaused = false;
Time.timeScale = 1f;
}
}
}
public SStarSpawning(IPowerUp powerup)
{
this.counter = 0;
this.Powerup = powerup;
Powerup.Velocity = Vector2.Zero;
SoundPanel.PlaySoundEffect(Sound.powerupappearsEffect);
}
protected virtual void Init()
{
Combination = GetComponent <CombinationHandler>();
WaveManager = GetComponent <WaveManager>();
powerUp = GetComponent <IPowerUp>();
cm = GetComponent <ComboManager>();
}
public IPowerUp Decorate(IPowerUp powerUp)
{
powerUp.Points += 300;
powerUp.usePowerUp = null;
powerUp.usePowerUp += powerUpEffect;
return(powerUp);
}
// Use this for initialization
public override void Start()
{
base.Start();
// Randomize color
mainRenderer.color = IPowerUp.FromHSV(Random.value, IEnemy.saturation, IEnemy.brightness);
if ((ShipController.Instance != null) && (IGameManager.Instance != null))
{
// Randomize torque
rigidbody2D.angularVelocity = Random.Range(spawnParams.torqueRange.x, spawnParams.torqueRange.y);
if (IGameManager.Instance is ObjectSpawner)
{
// Calculate where to aim for
mSpawnPosition = ShipController.Instance.transform.position;
mRandomOffset = Random.insideUnitCircle.normalized * spawnParams.aimRange;
mSpawnPosition.x += mRandomOffset.x;
mSpawnPosition.y += mRandomOffset.y;
mSpawnPosition -= transform.position;
mSpawnPosition.Normalize();
// Randomize force
mSpawnPosition *= Random.Range(spawnParams.speedRange.x, spawnParams.speedRange.y);
rigidbody2D.velocity = mSpawnPosition;
}
}
}
public void ProcessObject(List <List <Object> > matrix)
{
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
IPowerUp[] p = GetContents(matrix, x + i, y + j);
if (contains.Equals("multicoin"))
{
matrix[x + i].Add(new BlockMultiCoin(p, 16 * (x + i), 16 * (y + j)));
}
else
{
if (contains.Equals("vine"))
{
Vine v = new Vine(go, y + j + 1, 16 * (x + i), -1000);
matrix[x + i].Add(v);
VineSpawner spawner = new VineSpawner(v, 16 * (x + i), 16 * (y + j));
matrix[x + i].Add(spawner);
p = new IPowerUp[] { spawner };
}
matrix[x + i].Add(new BlockBrick(p, 16 * (x + i), 16 * (y + j)));
}
}
}
}
// Use this for initialization
public override void Start()
{
base.Start();
// Update sprite renderer color
mainRenderer.color = IPowerUp.FromHSV(Random.value, IEnemy.saturation, IEnemy.brightness);
if ((ShipController.Instance != null) && (IGameManager.Instance != null))
{
// Check if we need to fling this enemy to the player
if (IGameManager.Instance is ObjectSpawner)
{
// Randomize torque
rigidbody2D.angularVelocity = Random.Range(spawnParams.torqueRange.x, spawnParams.torqueRange.y);
// Calculate where to aim for
mSpawnPosition = ShipController.Instance.transform.position;
mRandomOffset = Random.insideUnitCircle.normalized * spawnParams.aimRange;
mSpawnPosition.x += mRandomOffset.x;
mSpawnPosition.y += mRandomOffset.y;
mSpawnPosition -= transform.position;
mSpawnPosition.Normalize();
// Randomize force
mSpawnPosition *= Random.Range(spawnParams.speedRange.x, spawnParams.speedRange.y);
rigidbody2D.velocity = mSpawnPosition;
}
// Update when we last fired
detection.detectRange *= detection.detectRange;
lastFired = Time.time;
}
}
public Crate(int x, int y, IColor color, IMap map, IMapItems wrappee, IPowerUp powerUp) : base(wrappee)
{
this.x = x;
this.y = y;
this.color = color;
this.map = map;
this.powerUp = powerUp;
}
public SFlagpoleFlagIdle(IPowerUp powerup)
{
this.Powerup = powerup;
Powerup.Sprite = new Animation(Textures.flagpoleFlag);
Powerup.Hitbox.Clear();
SetHitbox();
}
public void FindNewPowerUp()
{
do
{
this.powerUp = powerUpList[UnityEngine.Random.Range(0, this.powerUpList.Count)];
} while (!PowerUpRules(this.powerUp.type));
ritualHud.powerUpIcon.GetComponent <Image>().overrideSprite = Resources.Load <Sprite>(this.powerUp.icon);
}
private bool HasPowerUp()
{
if (currentPowerUp == null)
{
currentPowerUp = GameObject.Find("PowerupManager").GetComponent <PowerupManager>().GetPowerUp();
}
return(currentPowerUp != null);
}
public void PowerUp(IPowerUp powerUp)
{
Damage += powerUp.DamageBuff;
if (Damage < 1)
{
Damage = 1;
}
}
public void AddPower(IPowerUp power)
{
if (powerUp == null)
{
powerUp = power;
SetTarget(this);
StartEffect();
}
}
public void OnSlotMachinePull()
{
if (scoreMgr.CanAffordSpending(slotMachineCost))
{
IPowerUp powerUpPrize = GetRandomPowerUp();
storedPowerUps.Enqueue(powerUpPrize);
scoreMgr.SpendScore(slotMachineCost);
}
}
public void setPowerUp(IPowerUp setPowerUp)
{
powerUp = setPowerUp;
//notifies all game objects in power up listener list
foreach (IPowerUpChangeListener listener in powerUpChangeListenerList)
{
listener.OnAvatarPowereUpChange(powerUp);
}
}
private IPowerUp[] GetContents(List <List <Object> > matrix, int x, int y)
{
switch (this.contains)
{
case "multicoin":
{
IPowerUp[] pups = new IPowerUp[HotDAMN.MULTICOIN_BLOCK_MAXIMUM];
for (int i = 0; i < pups.Length; i++)
{
pups[i] = new Coin(16 * x, 16 * y);
pups[i].State = new SCoinInBlock(pups[i]);
matrix[x].Add(pups[i]);
}
return(pups);
}
case "coin":
{
IPowerUp p = new Coin(16 * x, 16 * y);
p.State = new SCoinInBlock(p);
matrix[x].Add(p);
return(new IPowerUp[] { p });
}
case "powerup":
{
IPowerUp p1 = new Mushroom(16 * x, 16 * y);
p1.State = new SMushroomInBlock(p1);
IPowerUp p2 = new FireFlower(16 * x, 16 * y);
p2.State = new SFireFlowerInBlock(p2);
matrix[x].Add(p1);
matrix[x].Add(p2);
return(new IPowerUp[] { p1, p2 });
}
case "star":
{
IPowerUp p = new Star(16 * x, 16 * y);
p.State = new SStarInBlock(p);
matrix[x].Add(p);
return(new IPowerUp[] { p });
}
case "1up":
{
IPowerUp p = new _1Up(16 * x, 16 * y);
p.State = new S1UpInBlock(p);
matrix[x].Add(p);
return(new IPowerUp[] { p });
}
default:
{
return(new IPowerUp[] {});
}
}
}
public SCoinIdle(IPowerUp powerup)
{
this.Powerup = powerup;
Powerup.Sprite = new Animation(Textures.powerupCoin, 6, 10);
Powerup.Hitbox.Clear();
SetHitbox();
Powerup.Velocity = Vector2.Zero;
}
public SFireFlowerIdle(IPowerUp powerup)
{
this.Powerup = powerup;
Powerup.Sprite = new Animation(Textures.powerupFireFlower, 4, 4);
Powerup.Hitbox.Clear();
SetHitbox();
Powerup.Velocity = Vector2.Zero;
}
// Use this for initialization
public override void Start()
{
// Play animation
animation.Play();
// Get a random hue
hue = Random.value;
IPowerUp.FromHSV(hue, saturation, brightness, ref spriteColor);
label.color = spriteColor;
}
public virtual void OnTriggerEnter2D(Collider2D other)
{
IPowerUp playerCollectPowerUp = other.gameObject.GetComponent <Player>();
if (playerCollectPowerUp != null)
{
playerCollectPowerUp.PowerUpCollected(PowerUpIndex);
ReturnPowerUp();
}
}
/// <summary>
/// Disables a power-up for a board.
/// </summary>
/// <param name="powerUp">The power-up to disble.</param>
/// <param name="ct">(Optional) A cancellation token for async processing.</param>
public async Task DisablePowerUp(IPowerUp powerUp, CancellationToken ct = default(CancellationToken))
{
var endpoint = EndpointFactory.Build(EntityRequestType.Board_Write_DisablePowerUp,
new Dictionary <string, object>
{
{ "_boardId", OwnerId },
{ "_id", OwnerId }
});
await JsonRepository.Execute(Auth, endpoint, ct, AdditionalParameters);
}
// Kick off the Slot Machine and select the PowerUp that the player
// will receive once the Reel stops.
public void PlaySlotsForPowerUp()
{
Guid winningPowerUpGuid = slotPlanner.SelectWinningPowerUp();
GameObject powerUpPrefab = powerUpDataStore.GetPowerUpByGuid(winningPowerUpGuid);
winningPowerUp = Instantiate(powerUpPrefab, Vector3.zero, Quaternion.identity).GetComponent <IPowerUp>();
gameState.SetSlotMachineState(SlotMachineState.START_SPINNING);
fullRotationsToComplete = Random.Range((int)fullRotationsToCompleteRange.x, (int)fullRotationsToCompleteRange.y);
}
public SStarBouncingLeft(IPowerUp powerup)
{
this.Powerup = powerup;
Powerup.Sprite = new Animation(Textures.powerupStar, 4, 4);
Powerup.Hitbox.Clear();
SetHitbox();
Powerup.Velocity = new Vector2(-1f, Powerup.Velocity.Y);
Powerup.Acceleration = Physics.GRAVITY / 3;
}
void AddOrUpdateDictionaryEntry(IPowerUp key, int value)
{
if (maxNumberOfSpawn.ContainsKey(key))
{
maxNumberOfSpawn[key] = value;
}
else
{
maxNumberOfSpawn.Add(key, value);
}
}
public SStarInBlock(IPowerUp powerup)
{
this.Powerup = powerup;
Powerup.Sprite = new Animation(Textures.blockHidden);
Powerup.Hitbox.Clear();
SetHitbox();
Powerup.Acceleration = Vector2.Zero;
Powerup.Velocity = Vector2.Zero;
}
public SCoinSpawning(IPowerUp powerup)
{
this.counter = 0;
this.Powerup = powerup;
Powerup.Sprite = new Animation(Textures.powerupCoinSpinning, 4, 4);
Powerup.Velocity = new Vector2(0, -7f);
Powerup.Acceleration = Physics.GRAVITY / 2;
SoundPanel.PlaySoundEffect(Sound.coinEffect);
HUD.COINS[HUD.currentPlayer]++;
HUD.SCORE[HUD.currentPlayer] += HotDAMN.SCORE_COLLECT_COIN;
}
public S1UpMovingRight(IPowerUp powerup)
{
this.Powerup = powerup;
Powerup.Sprite = new Animation(Textures.powerup1up);
Powerup.Hitbox.Clear();
SetHitbox();
Powerup.Acceleration = Physics.GRAVITY;
Powerup.Velocity = new Vector2(1f, 0);
}
public void OnAvatarPowereUpChange(IPowerUp powerUp){
if (powerUp == null) {
GetComponent<SpriteRenderer> ().sprite = empty;
} else if (powerUp.GetType() == typeof(PowerBirdSpawn)) {
GetComponent<SpriteRenderer> ().sprite = health;
} else if (powerUp.GetType() == typeof(PowerSlowMotion)) {
GetComponent<SpriteRenderer>().sprite = time;
}else if (powerUp.GetType() == typeof(DoPowerBlast)) {
GetComponent<SpriteRenderer>().sprite = blast;
}
}
void Awake()
{
characterController = GetComponent<CharacterController>();
anim = GetComponent<PlayerAnimator> ();
xPower = gameObject.AddComponent<SpeedPower>();
yPower = gameObject.AddComponent<GiantHookPower>();
}
void IncreaseCount(IPowerUp key)
{
int newValue = maxNumberOfSpawn[key] + 1;
AddOrUpdateDictionaryEntry(key, newValue);
}
public void setPowerUp(IPowerUp setPowerUp) {
powerUp = setPowerUp;
//notifies all game objects in power up listener list
foreach (IPowerUpChangeListener listener in powerUpChangeListenerList) {
listener.OnAvatarPowereUpChange (powerUp);
}
}
/// <summary>
/// Load the components required for this script.
/// </summary>
protected void Awake()
{
powerUp = GetComponent("IPowerUp") as IPowerUp;
used = false;
}