public void Distance(double theta1, double theta2, double dist)
{
RadialPosition rp1 = new RadialPosition(1, theta1);
double _dist = rp1.Distance(new RadialPosition(1, theta2));
Assert.AreEqual(Math.Round(dist, 2), Math.Round(_dist, 2));
}
void CheckMovementDone(RadialPosition to)
{
if (state == TutorialState.Movement)
{
if (movementStep == 0 && to.Lane == 4)
{
movementStep++;
}
else if (movementStep == 1 && to.Lane == 7)
{
movementStep++;
}
else if (movementStep == 2 && to.Lane == 5)
{
state = TutorialState.Swapping;
Invoke("SetupSwap", 1);
}
UpdateWobbleColor();
}
if (state == TutorialState.SuperShot)
{
Player.SupershotEnabled = to.Lane == 1;
}
}
void KeyboardMovement()
{
var position = boardMover.Position;
int delta = 0;
if (Input.GetKeyDown(KeyCode.D))
{
delta--;
}
if (Input.GetKeyDown(KeyCode.A))
{
delta++;
}
if (delta != 0)
{
var newPosition = new RadialPosition(position.Lane + delta, 0);
if (BoardController.Instance.TryMove(boardMover, newPosition))
{
Factory.Instance.PlaySound(MovementClip, pitchVariance.GetRandomPitch(), MovementVolume);
sr.sprite = PlayerSprites[newPosition.Lane];
OnMove?.Invoke(newPosition);
}
else
{
Factory.Instance.PlaySound(BlockedClip, pitchVariance.GetRandomPitch(), BlockedVolume);
}
}
}
void Update()
{
SpacesLeft = TOTAL_SPACES;
LanesLeft = BoardController.NUM_LANES;
for (int lane = 0; lane < BoardController.NUM_LANES; lane++)
{
for (int space = 0; space < BoardController.NUM_SPACES - 1; space++)
{
if (BoardController.Instance.GetMover(new RadialPosition(lane, space)) != null)
{
SpacesLeft--;
if (space == 0)
{
LanesLeft--;
}
}
}
}
for (int lane = 0; lane < ActivateTimes.Length; lane++)
{
var position = new RadialPosition(lane, BoardController.NUM_SPACES - 1);
laneCountDowns[lane] -= Time.deltaTime;
if (!FirstEnabled[lane] && laneCountDowns[lane] <= 5 || FirstEnabled[lane])
{
var c = Factory.Instance.OrbColors[nextOrbTypes[lane]];
if (BoardController.Instance.GetMover(position) != null)
{
WobbleSprites[lane].color = new Color(c.r, c.g, c.b, 0);
}
else
{
WobbleSprites[lane].color = new Color(c.r, c.g, c.b, 1);
}
}
if (laneCountDowns[lane] <= particleSpawnLength && !spawnedParticleCreation[lane] && BoardController.Instance.GetMover(position) == null)
{
var orbSpawn = Instantiate(OrbSpawnPrefab, WobbleSprites[lane].transform.localPosition, Quaternion.identity);
orbSpawn.color = Factory.Instance.OrbColors[nextOrbTypes[lane]];
spawnedParticleCreation[lane] = true;
}
if (laneCountDowns[lane] <= 0)
{
laneCountDowns[lane] = LaneSpawnTime * ((float)LanesLeft / (BoardController.NUM_LANES - 1));
SpawnOrb(position, lane);
nextOrbTypes[lane] = GetNextOrbType(lane);
spawnedParticleCreation[lane] = false;
WobbleSprites[lane].color = Factory.Instance.OrbColors[nextOrbTypes[lane]];
}
}
LightController.Instance.LightAmount(SpacesLeft / (float)TOTAL_SPACES);
if (SpacesLeft <= 1)
{
GameController.Instance.EndGame();
}
}
/// <summary>
/// Spawns a projectile. Projectiles are fast, invunerable and self destructs on impact with the hero.
/// </summary>
void spawnProjectile()
{
this.colorModifier.FadeToDelected(this.attackFrequency / 3f);
RadialPosition thisRadialPos = RotationUtils.XYToRadialPos(transform.position);
this.projectile.SetRadialSpawnPosition(thisRadialPos.GetAngle(), thisRadialPos.GetRadius());
this.enemySpawner.InstantiateEnemyPrefab(this.projectile);
}
public void RandomStep(double radius, double theta, double stepSize)
{
RadialPosition rp1 = new RadialPosition(radius, theta);
rp1.RandomStep(stepSize);
double dist = rp1.Distance(new RadialPosition(radius, theta));
Assert.AreEqual(Math.Round(stepSize, 2), Math.Round(dist, 2));
}
public void AddMover(BoardMover mover, RadialPosition pos)
{
if (positionLookup.ContainsKey(mover))
{
throw new Exception("Mover already on board");
}
positionLookup.Add(mover, pos);
movers[pos.Index] = mover;
}
public void StepTo(double radius, double theta, double stepSize)
{
RadialPosition rp1 = new RadialPosition(0, 0);
RadialPosition rp2 = new RadialPosition(radius, theta);
rp1.StepTo(rp2, stepSize);
Assert.AreEqual(stepSize, rp1.radius, "Radius is wrong");
Assert.AreEqual(theta, rp1.theta, "Angle is wrong");
}
public bool TryMove(GameObject obj, RadialPosition from, RadialPosition to)
{
if (GetObject(to) == null)
{
RemoveObject(from);
AddObject(obj, to);
return(true);
}
return(false);
}
public int GetLastEmptySpace(int lane)
{
int startIndex = new RadialPosition(lane, 0).Index;
for (int i = 1; i < NUM_SPACES; i++)
{
if (movers[startIndex + i] != null)
{
return(i - 1);
}
}
return(NUM_SPACES - 1);
}
public void Setup()
{
SetupOrbs(true, 0);
boardMover.enabled = true;
var startingPos = new RadialPosition(2, 0);
BoardController.Instance.AddMover(GetComponent <BoardMover>(), startingPos);
sr.sprite = PlayerSprites[startingPos.Lane];
transform.position = BoardController.Instance.GetPosition(startingPos);
BulletsLeft = 4;
BulletRechargeAmount = 0;
}
public Orb CreateLaneOrb(int lane, int type, int position = BoardController.NUM_SPACES - 1)
{
var orb = Instantiate(OrbPrefab);
orb.Type = type;
orb.GetComponent <SpriteRenderer>().sprite = OrbSprites[type];
var radialPos = new RadialPosition(lane, position);
var boardMover = orb.GetComponent <BoardMover>();
BoardController.Instance.AddMover(boardMover, radialPos);
orb.transform.position = BoardController.Instance.GetPosition(radialPos);
return(orb);
}
void Update()
{
RadialPosition radialPosition = RotationUtils.XYToRadialPos(this.transform.position);
float step = MovementSpeed * Time.deltaTime;
float angularStep = this.angularSpeed * Time.deltaTime;
float circlingStep = this.circlingSpeed * Time.deltaTime;
if (Vector3.Distance(Vector3.zero, transform.position) > Range)
{
radialPosition.AddRadius((-1) * step);
radialPosition.AddAngle(angularStep);
MoveTo(radialPosition);
if (RotationUtils.InCounterClockwiseLimits(radialPosition.GetAngle(), zigZagAngleHigh, zigZagAngleLow) && zigZag)
{
angularSpeed = -1 * angularSpeed;
}
}
else // If in range, do appropriate attack.
{
radialPosition.AddAngle(circlingStep);
MoveTo(radialPosition);
if (RotationUtils.InCounterClockwiseLimits(radialPosition.GetAngle(), zigZagAngleHigh, zigZagAngleLow) && zigZag)
{
circlingSpeed = -1 * circlingSpeed;
}
MoveTo(radialPosition);
if (selfDestruct)
{
doDamageToBoss();
KillSelf();
}
// Mele attack
else if (Range <= Parameters.MAX_MELE_RANGE && !IsInvoking("doDamageToBoss"))
{
InvokeRepeating("doDamageToBoss", 0, this.attackFrequency);
}
// Ranged attack
else if (Range > Parameters.MAX_MELE_RANGE && !IsInvoking("spawnProjectile"))
{
InvokeRepeating("spawnProjectile", 0, this.attackFrequency);
}
}
}
public bool TryMove(BoardMover mover, RadialPosition to)
{
if (mover.Locked)
{
return(false);
}
if (GetMover(to) == null)
{
movers[GetMoverPosition(mover).Index] = null;
positionLookup.Remove(mover);
AddMover(mover, to);
mover.CallMove();
return(true);
}
return(false);
}
void SpawnOrb(RadialPosition pos, int lane)
{
if (BoardController.Instance.GetMover(pos) == null)
{
Factory.Instance.CreateLaneOrb(pos.Lane, nextOrbTypes[lane]);
}
for (int i = 1; i < BoardController.NUM_SPACES; i++)
{
var movePos = new RadialPosition(pos.Lane, i);
var mover = BoardController.Instance.GetMover(movePos);
if (mover == null)
{
continue;
}
BoardController.Instance.TryMove(mover, new RadialPosition(movePos.Lane, movePos.Position - 1));
}
}
public void CreateLaunchOrb(int lane, Vector2 position, int type, int lastEmptySpace)
{
var orb = Instantiate(OrbPrefab);
orb.Type = type;
orb.GetComponent <SpriteRenderer>().sprite = OrbSprites[type];
orb.Shoot = true;
var radialPos = new RadialPosition(lane, lastEmptySpace);
var boardMover = orb.GetComponent <BoardMover>();
boardMover.MovementType = MovementType.Linear;
BoardController.Instance.AddMover(boardMover, radialPos);
boardMover.OnCloseEnough += orb.CloseEnough;
boardMover.Offset = (lane % 2 == 0 ? orb.StraightBump : orb.DiagonalBump).Rotate(lane / 2 * 90f);
orb.transform.position = position;
}
public static Vector3 RadialPosToXY(RadialPosition radialPosition)
{
float angle = radialPosition.GetAngle();
angle = MakePositiveAngle(angle);
float radius = radialPosition.GetRadius();
float x = Mathf.Cos(Mathf.Deg2Rad * angle) * radius;
float y = Mathf.Sin(Mathf.Deg2Rad * angle) * radius;
if (Mathf.Abs(x) < 0.001)
{
x = 0;
}
if (Mathf.Abs(y) < 0.001)
{
y = 0;
}
return(new Vector3(x, y));
}
public bool isInAttackArea(float lowAngle, float highAngle, float nearRadius, float farRadius)
{
float spriteRadius = transform.Find("Sprite").GetComponent <SpriteRenderer>().bounds.size.x / 2;
float distanceToBossActual = Mathf.Max(Vector3.Distance(Vector3.zero, transform.position), 0);
float distanceToBossFar = distanceToBossActual + spriteRadius;
float distanceToBossNear = distanceToBossActual - spriteRadius;
RadialPosition radialPosition = RotationUtils.XYToRadialPos(this.transform.position);
float enemyWidthAngle = Mathf.Rad2Deg * Mathf.Acos(1 - Mathf.Pow(spriteRadius / Mathf.Sqrt(2 * distanceToBossActual), 2));
float enemyHighAngle = radialPosition.GetAngle() + enemyWidthAngle;
float enemyLowAngle = radialPosition.GetAngle() - enemyWidthAngle;
bool inHighAngle = RotationUtils.InCounterClockwiseLimits(enemyHighAngle, lowAngle, highAngle);
bool inLowAngle = RotationUtils.InCounterClockwiseLimits(enemyLowAngle, lowAngle, highAngle);
bool bossLargerThanRadius = RotationUtils.InCounterClockwiseLimits(lowAngle, enemyLowAngle, enemyHighAngle) &&
RotationUtils.InCounterClockwiseLimits(highAngle, enemyLowAngle, enemyHighAngle);
bool inRadius = distanceToBossNear <= farRadius && distanceToBossFar >= nearRadius;
return((inLowAngle || inHighAngle || bossLargerThanRadius) && inRadius);
}
void Update()
{
Cooldown -= Time.deltaTime;
// Change transform
var targetPosition = BoardController.Instance.GetPosition(Position);
transform.position = Vector2.Lerp(transform.position, targetPosition, 1f - Mathf.Exp(-MovementSharpness * Time.deltaTime));
if (Cooldown > 0)
{
return;
}
// Input
int delta = 0;
if (Input.GetKeyDown(Clockwise))
{
delta--;
}
if (Input.GetKeyDown(CounterClockwise))
{
delta++;
}
if (delta != 0)
{
var newPosition = new RadialPosition(Position.Lane + delta, 0);
var moved = BoardController.Instance.TryMove(gameObject, Position, newPosition);
if (moved)
{
Position = newPosition;
Cooldown = WaitTime;
}
}
}
public void MoveTo(RadialPosition radialPosition)
{
transform.position = RotationUtils.RadialPosToXY(radialPosition);
}
public GameObject GetObject(RadialPosition pos)
{
return(Lanes[pos.Lane].Objects[pos.Position]);
}
public void AddObject(GameObject obj, RadialPosition pos)
{
Lanes[pos.Lane].Objects[pos.Position] = obj;
}
public void RemoveObject(RadialPosition pos)
{
Lanes[pos.Lane].Objects[pos.Position] = null;
}
public Vector2 GetPosition(RadialPosition pos) => Lanes[pos.Lane].Spaces[pos.Position];
public Vector2 GetPosition(RadialPosition pos) => positions[pos.Index];
public BoardMover GetMover(RadialPosition pos) => movers[pos.Index];
