public RandomAccWeap(int damageLevel) : base(0x1ECD)
{
switch (damageLevel)
{
case 1:
DamageLevel = WeaponDamageLevel.Ruin;
break;
case 2:
DamageLevel = WeaponDamageLevel.Might;
break;
case 3:
DamageLevel = WeaponDamageLevel.Force;
break;
case 4:
DamageLevel = WeaponDamageLevel.Power;
break;
case 5:
DamageLevel = WeaponDamageLevel.Vanq;
break;
default:
DamageLevel = WeaponDamageLevel.Ruin;
break;
}
Weight = 1.0;
Name = "Random accurate weapon of " + DamageLevel.ToString().ToLower();
Hue = 1960;
}
public override void clearState()
{
engineDamage = DamageLevel.NONE;
trannyDamage = DamageLevel.NONE;
aeroDamage = DamageLevel.NONE;
maxSuspensionDamage = DamageLevel.NONE;
maxBrakeDamage = DamageLevel.NONE;
timeWhenDamageLastChanged = DateTime.MinValue;
isMissingWheel = false;
damageToReportNext = null;
reportedDamagesLevels.Clear();
minDamageToReport = DamageLevel.TRIVIAL;
nextPunctureCheck = DateTime.UtcNow + timeToWaitForDamageToSettle;
componentDestroyed = Component.NONE;
orientationSamples.Clear();
nextOrientationCheckDue = DateTime.MinValue;
isRolling = false;
timeOfDangerousAcceleration = DateTime.MinValue;
timeToRecheckAfterPotentiallyDangerousAcceleration = DateTime.MaxValue;
cancelWaitingForDriverIsOK(DriverOKResponseType.NONE);
playedAreYouOKInThisSession = false;
triggerCheckDriverIsOKForIRacingAfter = DateTime.MaxValue;
waitingAfterPotentiallyDangerousAcceleration = false;
speedAfterPotentiallyDangerousAcceleration = float.MaxValue;
}
// used when damage level decreases
private void resetReportedDamage(Component component, DamageLevel newDamageLevel)
{
if (reportedDamagesLevels.ContainsKey(component))
{
reportedDamagesLevels[component] = newDamageLevel;
}
}
// Update is called once per frame
void Update()
{
float currentHP = health.currentHP;
float maxHP = health.maxHP;
if (currentHP / maxHP <= 0.25f)
{
if (level != DamageLevel.Quarter)
{
level = DamageLevel.Quarter;
SpawnFires(QuarterDamage);
}
}
else if (currentHP / maxHP <= 0.5f)
{
if (level != DamageLevel.Half)
{
level = DamageLevel.Half;
SpawnFires(HalfDamage);
}
}
else if (currentHP / maxHP <= 0.755f)
{
if (level != DamageLevel.ThreeQuarter)
{
level = DamageLevel.ThreeQuarter;
SpawnFires(ThreeQuarterDamage);
}
}
}
private void addReportedDamage(Component component, DamageLevel damageLevel)
{
if (reportedDamagesLevels.ContainsKey(component))
{
reportedDamagesLevels[component] = damageLevel;
}
else
{
reportedDamagesLevels.Add(component, damageLevel);
}
}
private Boolean hasBeenReported(Component component, DamageLevel damageLevel)
{
foreach (KeyValuePair <Component, DamageLevel> componentAndDamageAlreadyReported in reportedDamagesLevels)
{
if (component == componentAndDamageAlreadyReported.Key && componentAndDamageAlreadyReported.Value == damageLevel)
{
return(true);
}
}
return(false);
}
private DamageLevel getLastReportedDamageLevel(Component component)
{
DamageLevel level = DamageLevel.NONE;
if (reportedDamagesLevels.TryGetValue(component, out level))
{
return(level);
}
return(DamageLevel.NONE);
}
public RandomAccWeap() : base(0x1ECD)
{
if (DamageLevel == WeaponDamageLevel.Regular)
{
DamageLevel = WeaponDamageLevel.Ruin;
}
Weight = 1.0;
Name = "Random accurate weapon of " + DamageLevel.ToString().ToLower();
Hue = 1960;
}
public override void clearState()
{
engineDamage = DamageLevel.NONE;
trannyDamage = DamageLevel.NONE;
aeroDamage = DamageLevel.NONE;
maxSuspensionDamage = DamageLevel.NONE;
maxBrakeDamage = DamageLevel.NONE;
timeWhenDamageLastChanged = DateTime.MinValue;
isMissingWheel = false;
damageToReportNext = null;
reportedDamagesLevels.Clear();
minDamageToReport = DamageLevel.TRIVIAL;
}
public override void clearState()
{
engineDamage = DamageLevel.NONE;
trannyDamage = DamageLevel.NONE;
aeroDamage = DamageLevel.NONE;
maxSuspensionDamage = DamageLevel.NONE;
maxBrakeDamage = DamageLevel.NONE;
timeWhenDamageLastChanged = DateTime.MinValue;
isMissingWheel = false;
damageToReportNext = null;
reportedDamagesLevels.Clear();
minDamageToReport = DamageLevel.TRIVIAL;
nextPunctureCheck = DateTime.Now + timeToWaitForDamageToSettle;
}
public DamageLevel AddDamageLevel(Sprite sprite = null, float damageRequired = 0.0f)
{
if (DamageLevels == null)
{
DamageLevels = new List <DamageLevel>();
}
var newDamageLevel = new DamageLevel(); DamageLevels.Add(newDamageLevel);
newDamageLevel.Sprite = sprite;
newDamageLevel.DamageRequired = damageRequired;
return(newDamageLevel);
}
public DamageLevel AddDamageLevel(Sprite sprite = null, float damageRequired = 0.0f)
{
if (DamageLevels == null)
{
DamageLevels = new List<DamageLevel>();
}
var newDamageLevel = new DamageLevel(); DamageLevels.Add(newDamageLevel);
newDamageLevel.Sprite = sprite;
newDamageLevel.DamageRequired = damageRequired;
return newDamageLevel;
}
private bool chooseDamageLevel()
{
Console.WriteLine("Choose damage level ( 0 - No damage, 1 - small, 2 - medium, 3 - heavy, 4 - ship is completely destroyed)");
var input = Console.ReadLine();
int damageLvl;
Int32.TryParse(input, out damageLvl);
if (damageLvl <= (int)DamageLevel.Destroyed && damageLvl >= (int)DamageLevel.Undamaged)
{
damageLevel = new DamageLevel();
damageLevel = (DamageLevel)damageLvl;
}
else
{
Console.WriteLine("Wrong input. Try Again");
return(false);
}
return(true);
}
private void healthChanged()
{
if (DamageAble.HP <= 2)
{
DamageLevel = DamageLevel.BROKEN;
}
else if (DamageAble.HP <= 6)
{
DamageLevel = DamageLevel.DAMAGED;
}
else
{
DamageLevel = DamageLevel.OK;
}
if (DamageLevel != DamageLevel.OK)
{
UnMountModule();
}
}
private void UpdateDamageLevels()
{
if (DamageLevels == null)
{
DamageLevels = new List <DamageLevel>();
}
// Copy default damage level from SpriteRenderer?
if (DamageLevels.Count == 0)
{
if (spriteRenderer == null)
{
spriteRenderer = GetComponent <SpriteRenderer>();
}
if (spriteRenderer.sprite != null)
{
var newDamageLevel = new DamageLevel(); DamageLevels.Add(newDamageLevel);
newDamageLevel.Sprite = spriteRenderer.sprite;
}
}
}
private Boolean hasBeenReported(Component component, DamageLevel damageLevel)
{
foreach (KeyValuePair<Component, DamageLevel> componentAndDamageAlreadyReported in reportedDamagesLevels)
{
if (component == componentAndDamageAlreadyReported.Key && componentAndDamageAlreadyReported.Value == damageLevel)
{
return true;
}
}
return false;
}
protected override void triggerInternal(GameStateData previousGameState, GameStateData currentGameState)
{
if (currentGameState.CarDamageData.DamageEnabled)
{
aeroDamage = currentGameState.CarDamageData.OverallAeroDamage;
trannyDamage = currentGameState.CarDamageData.OverallTransmissionDamage;
engineDamage = currentGameState.CarDamageData.OverallEngineDamage;
if (enableBrakeDamageMessages)
{
if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.DESTROYED))
{
maxBrakeDamage = DamageLevel.DESTROYED;
}
else if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.MAJOR))
{
maxBrakeDamage = DamageLevel.MAJOR;
}
else if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.MINOR))
{
maxBrakeDamage = DamageLevel.MINOR;
}
else if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.TRIVIAL))
{
maxBrakeDamage = DamageLevel.TRIVIAL;
}
}
if (enableSuspensionDamageMessages)
{
if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.DESTROYED))
{
maxSuspensionDamage = DamageLevel.DESTROYED;
}
else if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.MAJOR))
{
maxSuspensionDamage = DamageLevel.MAJOR;
}
else if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.MINOR))
{
maxSuspensionDamage = DamageLevel.MINOR;
}
else if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.TRIVIAL))
{
maxSuspensionDamage = DamageLevel.TRIVIAL;
}
isMissingWheel = !currentGameState.PitData.InPitlane && (!currentGameState.TyreData.LeftFrontAttached || !currentGameState.TyreData.RightFrontAttached ||
!currentGameState.TyreData.LeftRearAttached || !currentGameState.TyreData.RightRearAttached);
}
if (engineDamage < getLastReportedDamageLevel(Component.ENGINE))
{
resetReportedDamage(Component.ENGINE, engineDamage);
}
if (trannyDamage < getLastReportedDamageLevel(Component.TRANNY))
{
resetReportedDamage(Component.TRANNY, trannyDamage);
}
if (maxSuspensionDamage < getLastReportedDamageLevel(Component.SUSPENSION))
{
resetReportedDamage(Component.SUSPENSION, maxSuspensionDamage);
}
if (maxBrakeDamage < getLastReportedDamageLevel(Component.BRAKES))
{
resetReportedDamage(Component.BRAKES, maxBrakeDamage);
}
if (aeroDamage < getLastReportedDamageLevel(Component.AERO))
{
resetReportedDamage(Component.AERO, aeroDamage);
}
minDamageToReport = (DamageLevel)Math.Max((int)engineDamage, Math.Max((int)trannyDamage, Math.Max((int)maxSuspensionDamage, Math.Max((int)maxBrakeDamage, (int) aeroDamage))));
Tuple<Component, DamageLevel> worstUnreportedDamage = getWorstUnreportedDamage();
if (worstUnreportedDamage != null && worstUnreportedDamage.Item2 >= minDamageToReport)
{
if (damageToReportNext == null || worstUnreportedDamage.Item1 != damageToReportNext.Item1 || worstUnreportedDamage.Item2 != damageToReportNext.Item2)
{
timeWhenDamageLastChanged = currentGameState.Now;
damageToReportNext = worstUnreportedDamage;
}
else if (timeWhenDamageLastChanged.Add(timeToWaitForDamageToSettle) < currentGameState.Now)
{
Console.WriteLine("reporting ...");
Console.WriteLine(damageToReportNext.Item1 + ", " + damageToReportNext.Item2);
if (reportedDamagesLevels.ContainsKey(damageToReportNext.Item1))
{
reportedDamagesLevels[damageToReportNext.Item1] = damageToReportNext.Item2;
}
else
{
reportedDamagesLevels.Add(damageToReportNext.Item1, damageToReportNext.Item2);
}
if (enableDamageMessages)
{
playDamageToReport();
}
}
}
}
}
/// <summary>
/// Set the damage status of a particular vehicle panel
/// </summary>
public bool SetPanelDamage(Panel panel, DamageLevel damage)
{
return(MtaShared.SetVehiclePanelState(element, (int)panel, (int)damage));
}
public override MaterialsSet CountRepairMaterials(DamageLevel damageLevel)
{
return(repair.FerryRepairMaterials(damageLevel));
}
public void InvalidateDamageState(Mobile from)
{
if (Durability >= 100)
m_DamageState = DamageLevel.Pristine;
else if (Durability >= 75.0)
m_DamageState = DamageLevel.Slightly;
else if (Durability >= 50.0)
m_DamageState = DamageLevel.Moderately;
else if (Durability >= 25.0)
m_DamageState = DamageLevel.Heavily;
else
m_DamageState = DamageLevel.Severely;
if (Durability <= 0)
{
DoAreaMessage(1116297, 5, null); //The ship cannon has been destroyed!
Delete();
if (from != null && from.InRange(this.Location, 5))
from.SendLocalizedMessage(1116297); //The ship cannon has been destroyed!
}
InvalidateProperties();
}
public BaseCannon(BaseGalleon galleon)
{
Movable = false;
m_Cleaned = true;
m_Charged = false;
m_Primed = false;
m_Galleon = galleon;
m_AmmoType = AmmoType.Empty;
m_Hits = MaxHits;
m_DamageState = DamageLevel.Pristine;
}
//INotificationStrategy notificationStrategy;
//IRepairStrategy repairStrategy;
//public RepairDock(INotificationStrategy notifStr, IRepairStrategy repStr)
//{
// notificationStrategy = notifStr;
// repairStrategy = repStr;
//}
public abstract int CountRepairTime(DamageLevel damageLevel);
override protected void triggerInternal(GameStateData previousGameState, GameStateData currentGameState)
{
// if we've crashed hard and are waiting for the player to say they're OK, don't process anything else in this event:
if (waitingForDriverIsOKResponse)
{
if (timeWhenAskedIfDriverIsOK.Add(TimeSpan.FromSeconds(8)) < currentGameState.Now)
{
timeWhenAskedIfDriverIsOK = currentGameState.Now;
if (driverIsOKRequestCount == 1)
{
audioPlayer.playMessageImmediately(new QueuedMessage(folderAreYouOKSecondTry, 0, type: SoundType.CRITICAL_MESSAGE, priority: 15));
driverIsOKRequestCount = 2;
}
else if (driverIsOKRequestCount == 2)
{
// no response after 3 requests, he's dead, jim.
audioPlayer.playMessageImmediately(new QueuedMessage(folderAreYouOKThirdTry, 0, type: SoundType.CRITICAL_MESSAGE, priority: 15));
cancelWaitingForDriverIsOK(DriverOKResponseType.NONE);
}
}
return;
}
if (waitingAfterPotentiallyDangerousAcceleration)
{
if (currentGameState.PositionAndMotionData.CarSpeed > speedAfterPotentiallyDangerousAcceleration + 5)
{
Console.WriteLine("Car has accelerated, cancelling wait for crash message");
waitingAfterPotentiallyDangerousAcceleration = false;
timeToRecheckAfterPotentiallyDangerousAcceleration = DateTime.MaxValue;
}
else if (timeToRecheckAfterPotentiallyDangerousAcceleration > currentGameState.Now)
{
waitingAfterPotentiallyDangerousAcceleration = false;
timeToRecheckAfterPotentiallyDangerousAcceleration = DateTime.MaxValue;
timeOfDangerousAcceleration = currentGameState.Now;
// special case for iRacing: no damage data so we can't hang this off 'destroyed' components
triggerCheckDriverIsOKForIRacingAfter = currentGameState.Now.Add(TimeSpan.FromSeconds(2));
}
else
{
// suspend the rest of this event
return;
}
}
// need to be careful with interval here.
// Disable these for iRacing, which has some spikes in car speed data that trigger false positives
if (CrewChief.gameDefinition.gameEnum != GameEnum.IRACING &&
enableCrashMessages && !playedAreYouOKInThisSession && !currentGameState.PitData.InPitlane &&
currentGameState.PositionAndMotionData.CarSpeed > 0.001)
{
if (previousGameState != null)
{
double interval = (currentGameState.Now - previousGameState.Now).TotalSeconds;
if (interval > 0.01)
{
double calculatedAcceleration = Math.Abs(currentGameState.PositionAndMotionData.CarSpeed - previousGameState.PositionAndMotionData.CarSpeed) / interval;
/*Console.WriteLine("Interval = " + interval +
* " Current speed = " + currentGameState.PositionAndMotionData.CarSpeed +
* " previous speed = " + previousGameState.PositionAndMotionData.CarSpeed + " acceleration = " + calculatedAcceleration / 9.8f + "g");*/
// if we're subject to > 40G (400m/s2), this is considered dangerous. If we've stopped (or nearly stopped) immediately
// after the impact, assume it's a bad 'un. If we're still moving after the impact, track the speed for 3 seconds and
// if it doesn't increase in that time, we can assume it's a bad 'un
if (calculatedAcceleration > 400)
{
Console.WriteLine("Massive impact. Current speed = " + currentGameState.PositionAndMotionData.CarSpeed.ToString("0.000") +
" previous speed = " + previousGameState.PositionAndMotionData.CarSpeed.ToString("0.000") + " acceleration = " + (calculatedAcceleration / 9.8f).ToString("0.0000") + "g");
if (currentGameState.PositionAndMotionData.CarSpeed < 3)
{
timeOfDangerousAcceleration = currentGameState.Now;
// special case for iRacing: no damage data so we can't hang this off 'destroyed' components
triggerCheckDriverIsOKForIRacingAfter = currentGameState.Now.Add(TimeSpan.FromSeconds(4));
}
else
{
// massive acceleration but we're still moving
timeToRecheckAfterPotentiallyDangerousAcceleration = currentGameState.Now.Add(TimeSpan.FromSeconds(3));
waitingAfterPotentiallyDangerousAcceleration = true;
speedAfterPotentiallyDangerousAcceleration = currentGameState.PositionAndMotionData.CarSpeed;
}
}
}
}
}
Boolean orientationSamplesFull = orientationSamples.Count > orientationSamplesCount;
if (orientationSamplesFull)
{
orientationSamples.RemoveFirst();
}
orientationSamples.AddLast(currentGameState.PositionAndMotionData.Orientation);
// don't check for rolling if we've just had a dangerous acceleration as we don't want both messages to trigger
if (enableCrashMessages && currentGameState.Now > nextOrientationCheckDue && orientationSamplesFull &&
currentGameState.Now.Subtract(timeOfDangerousAcceleration) > TimeSpan.FromSeconds(10))
{
nextOrientationCheckDue = currentGameState.Now.Add(orientationCheckEvery);
checkOrientation(currentGameState.PositionAndMotionData.CarSpeed);
}
if (currentGameState.CarDamageData.DamageEnabled && currentGameState.SessionData.SessionRunningTime > 10 && currentGameState.Now > nextPunctureCheck)
{
nextPunctureCheck = currentGameState.Now + timeToWaitForDamageToSettle;
CornerData.Corners puncture = getPuncture(currentGameState.TyreData);
if (puncture != lastReportedPunctureCorner)
{
lastReportedPunctureCorner = puncture;
switch (puncture)
{
case CornerData.Corners.FRONT_LEFT:
audioPlayer.playMessage(new QueuedMessage(folderLeftFrontPuncture, 0, abstractEvent: this, priority: 10));
break;
case CornerData.Corners.FRONT_RIGHT:
audioPlayer.playMessage(new QueuedMessage(folderRightFrontPuncture, 0, abstractEvent: this, priority: 10));
break;
case CornerData.Corners.REAR_LEFT:
audioPlayer.playMessage(new QueuedMessage(folderLeftRearPuncture, 0, abstractEvent: this, priority: 10));
break;
case CornerData.Corners.REAR_RIGHT:
audioPlayer.playMessage(new QueuedMessage(folderRightRearPuncture, 0, abstractEvent: this, priority: 10));
break;
}
}
}
if (currentGameState.CarDamageData.DamageEnabled)
{
aeroDamage = currentGameState.CarDamageData.OverallAeroDamage;
trannyDamage = currentGameState.CarDamageData.OverallTransmissionDamage;
engineDamage = currentGameState.CarDamageData.OverallEngineDamage;
if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.DESTROYED))
{
maxBrakeDamage = DamageLevel.DESTROYED;
componentDestroyed = Component.BRAKES;
}
else if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.MAJOR))
{
maxBrakeDamage = DamageLevel.MAJOR;
}
else if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.MINOR))
{
maxBrakeDamage = DamageLevel.MINOR;
}
else if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.TRIVIAL))
{
maxBrakeDamage = DamageLevel.TRIVIAL;
}
else
{
maxBrakeDamage = DamageLevel.NONE;
}
if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.DESTROYED))
{
maxSuspensionDamage = DamageLevel.DESTROYED;
componentDestroyed = Component.SUSPENSION;
}
else if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.MAJOR))
{
maxSuspensionDamage = DamageLevel.MAJOR;
}
else if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.MINOR))
{
maxSuspensionDamage = DamageLevel.MINOR;
}
else if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.TRIVIAL))
{
maxSuspensionDamage = DamageLevel.TRIVIAL;
}
else
{
maxSuspensionDamage = DamageLevel.NONE;
}
isMissingWheel = !currentGameState.PitData.InPitlane && (!currentGameState.TyreData.LeftFrontAttached || !currentGameState.TyreData.RightFrontAttached ||
!currentGameState.TyreData.LeftRearAttached || !currentGameState.TyreData.RightRearAttached);
if (engineDamage < getLastReportedDamageLevel(Component.ENGINE))
{
resetReportedDamage(Component.ENGINE, engineDamage);
}
if (trannyDamage < getLastReportedDamageLevel(Component.TRANNY))
{
resetReportedDamage(Component.TRANNY, trannyDamage);
}
if (maxSuspensionDamage < getLastReportedDamageLevel(Component.SUSPENSION))
{
resetReportedDamage(Component.SUSPENSION, maxSuspensionDamage);
}
if (maxBrakeDamage < getLastReportedDamageLevel(Component.BRAKES))
{
resetReportedDamage(Component.BRAKES, maxBrakeDamage);
}
if (aeroDamage < getLastReportedDamageLevel(Component.AERO))
{
resetReportedDamage(Component.AERO, aeroDamage);
}
minDamageToReport = (DamageLevel)Math.Max((int)engineDamage, Math.Max((int)trannyDamage, Math.Max((int)maxSuspensionDamage, Math.Max((int)maxBrakeDamage, (int)aeroDamage))));
Tuple <Component, DamageLevel> worstUnreportedDamage = getWorstUnreportedDamage();
if (worstUnreportedDamage != null && worstUnreportedDamage.Item2 >= minDamageToReport)
{
if (damageToReportNext == null || worstUnreportedDamage.Item1 != damageToReportNext.Item1 || worstUnreportedDamage.Item2 != damageToReportNext.Item2)
{
timeWhenDamageLastChanged = currentGameState.Now;
damageToReportNext = worstUnreportedDamage;
}
else if (timeWhenDamageLastChanged.Add(timeToWaitForDamageToSettle) < currentGameState.Now)
{
Console.WriteLine("Reporting ...");
Console.WriteLine(damageToReportNext.Item1 + ", " + damageToReportNext.Item2);
// put *all* the damage levels in the 'reported' set, even though we haven't actually reported them.
// This ensure we only ever play the worst damage on the car when damage has just increased
// Only do this if the component damage is *less* than the one we just reported
if (Component.AERO == damageToReportNext.Item1 || aeroDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.AERO, aeroDamage);
}
if (Component.BRAKES == damageToReportNext.Item1 || maxBrakeDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.BRAKES, maxBrakeDamage);
}
if (Component.ENGINE == damageToReportNext.Item1 || engineDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.ENGINE, engineDamage);
}
if (Component.SUSPENSION == damageToReportNext.Item1 || maxSuspensionDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.SUSPENSION, maxSuspensionDamage);
}
if (Component.TRANNY == damageToReportNext.Item1 || trannyDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.TRANNY, trannyDamage);
}
if (enableDamageMessages)
{
playDamageToReport(currentGameState.SessionData.SessionType == SessionType.Race && currentGameState.SessionData.NumCarsOverall > 2, currentGameState.Now);
}
}
}
}
else if (CrewChief.gameDefinition.gameEnum == GameEnum.IRACING && currentGameState.Now > triggerCheckDriverIsOKForIRacingAfter)
{
triggerCheckDriverIsOKForIRacingAfter = DateTime.MaxValue;
checkIfDriverIsOK(currentGameState.Now);
}
}
public BaseGalleon(Direction direction) : base(direction, false)
{
m_Hits = MaxHits;
m_DamageTaken = DamageLevel.Pristine;
m_BaseBoatHue = 0;
AddMooringLines(direction);
AddCannonTiles(direction);
AddHoldTiles(direction);
AddGalleonPilotAndWheel(direction);
Timer.DelayCall(TimeSpan.FromSeconds(2), new TimerCallback(MarkRunes));
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 3:
case 2:
m_Pole = reader.ReadItem() as BindingPole;
m_CapturedCaptain = reader.ReadMobile();
goto case 1;
case 1:
m_BaseBoatHue = reader.ReadInt();
goto case 0;
case 0:
m_GalleonPilot = reader.ReadMobile();
m_Hits = reader.ReadInt();
m_Wheel = reader.ReadItem() as ShipWheel;
m_GalleonHold = reader.ReadItem() as GalleonHold;
if (version < 3)
{
reader.ReadItem();
reader.ReadItem();
}
m_DamageTaken = (DamageLevel)reader.ReadInt();
m_BasePaintHue = reader.ReadInt();
m_PaintCoats = reader.ReadInt();
m_NextPaintDecay = reader.ReadDateTime();
m_SecurityEntry = new SecurityEntry(this, reader);
int count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
Static tile = reader.ReadItem() as Static;
if (tile != null && !tile.Deleted)
AddCannonTile(tile);
}
count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
Item cannon = reader.ReadItem();
if (cannon != null && !cannon.Deleted)
m_Cannons.Add(cannon);
}
count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
Static filler = reader.ReadItem() as Static;
if (filler != null && !filler.Deleted)
AddFillerTile(filler);
}
count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
MooringLine line = reader.ReadItem() as MooringLine;
if (line != null && !line.Deleted)
AddMooringLine(line);
}
count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
HoldItem hItem = reader.ReadItem() as HoldItem;
if (hItem != null && !hItem.Deleted)
AddHoldTile(hItem);
}
count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
Item addon = reader.ReadItem();
if (addon != null && !addon.Deleted)
AddAddon(addon);
}
count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
Static atile = reader.ReadItem() as Static;
if (atile != null && !atile.Deleted)
AddAddonTile(atile);
}
break;
}
if (m_Pole != null)
m_Pole.Galleon = this;
}
// used when damage level decreases
private void resetReportedDamage(Component component, DamageLevel newDamageLevel)
{
if (reportedDamagesLevels.ContainsKey(component))
{
reportedDamagesLevels[component] = newDamageLevel;
}
}
public abstract MaterialsSet CountRepairMaterials(DamageLevel damageLevel);
public Spell(string name, string championName, SpellSlot spellslot, float range, float width,
double speed, double delay, Spelltype spelltype, DamageLevel damagelvl, CCtype cctype, bool collision)
{
ChampionName = championName;
Spellslot = spellslot;
Name = name;
Range = range;
Width = width;
Speed = speed;
Delay = delay;
SpellType = spelltype;
Damagelvl = damagelvl;
CcType = cctype;
Collision = collision;
}
public override int CountRepairTime(DamageLevel damageLevel)
{
return(repair.FerryRepairTime(damageLevel));
}
private void UpdateDamageLevels()
{
if (DamageLevels == null)
{
DamageLevels = new List<DamageLevel>();
}
// Copy default damage level from SpriteRenderer?
if (DamageLevels.Count == 0)
{
if (spriteRenderer == null) spriteRenderer = GetComponent<SpriteRenderer>();
if (spriteRenderer.sprite != null)
{
var newDamageLevel = new DamageLevel(); DamageLevels.Add(newDamageLevel);
newDamageLevel.Sprite = spriteRenderer.sprite;
}
}
}
private void addReportedDamage(Component component, DamageLevel damageLevel)
{
reportedDamagesLevels[component] = damageLevel;
}
override protected void triggerInternal(GameStateData previousGameState, GameStateData currentGameState)
{
if (currentGameState.CarDamageData.DamageEnabled && currentGameState.SessionData.SessionRunningTime > 10 && currentGameState.Now > nextPunctureCheck)
{
nextPunctureCheck = currentGameState.Now + timeToWaitForDamageToSettle;
CornerData.Corners puncture = getPuncture(currentGameState.TyreData);
if (puncture != lastReportedPunctureCorner)
{
lastReportedPunctureCorner = puncture;
switch (puncture)
{
case CornerData.Corners.FRONT_LEFT:
audioPlayer.playMessage(new QueuedMessage(folderLeftFrontPuncture, 0, this));
break;
case CornerData.Corners.FRONT_RIGHT:
audioPlayer.playMessage(new QueuedMessage(folderRightFrontPuncture, 0, this));
break;
case CornerData.Corners.REAR_LEFT:
audioPlayer.playMessage(new QueuedMessage(folderLeftRearPuncture, 0, this));
break;
case CornerData.Corners.REAR_RIGHT:
audioPlayer.playMessage(new QueuedMessage(folderRightRearPuncture, 0, this));
break;
}
}
}
if (currentGameState.CarDamageData.DamageEnabled)
{
aeroDamage = currentGameState.CarDamageData.OverallAeroDamage;
trannyDamage = currentGameState.CarDamageData.OverallTransmissionDamage;
engineDamage = currentGameState.CarDamageData.OverallEngineDamage;
if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.DESTROYED))
{
maxBrakeDamage = DamageLevel.DESTROYED;
}
else if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.MAJOR))
{
maxBrakeDamage = DamageLevel.MAJOR;
}
else if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.MINOR))
{
maxBrakeDamage = DamageLevel.MINOR;
}
else if (currentGameState.CarDamageData.BrakeDamageStatus.hasValueAtLevel(DamageLevel.TRIVIAL))
{
maxBrakeDamage = DamageLevel.TRIVIAL;
}
if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.DESTROYED))
{
maxSuspensionDamage = DamageLevel.DESTROYED;
}
else if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.MAJOR))
{
maxSuspensionDamage = DamageLevel.MAJOR;
}
else if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.MINOR))
{
maxSuspensionDamage = DamageLevel.MINOR;
}
else if (currentGameState.CarDamageData.SuspensionDamageStatus.hasValueAtLevel(DamageLevel.TRIVIAL))
{
maxSuspensionDamage = DamageLevel.TRIVIAL;
}
isMissingWheel = !currentGameState.PitData.InPitlane && (!currentGameState.TyreData.LeftFrontAttached || !currentGameState.TyreData.RightFrontAttached ||
!currentGameState.TyreData.LeftRearAttached || !currentGameState.TyreData.RightRearAttached);
if (engineDamage < getLastReportedDamageLevel(Component.ENGINE))
{
resetReportedDamage(Component.ENGINE, engineDamage);
}
if (trannyDamage < getLastReportedDamageLevel(Component.TRANNY))
{
resetReportedDamage(Component.TRANNY, trannyDamage);
}
if (maxSuspensionDamage < getLastReportedDamageLevel(Component.SUSPENSION))
{
resetReportedDamage(Component.SUSPENSION, maxSuspensionDamage);
}
if (maxBrakeDamage < getLastReportedDamageLevel(Component.BRAKES))
{
resetReportedDamage(Component.BRAKES, maxBrakeDamage);
}
if (aeroDamage < getLastReportedDamageLevel(Component.AERO))
{
resetReportedDamage(Component.AERO, aeroDamage);
}
minDamageToReport = (DamageLevel)Math.Max((int)engineDamage, Math.Max((int)trannyDamage, Math.Max((int)maxSuspensionDamage, Math.Max((int)maxBrakeDamage, (int)aeroDamage))));
Tuple <Component, DamageLevel> worstUnreportedDamage = getWorstUnreportedDamage();
if (worstUnreportedDamage != null && worstUnreportedDamage.Item2 >= minDamageToReport)
{
if (damageToReportNext == null || worstUnreportedDamage.Item1 != damageToReportNext.Item1 || worstUnreportedDamage.Item2 != damageToReportNext.Item2)
{
timeWhenDamageLastChanged = currentGameState.Now;
damageToReportNext = worstUnreportedDamage;
}
else if (timeWhenDamageLastChanged.Add(timeToWaitForDamageToSettle) < currentGameState.Now)
{
Console.WriteLine("reporting ...");
Console.WriteLine(damageToReportNext.Item1 + ", " + damageToReportNext.Item2);
// put *all* the damage levels in the 'reported' set, even though we haven't actually reported them.
// This ensure we only ever play the worst damage on the car when damage has just increased
// Only do this if the component damage is *less* than the one we just reported
if (Component.AERO == damageToReportNext.Item1 || aeroDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.AERO, aeroDamage);
}
if (Component.BRAKES == damageToReportNext.Item1 || maxBrakeDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.BRAKES, maxBrakeDamage);
}
if (Component.ENGINE == damageToReportNext.Item1 || engineDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.ENGINE, engineDamage);
}
if (Component.SUSPENSION == damageToReportNext.Item1 || maxSuspensionDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.SUSPENSION, maxSuspensionDamage);
}
if (Component.TRANNY == damageToReportNext.Item1 || trannyDamage < damageToReportNext.Item2)
{
addReportedDamage(Component.TRANNY, trannyDamage);
}
if (enableDamageMessages)
{
playDamageToReport();
}
}
}
}
}
