public override void Start()
{
base.Start();
movementCalculator = GetComponent <MovementCalculator>();
objectTag += (int)ObjectTag.Platform;
}
// *** MONOBEHAVIOUR FUNCTIONS ***
void Awake()
{
if (ActiveGrid == null)
{
ActiveGrid = this;
}
else
{
Debug.LogError("A Grid component was initialized while another one is already running: " + gameObject.name);
}
InitializeEntities();
InitializeTiles();
movementCalculator = new MovementCalculator();
GameObject newObj = Instantiate(Resources.Load <GameObject>("Prefabs/Interface/PathLine"));
newObj.transform.SetParent(transform, true);
movementLine = newObj.GetComponent <LineRenderer>();
movementLine.startColor = Color.cyan;
movementLine.endColor = Color.cyan;
movementLine.useWorldSpace = false;
movementLine.gameObject.SetActive(false);
}
public void MovementCalculator_IsMoving_Returns_True_When_Velocity_Is_Non_Zero()
{
var movementCalculator = new MovementCalculator();
var isMoving = movementCalculator.IsMoving(Vector3.forward);
Assert.AreEqual(true, isMoving);
}
public void MovementCalculator_HasMovementInput_Returns_False_When_No_Input()
{
var movementCalculator = new MovementCalculator();
var hasMovementInput = movementCalculator.HasMovementInput(Vector2.zero);
Assert.AreEqual(false, hasMovementInput);
}
public void MovementCalculator_HasMovementInput_Returns_True_When_Y_Has_Input()
{
var movementCalculator = new MovementCalculator();
var hasMovementInput = movementCalculator.HasMovementInput(Vector2.up);
Assert.AreEqual(true, hasMovementInput);
}
public void MovementCalculator_IsMoving_Returns_False_When_Velocity_Is_Zero()
{
var movementCalculator = new MovementCalculator();
var isMoving = movementCalculator.IsMoving(Vector3.zero);
Assert.AreEqual(false, isMoving);
}
public void MovementCalculator_NewVelocity_Side_Velocity_Increased_By_SideSpeed()
{
var testPlayer = new GameObject();
var movementCalculator = new MovementCalculator();
var newVelocity = movementCalculator.CalculateNewVelocity(
testPlayer.transform, new Vector3(10, 10, 10), Vector2.right, 6, 4);
Assert.AreEqual(4, newVelocity.x);
}
public void MovementCalculator_NewVelocity_Forward_Velocity_Increased_By_ForwardSpeed()
{
var testPlayer = new GameObject();
var movementCalculator = new MovementCalculator();
var newVelocity = movementCalculator.CalculateNewVelocity(
testPlayer.transform, new Vector3(10, 10, 10), Vector2.up, 6, 4);
Assert.AreEqual(6, newVelocity.z);
}
public void MovementCalculator_NewVelocity_Down_Input_Returns_Back_Direction()
{
var testPlayer = new GameObject();
var movementCalculator = new MovementCalculator();
var newVelocity = movementCalculator.CalculateNewVelocity(
testPlayer.transform, new Vector3(10, 10, 10), Vector2.down, 6, 4);
Assert.AreEqual(-6, newVelocity.z);
}
// Use this for initialization
void Start()
{
movementCalculator = new MovementCalculator();
IsBusy = false;
AttachedEntity = GetComponent <Entity>();
AttachedUnit = GetComponent <Unit>();
}
public virtual void Start()
{
_rigidbody = GetComponent <Rigidbody>();
_prevPos = transform.position;
_calc = new MovementCalculator();
var gameController = GameObject.FindGameObjectWithTag("GameController");
_input = gameController.GetComponent <ActiveCarInputProvider>();
}
public void MovementCalculator_NewVelocity_Returns_With_Current_Fall_Speed()
{
var testPlayer = new GameObject();
var movementCalculator = new MovementCalculator();
var newVelocity = movementCalculator.CalculateNewVelocity(
testPlayer.transform, new Vector3(10, 10, 10), Vector2.up, 6, 4);
Assert.AreEqual(10, newVelocity.y);
}
public void MovementCalculator_NewVelocity_Left_Input_Returns_Left_Direction()
{
var testPlayer = new GameObject();
var movementCalculator = new MovementCalculator();
var newVelocity = movementCalculator.CalculateNewVelocity(
testPlayer.transform, new Vector3(10, 10, 10), Vector2.left, 6, 4);
Assert.AreEqual(-4, newVelocity.x);
}
// Use this for initialization
void Start()
{
state = 1;
launcher = GetComponentInChildren <Launcher>();
ammo = GetComponent <ObjectPool>();
movementCalculator = GetComponent <MovementCalculator>();
detectArea = GetComponent <CircleCollider2D>();
detectArea.isTrigger = true;
ObstacleBasic ob = ammo.objectToPool.GetComponent <ObstacleBasic>();
ob.lifeTime = bulletLifeTime;
}
public void WhenCalculatingStepsNumberWithLowMaxSpeed()
{
var stepsMM = 100;
var distance = 20;
var sut = new MovementCalculator(new AxisConfiguration
{
MaxAcceleration = 2,
StepsPerMM = stepsMM,
MaxSpeedPerMM = 1
}, "X");
var expectedStepsCount = distance * stepsMM;
var steps = sut.CalculateSteps(0, distance, 50);
var actualStepsContu = steps.TailSteps.Count + steps.BodySteps.Count + steps.HeadSteps.Count;
Assert.AreEqual(expectedStepsCount, actualStepsContu);
}
public List <Vector2Int> GetPath(Vector2Int from, Vector2Int to)
{
// Check that from and to are reachable
if (distanceArray[from.x, from.y] < 0)
{
return(null);
}
if (distanceArray[to.x, to.y] < 0)
{
return(null);
}
// Create a new movement calculator with new from
MovementCalculator tempMoveCalc = new MovementCalculator();
tempMoveCalc.CalculateMovement(from, GetReachableTiles());
return(tempMoveCalc.GetPath(to));
}
public void WhenCalculatingStepsNumberWithHighMaxSpeedAndHighResultion()
{
// arange
var stepsMM = 2000;
var distance = 20;
var sut = new MovementCalculator(new AxisConfiguration
{
MaxAcceleration = 2,
StepsPerMM = stepsMM,
MaxSpeedPerMM = 50
}, "X");
var expectedStepsCount = distance * stepsMM;
// act
var steps = sut.CalculateSteps(0, distance, 50);
var actualStepsContu = steps.TailSteps.Count + steps.BodySteps.Count + steps.HeadSteps.Count;
// assert
Assert.AreEqual(expectedStepsCount, actualStepsContu);
Assert.AreEqual(0, steps.BodySteps.Count);
}
// Update is called once per frame
void Update()
{
if (calculator == null)
{
calculator = new MovementCalculator();
calculator.CalculateMovement(position, range);
var tiles = calculator.GetReachableTiles();
Grid.ActiveGrid.HighlightTile(position, GridTile.TileHighlights.Friend);
foreach (var tile in tiles)
{
Grid.ActiveGrid.HighlightTile(tile, GridTile.TileHighlights.Movement);
}
}
if (GridTile.CurrentlySelected != null)
{
var path = calculator.GetPath(GridTile.CurrentlySelected.Coordinates);
if (path != null)
{
line.gameObject.SetActive(true);
line.positionCount = path.Count;
for (int i = 0; i < path.Count; i++)
{
line.SetPosition(i, Grid.ActiveGrid.GridToWorld(path[i], 0.1f));
}
}
else
{
line.gameObject.SetActive(false);
}
}
else
{
line.gameObject.SetActive(false);
}
}
public void WhenGettingFullSpeed()
{
// arange
var stepsMM = 1;
var distance = 1000;
var givenSpeed = 50;
var sut = new MovementCalculator(new AxisConfiguration
{
MaxAcceleration = 200,
StepsPerMM = stepsMM,
MaxSpeedPerMM = givenSpeed
}, "X");
var expectedStepsCount = distance * stepsMM;
// act
var steps = sut.CalculateSteps(0, distance, 50);
var actualStepsContu = steps.TailSteps.Count + steps.BodySteps.Count + steps.HeadSteps.Count;
// assert
Assert.AreEqual(expectedStepsCount, actualStepsContu);
Assert.IsTrue(steps.BodySteps.Count > 1);
Assert.AreEqual(givenSpeed, steps.BodySteps[0].SpeedAfterMove);
}
private static void InitializeAxes()
{
_xAxisCalculator = new MovementCalculator(new AxisConfiguration
{
MaxAcceleration = 500,
MaxSpeedPerMM = 300,
StepsPerMM = _stepsmmx
}, "X");
_yAxisCalculator = new MovementCalculator(new AxisConfiguration
{
MaxAcceleration = 500,
MaxSpeedPerMM = 300,
StepsPerMM = _stepsmmy
}, "Y");
_eAxisCalculator = new MovementCalculator(new AxisConfiguration
{
MaxAcceleration = 15,
MaxSpeedPerMM = 20,
StepsPerMM = _stepsmme
}, "E");
}
public static void TestSomething()
{
MovementCalculator.CalculateMovementForWfHolp();
}
