void OnTriggerEnter(Collider other)
{
var otherObject = other.gameObject.GetComponent <CollisionEntity>();
if (otherObject == null)
{
return;
}
EntityType otherType = otherObject.entityType;
CollisionEffect effect = CollisionEffect.None;
switch (otherType)
{
case EntityType.Red:
effect = hitRed;
break;
case EntityType.Green:
effect = hitGreen;
break;
case EntityType.Blue:
effect = hitBlue;
break;
}
ResolveCollision(effect);
}
void OnTriggerEnter(Collider other)
{
var otherObject = other.gameObject.GetComponent <CollisionEntity>();
if (otherObject == null)
{
return;
}
EntityType otherType = otherObject.entityType;
CollisionEffect effect = CollisionEffect.None;
switch (otherType)
{
case EntityType.Player:
effect = hitPlayer;
ScoreKeeper.Score += scorePlayer;
break;
case EntityType.Red:
effect = hitRed;
ScoreKeeper.Score += ((float)scoreRed / 4);
break;
case EntityType.Green:
effect = hitGreen;
ScoreKeeper.Score += ((float)scoreGreen / 4);
break;
case EntityType.Blue:
effect = hitBlue;
ScoreKeeper.Score += ((float)scoreBlue / 4);
break;
}
ResolveCollision(effect, otherObject);
}
public CollisionEffect GetEffect(int effectID)
{
CollisionEffect effect = null;
collisionEffects.TryGetValue(effectID, out effect);
return(effect);
}
protected override void Collision(BaseEntity col, Direction dir)
{
base.Collision(col, dir);
CollisionEffect effect = new CollisionEffect(col, dir);
collisionEffects.Add(effect);
Game.AddEntity(effect);
}
void Awake()
{
util = new Util();
rules = GameObject.Find("Ruleset").GetComponent <Ruleset>();
hitRed = rules.CollisionEffects[util.CollisionEffectsIndex(EntityType.Player, EntityType.Red)];
hitGreen = rules.CollisionEffects[util.CollisionEffectsIndex(EntityType.Player, EntityType.Green)];
hitBlue = rules.CollisionEffects[util.CollisionEffectsIndex(EntityType.Player, EntityType.Blue)];
speed = rules.PlayerSpeed;
}
//initialise the collisionEffects array to the default effect of none
private CollisionEffect[] DefaultCollisionEffects()
{
int numCollisionEffects = Enum.GetNames(typeof(CollisionEffect)).Length;
CollisionEffect[] defaultEffects = new CollisionEffect[numCollisionEffects * numCollisionEffects];
for (int i = 0; i < defaultEffects.Length; i++)
{
defaultEffects[i] = CollisionEffect.None;
}
return(defaultEffects);
}
private void Start()
{
_collisionEffect = GetComponentInChildren <CollisionEffect>();
_platformStartScale = transform.localScale;
_startBoundary = new Boundary()
{
xMin = boundary.xMin, xMax = boundary.xMax
};
GameManager.Instance.BallsManager.BallCountChanged += DecreaseScaleX;
}
private void UpdatePushDirection()
{
//work out if the other entity is pushed by us
CollisionEffect otherEffect = rules.CollisionEffects[util.CollisionEffectsIndex(this.pushList[0].entityType, this.entityType)];
if (this.pushList.Count == 1)
{
CollisionEntity pusher = this.pushList[0];
this.moving = pusher.moving;
this.currentMoveSpeed = pusher.currentMoveSpeed;
}
}
private void ResolveCollision(CollisionEffect effect)
{
switch (effect)
{
case CollisionEffect.None:
return;
case CollisionEffect.Teleport:
Teleport();
return;
case CollisionEffect.Death:
scoreKeeper.GameLost();
return;
//TODO: rest of the effects
}
}
private void ResolveCollision(CollisionEffect effect, CollisionEntity other)
{
switch (effect)
{
case CollisionEffect.None:
return;
case CollisionEffect.Teleport:
Teleport();
return;
case CollisionEffect.Death:
Destroy(gameObject);
return;
case CollisionEffect.Push:
Push(other);
return;
}
}
private void GetRules()
{
collisionEffects = new CollisionEffect[Enum.GetNames(typeof(CollisionEffect)).Length];
//TODO: better way of doing this - just use this.entitytype
if (entityType == EntityType.Red)
{
speed = rules.RedSpeed;
movementType = rules.RedMovement;
target = rules.RedTarget;
scorePlayer = rules.ScorePlayerRed;
scoreRed = rules.ScoreRedRed;
scoreGreen = rules.ScoreRedGreen;
scoreBlue = rules.ScoreRedBlue;
}
else if (entityType == EntityType.Green)
{
speed = rules.GreenSpeed;
movementType = rules.GreenMovement;
target = rules.GreenTarget;
scorePlayer = rules.ScorePlayerGreen;
scoreRed = rules.ScoreRedGreen;
scoreGreen = rules.ScoreGreenGreen;
scoreBlue = rules.ScoreGreenBlue;
}
else if (entityType == EntityType.Blue)
{
speed = rules.BlueSpeed;
movementType = rules.BlueMovement;
target = rules.BlueTarget;
scorePlayer = rules.ScorePlayerBlue;
scoreRed = rules.ScoreRedBlue;
scoreGreen = rules.ScoreGreenBlue;
scoreBlue = rules.ScoreBlueBlue;
}
hitPlayer = rules.CollisionEffects[util.CollisionEffectsIndex(this.entityType, EntityType.Player)];
hitRed = rules.CollisionEffects[util.CollisionEffectsIndex(this.entityType, EntityType.Red)];
hitGreen = rules.CollisionEffects[util.CollisionEffectsIndex(this.entityType, EntityType.Green)];
hitBlue = rules.CollisionEffects[util.CollisionEffectsIndex(this.entityType, EntityType.Blue)];
this.currentMoveSpeed = this.speed;
}
/// <summary>
/// Handles a message sent to this component.
/// </summary>
/// <param name="message">Message to be handled</param>
/// <returns>True, if handled, otherwise false</returns>
public override bool ExecuteMessage(IMessage message)
{
switch (message.Type)
{
case MessageType.AddCollisionEffect:
{
MsgAddCollisionEffect msgAddEffect = message as MsgAddCollisionEffect;
message.TypeCheck(msgAddEffect);
AddEffect(msgAddEffect.EffectType, msgAddEffect.EffectID);
}
return(true);
case MessageType.RemoveCollisionEffect:
{
MsgRemoveCollisionEffect msgRemEffect = message as MsgRemoveCollisionEffect;
message.TypeCheck(msgRemEffect);
if (msgRemEffect.RemoveAll)
{
RemoveAllEffectsOfType(msgRemEffect.EffectType);
}
else
{
RemoveEffect(msgRemEffect.EffectID);
}
}
return(true);
case MessageType.InitCollisionEffect:
{
MsgInitCollisionEffect msgInitEffect = message as MsgInitCollisionEffect;
message.TypeCheck(msgInitEffect);
CollisionEffect effect = GetEffect(msgInitEffect.EffectID);
if (effect != null)
{
if (msgInitEffect.DirectionalEffect)
{
if (!effect.InitializeDirectionalEffect(msgInitEffect.Direction, msgInitEffect.Strength))
{
throw new Exception("This collision effect doesn't handle directional effects");
}
}
else
{
if (!effect.InitializeNonDirectionalEffect(msgInitEffect.Strength))
{
throw new Exception("This collision effect doesn't handle non-directional effects");
}
}
}
}
return(true);
case MessageType.Collision:
{
MsgOnCollision msgCollData = message as MsgOnCollision;
message.TypeCheck(msgCollData);
NofityEffectsOfCollision(msgCollData.EntityID);
}
return(true);
case MessageType.CollisionOff:
{
MsgOffCollision msgCollData = message as MsgOffCollision;
message.TypeCheck(msgCollData);
NofityEffectsOfCollisionOff(msgCollData.EntityID);
}
return(true);
default:
return(false);
}
}
public void InitializeCollisionEffect(CollisionEffectDefinition effectDef)
{
CollisionEffect effect = GetEffect(effectDef.EffectUniqueID);
effect.InitializeEffect(effectDef);
}
