public void OnFlowerHit(ICenterRose rose, IOrb orb)
{
bool allClear = true;
foreach (var flower in flowers)
{
if (flower.State == PointGeneratorState.Full)
{
allClear = false;
break;
}
}
if (allClear)
{
if (orb.Owner != null)
{
scoring = true;
scoringPlayer = orb.Owner;
foreach (var flower in flowers)
{
flower.ResetCooldown();
}
}
}
}
private void OnTriggerExit2D(Collider2D collision)
{
IOrb orb = collision.AsOrb();
if (orb != null)
{
stateMachine.SetState(AimRegionState.Normal);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
IOrb orb = collision.AsOrb();
if (orb != null)
{
HitOrb(orb);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
IOrb orb = collision.AsOrb();
if (orb != null && stateMachine.CurrentStateKey == PaddleState.Normal)
{
StartAim(orb);
}
}
void UpdateOrb(IOrb orb)
{
if (this.state != WellState.Active)
{
return;
}
PullOrb(orb);
}
public override void OnBump(IOrb orb, Vector2 collisionPoint)
{
if (orb.Owner != null)
{
orb.Owner.GainUltCharge(points, Position);
}
manager.OnBeeHit(this);
stateMachine.SetState(BeeState.Hit);
}
void PullOrb(IOrb orb)
{
var delta = (Vector2)transform.position - orb.Position;
var scale = 1 - Mathf.Clamp(delta.magnitude / (orb.Radius + circleCollider.radius), 0, 1);
var scaleSq = (float)Math.Pow(scale, 2);
orb.Pull(delta, gravity * scaleSq);
Debug.Log("delta=" + delta + ", scale=" + scale + ", scaleSq=" + scaleSq + ", gravity*scaleSq=" + gravity * scaleSq);
}
private void HitOrb(IOrb orb)
{
var hitVector = new Vector2(0, 1);
if (hero.Side == HeroSide.Top)
{
hitVector = new Vector2(0, -1);
}
var hitSpeed = 0f;
var velocity = hero.AimVector - hero.Position;
hitSpeed = Mathf.Clamp(velocity.magnitude / touchVelocityMax, 0, 1);
hitVector = hitVector * (1 - hitSpeed) + hitSpeed * velocity.normalized;
if (hero.Side == HeroSide.Top && hitVector.y > 0 || hero.Side == HeroSide.Bottom && hitVector.y < 0)
{
hitVector = new Vector2(hitVector.x, -hitVector.y);
}
var slope = hitVector.x / hitVector.y;
if (slope > minSlope)
{
hitVector = new Vector2(minSlope, Math.Sign(hitVector.y));
}
else if (slope < -minSlope)
{
hitVector = new Vector2(-minSlope, Math.Sign(hitVector.y));
}
var spin = MathHelper.ShortestVector(orb.Position, hero.AimVector, hero.AimSpinVector + hero.AimVector);
var spinMagnitude = spin.magnitude;
if (spinMagnitude < spinMinCutoff)
{
spinMagnitude = 0;
}
else
{
spinMagnitude = Mathf.Clamp(spinMagnitude, spinMinCutoff, spinMaxCutoff) * spinCoefficient;
spinMagnitude *= Math.Sign(MathHelper.Determinant(orb.Position, hero.AimVector, hero.AimSpinVector + hero.AimVector));
}
Debug.Log("HitOrb! hitSpeed: " + hitSpeed + " dirX: " + hitVector.x + " dirY: " + hitVector.y + " spin: " + spinMagnitude);
orb.ForceHit(hero, hitVector, 1f, spinMagnitude);
stateMachine.SetState(PaddleState.Cooldown);
hero.HitOrb();
}
void HitOrb(IOrb orb)
{
stateMachine.SetState(AimRegionState.Cooldown);
/*var futureOrbPos = orb.Position + orb.Direction * 2;
*
* int collisions = Physics2D.RaycastNonAlloc(orb.Position, orb.Direction, collisionBuffer, 3, collisionFilter.layerMask);
* for (int i = 0; i < collisions; i++)
* {
* IPaddle collidedPaddle = collisionBuffer[i].collider.GetComponent<Paddle>();
* if (collidedPaddle != null && collidedPaddle == this.paddle)
* {
* }
* }*/
}
private void RemoveOrb(IOrb orb)
{
if (orb is Quas)
{
this.QuasCount--;
}
else if (orb is Wex)
{
this.WexCount--;
}
else
{
this.ExortCount--;
}
this.CurrentOrbs.Remove(orb);
}
void OrbHit(IOrb orb)
{
if (this.state != TreeState.Charging)
{
return;
}
if (orb.Owner != null && orb.Owner.Side == side)
{
curHits++;
if (curHits == hitsToUnleash)
{
state = TreeState.Unleashing;
curHits = 0;
}
}
}
public void OnCenterHit(IOrb orb)
{
if (state != WellState.Active)
{
return;
}
if (orb.Owner.Side == HeroSide.Top)
{
pushDirection = new Vector2(0, -1);
}
else
{
pushDirection = new Vector2(0, 1);
}
orb.ForceHit(Vector2.zero, 0);
SetState(WellState.Charging);
}
public override void OnBump(IOrb orb, Vector2 collisionPoint)
{
Vector2 normal = (orb.Position - collisionPoint).normalized;
Vector2 newDirection = orb.Direction - 2 * (orb.Direction.x * normal.x + orb.Direction.y * normal.y) * normal;
float newSpin = orb.Spin;
newDirection = MathHelper.Rotate(newDirection, newSpin * .5f);
if (Math.Abs(newSpin) < .25f)
{
newSpin = 0;
}
else
{
newSpin -= .25f * Math.Sign(newSpin);
}
orb.ForceHit(newDirection, orb.SpeedMultiplier, newSpin);
}
public override void OnBump(IOrb orb, Vector2 collisionPoint)
{
if (State != PointGeneratorState.Full)
{
return;
}
ResetCooldown();
if (orb.Owner != null)
{
orb.Owner.GainUltCharge(points, Position);
}
if (onHitEffect != null)
{
this.AddChild(Game.Objects.CreatePrefab <SimpleEffect>(onHitEffect.gameObject));
}
OnFullBump(orb, collisionPoint);
}
public void OnFlowerHit(ISideFlower flower, IOrb orb)
{
flowers.Remove(flower);
}
private void StartAim(IOrb orb)
{
this.orb = orb;
stateMachine.SetState(PaddleState.Aiming);
}
public override void OnCenterBump(IOrb orb)
{
well.OnCenterHit(orb);
}
public virtual void OnCenterBump(IOrb orb)
{
}
public override void OnFullBump(IOrb orb, Vector2 collisionPoint)
{
flowerBed.OnFlowerHit(this, orb);
}
public override void OnFullBump(IOrb orb, Vector2 collisionPoint)
{
spawner.OnFlowerHit(this, orb);
Kill();
}
public virtual void OnFullBump(IOrb orb, Vector2 collisionPoint)
{
}
protected override void OnParented(IGameEntity parent)
{
orb = (IOrb)parent;
}
void Awake()
{
orb = this.transform.parent.GetComponent <Orb>();
}
