// Start is called before the first frame update
void Start()
{
pos0 = rb.transform.position;
startTime = Time.time;
fs = new FiringSolution();
Debug.Log("success");
}
private void LaunchBoardModelOnFiringSolutionUpdated()
{
_firingSolution = _launchBoardModel.FiringSolution;
OnPropertyChanged(Properties.DataAvailable);
OnPropertyChanged(Properties.TableRow);
OnPropertyChanged(Properties.TableColumn);
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
FiringSolution fs = new FiringSolution();
Debug.Log("success");
vel = fs.calculateFiringSolution(rb.transform.position, target.transform.position, muzzleV, Physics.gravity);
if (vel.HasValue)
{
//get rid of all velocity first
rb.AddForce(Vector3.left * rb.velocity.x, ForceMode.VelocityChange);
rb.AddForce(Vector3.back * rb.velocity.z, ForceMode.VelocityChange);
rb.AddForce(Vector3.down * rb.velocity.y, ForceMode.VelocityChange);
rb.AddForce(vel.Value.normalized * muzzleV, ForceMode.VelocityChange);
Debug.Log("success");
}
}
if (Input.GetKeyDown(KeyCode.R))
{
// reset
rb.isKinematic = true;
transform.position = pos0;
rb.isKinematic = false;
}
}
private void UpdateFiringSolution(FiringSolution firingSolution, MissileAccelerationData missileAccelerationData, IShellstarModel shellstar)
{
FiringSolution = firingSolution;
AccelerationData = missileAccelerationData;
Shellstar = shellstar;
LaunchWindows = GetAvailableLaunchWindows();
OnFiringSolutionUpdated();
}
public void Reset()
{
rb.velocity = Vector3.zero;
FiringSolution fs = new FiringSolution();
Nullable <Vector3> aimVector = fs.Calculate(transform.position, target.transform.position, launchForce, Physics.gravity);
if (aimVector.HasValue)
{
rb.AddForce(aimVector.Value.normalized * launchForce, ForceMode.VelocityChange);
}
}
void Start()
{
Time.timeScale = myTimeScale;
rb = GetComponent <Rigidbody>();
FiringSolution fs = new FiringSolution();
Nullable <Vector3> aimVector = fs.Calculate(transform.position, target.transform.position, launchForce, Physics.gravity);
if (aimVector.HasValue)
{
rb.AddForce(aimVector.Value.normalized * launchForce, ForceMode.VelocityChange);
}
}
//Call Time.timeScale to readjust time
// Start is called before the first frame update
void Start()
{
rb = GetComponent <Rigidbody>();
FiringSolution launchSolve = new FiringSolution();
Nullable <Vector3> launchVector = launchSolve.Calculate(transform.position, target.transform.position, launchForce, Physics.gravity);
if (launchVector.HasValue)
{
travelTime = launchSolve.ttt;
rb.AddForce(launchVector.Value.normalized * launchForce, ForceMode.VelocityChange);
}
}
// Start is called before the first frame update
void Awake()
{
target = GameObject.FindGameObjectsWithTag("Player")[0];
Time.timeScale = myTimeScale; // allow for slowing time to see what's happening
rb = GetComponent <Rigidbody>();
FiringSolution fs = new FiringSolution();
Nullable <Vector3> aimVector = fs.Calculate(transform.position, target.transform.position, launchForce, Physics.gravity);
if (aimVector.HasValue)
{
rb.AddForce(aimVector.Value.normalized * launchForce, ForceMode.VelocityChange);
}
}
// Start is called before the first frame update
void Start()
{
Time.timeScale = myTimeScale; // allow for slowing time to see what's happening
rb = GetComponent <Rigidbody>();
targetRenderer = target[targetNum].GetComponent <Renderer>();
targetRenderer.material = targetMaterial;
fs = new FiringSolution();
//Nullable<Vector3> aimVector = fs.Calculate(transform.position, target.transform.position, launchForce, Physics.gravity);
//if (aimVector.HasValue)
//{
// rb.AddForce(aimVector.Value.normalized * launchForce, ForceMode.VelocityChange);
//}
}
private void LaunchBoardModelOnFiringSolutionUpdated()
{
_firingSolution = _launchBoardModel.FiringSolution;
OnPropertyChanged(Properties.CanViewShellstar);
OnPropertyChanged(Properties.IsDataAvailable);
OnPropertyChanged(Properties.CrossingVector);
OnPropertyChanged(Properties.MuzzleVelocity);
OnPropertyChanged(Properties.NoShotComment);
OnPropertyChanged(Properties.CvAdjustment);
OnPropertyChanged(Properties.MvAdjustment);
OnPropertyChanged(Properties.ModifiedCv);
OnPropertyChanged(Properties.ModifiedMv);
OnPropertyChanged(Properties.RoCTurn);
OnPropertyChanged(Properties.NoShot);
OnPropertyChanged(Properties.RoC);
}
private IShellstarModel BuildShellstar(FiringSolution firingSolution, MissileAccelerationData accelerationData)
{
if (firingSolution == null || firingSolution.AimAdjustment == AimAdjustment.NoShot ||
(accelerationData != null && accelerationData.ValidLaunch == false))
{
return(null);
}
var shellstar = _shellstarBuilder.BuildShellstarInfo(TargetDistance.Magnitude, LaunchingSegment, firingSolution, accelerationData);
var result = new ShellstarModel(shellstar, LaunchingSegment)
{
Tag = GetDefaultTag()
};
return(result);
}
public void Launch(float force)
{
print(target.transform.position);
FiringSolution fs = new FiringSolution();
Nullable <Vector3> aimVector = fs.Calculate(transform.position, target.transform.position, force, Physics.gravity);
if (aimVector.HasValue)
{
rb.AddForce(aimVector.Value.normalized * force, ForceMode.VelocityChange);
}
else
{
Launch(force * 1.25f);
}
print(force);
}
void Start()
{
//targets = GameObject.FindGameObjectsWithTag(targetTag);
Debug.Log(targetIndex);
Debug.Log(targets[0]);
Time.timeScale = myTimeScale;
rb = GetComponent <Rigidbody>();
FiringSolution fs = new FiringSolution();
Nullable <Vector3> aimVector = fs.Calculate(transform.position, targets[targetIndex].transform.position, launchForce, Physics.gravity);
if (aimVector.HasValue)
{
rb.AddForce(aimVector.Value.normalized * launchForce, ForceMode.VelocityChange);
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
FiringSolution fs = new FiringSolution();
Nullable <Vector3> aimVector = fs.Calculate(transform.position, target.transform.position, launchForce, Physics.gravity);
if (aimVector.HasValue)
{
rb.AddForce(aimVector.Value.normalized * launchForce, ForceMode.VelocityChange);
}
}
if (Input.GetKeyDown(KeyCode.R))
{
rb.isKinematic = true;
transform.position = startPos;
rb.isKinematic = false;
}
}
// Start is called before the first frame update
void OnEnable()
{
Time.timeScale = myTimeScale; // allow for slowing time to see what's happening
rb = GetComponent <Rigidbody>();
//Disable animation convenience settings on rigidbody
rb.useGravity = true;
rb.isKinematic = false;
FiringSolution fs = new FiringSolution();
Nullable <Vector3> aimVector = fs.Calculate(transform.position, target.transform.position, launchForce, Physics.gravity);
if (aimVector.HasValue)
{
rb.AddForce(aimVector.Value.normalized * launchForce, ForceMode.VelocityChange);
}
fireAudio.Play();
Invoke("ActivateCamera", 0.2f);
}
public FiringSolution CalculateSolution(int courseOffset, int crossingVector, int mvMultiplier, int acceleration)
{
var firingSolution = new FiringSolution
{
CrossingVector = crossingVector,
MuzzleVelocity = mvMultiplier * acceleration
};
var shotGeometryData = _shotGeometryTable.GetShotGeometry(crossingVector, firingSolution.MuzzleVelocity, courseOffset);
firingSolution.AimAdjustment = shotGeometryData.AimAdjustment;
firingSolution.ShotGeometryColumn = shotGeometryData.TableColumn;
firingSolution.ShotGeometryRow = shotGeometryData.TableRow;
firingSolution.CrossingVectorAdjustment = shotGeometryData.CvAdjustment;
firingSolution.MuzzleVelocityAdjustment = shotGeometryData.MvAdjustment;
firingSolution.ModifiedCrossingVector = (int)Math.Ceiling(firingSolution.CrossingVector * shotGeometryData.CvAdjustment);
firingSolution.ModifiedMuzzleVelocity = (int)Math.Ceiling(firingSolution.MuzzleVelocity * shotGeometryData.MvAdjustment);
firingSolution.RoCTurn = firingSolution.ModifiedCrossingVector + firingSolution.ModifiedMuzzleVelocity;
firingSolution.RoC = CalculateRoc(firingSolution.RoCTurn);
return(firingSolution);
}
protected override FiringSolution?FindFiringSolution(GameObject target)
{
return(FiringSolution.FindSolution(gameObject, ProjectilePrefab.GetComponent <ProjectileComponent>(), target));
}
public ShellstarInfo BuildShellstarInfo(int targetDistance, TurnData startingImpulse, FiringSolution firingSolution, MissileAccelerationData missileAcceleration)
{
if (firingSolution == null)
{
throw new ArgumentNullException("firingSolution", "Firing solution is needed to calculate shellstar data.");
}
int dmg50,
dmg100,
dmg200;
_projectileDamageTable.GetDamages(firingSolution.RoC, out dmg50, out dmg100, out dmg200);
var result = new ShellstarInfo
{
RoC = firingSolution.RoC,
Dmg50 = dmg50,
Dmg100 = dmg100,
Dmg200 = dmg200,
};
float inertialFlightDistance = (missileAcceleration != null) ?
// Burnout range rounded down.
(float)Math.Floor(targetDistance - missileAcceleration.BurnDistance) :
targetDistance;
BuildInertialSegments(result, inertialFlightDistance, firingSolution, missileAcceleration != null);
if (missileAcceleration != null)
{
BuildAccelerationSegments(result, targetDistance, missileAcceleration);
}
result.ImpulseTrack.Reverse();
AssignImpulseInformation(result, startingImpulse);
return(result);
}
private void BuildInertialSegments(ShellstarInfo shellstarInfo, float driftDistance, FiringSolution firingSolution, bool isMissile)
{
float currentDistance = 0;
bool roundUp = false;
// CG shells can be fired at range 0. For this case we add a single segment.
if ((int)driftDistance == 0 && firingSolution.AimAdjustment != AimAdjustment.NoShot && !isMissile)
{
shellstarInfo.ImpulseTrack.Add(new ImpulseTrackElement
{
Range = 0,
IsBurning = false
});
return;
}
// Ex 1: Drift distance = 20; RoC = 4; currentDistance = 20 is satisfies condition, 24 doesn't.
// Ex 2: Drift distance = 17; RoC = 4; currentDistance = 20 is satisfies condition, 24 doesn't.
while (driftDistance - currentDistance > -firingSolution.RoC)
{
var impulseData = new ImpulseTrackElement
{
Range = (int)Math.Min(currentDistance, driftDistance),
IsBurning = false
};
shellstarInfo.ImpulseTrack.Add(impulseData);
currentDistance += roundUp ?
(float)Math.Ceiling(firingSolution.RoC) :
(float)Math.Floor(firingSolution.RoC);
roundUp = !roundUp;
}
}
