public void UpdateSlowEffects(float deltaTime)
{
SpeedModifier toRemove = null;
if (speedModifiers != null)
{
foreach (SpeedModifier sm in speedModifiers)
{
sm.DecrementTimer(deltaTime);
if (sm.HasFinished())
{
toRemove = sm;
}
}
}
if (toRemove != null)
{
speedModifiers.Remove(toRemove);
}
float rawSpeed = originalSpeed;
foreach (SpeedModifier sm in speedModifiers)
{
rawSpeed *= sm.slowValue;
}
agent.speed = rawSpeed;
}
public static ItemModifierEffect getRandomModifierOfLevel(int level)
{
int rand = Random.Range(0, 100);
ItemModifierEffect modifier;
if (rand < 20)
{
modifier = new ArmourModifier(level);
}
else if (rand < 40)
{
modifier = new SpeedModifier(level);
}
else if (rand < 60)
{
modifier = new FlatDamageModifier(level);
}
else if (rand < 80)
{
modifier = new RelDamageModifier(level);
}
else
{
modifier = new LifeModifier(level);
}
return(modifier);
}
public override int GetHashCode()
{
unchecked
{
return((SpeedModifier.GetHashCode() * 397) ^ LeaveLightsOn.GetHashCode());
}
}
public void RemoveSpeedModifier(int ticket)
{
SpeedModifier rsm = FindSpeedModifier(ticket);
if (rsm != null && speedModifiers.Contains(rsm))
{
speedModifiers.Remove(rsm);
}
}
// Use this for initialization
void Start()
{
InProgress = false;
// Reduce speed by half when reload is InProgress
SpeedModifier modifier = s => InProgress ? 0.5f * s : s;
var sm = (PlayerMovable)SpeedManager;
sm.SpeedModifiers.Add(modifier);
}
public override YAMLNode ExportYAML(IAssetsExporter exporter)
{
YAMLMappingNode node = (YAMLMappingNode)base.ExportYAML(exporter);
node.Add("x", X.ExportYAML(exporter));
node.Add("y", Y.ExportYAML(exporter));
node.Add("z", Z.ExportYAML(exporter));
node.Add("speedModifier", SpeedModifier.ExportYAML(exporter));
node.Add("inWorldSpace", InWorldSpace);
return(node);
}
public int AddSpeedModifier(float value, int ticket)
{
if (value < 0)
{
value = 0f;
}
SpeedModifier nsm = new SpeedModifier();
nsm.value = value;
nsm.ticket = ticket;
speedModifiers.Add(nsm);
return(nsm.ticket);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
X.Read(stream);
Y.Read(stream);
Z.Read(stream);
if (IsReadSpeedModifier(stream.Version))
{
SpeedModifier.Read(stream);
}
InWorldSpace = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
public Modification GetModification(ModType type)
{
// Define return value
// -------------------
Modification mod;
switch (type)
{
case ModType.HommingMotion:
mod = new HommingMotionModifier();
(mod as HommingMotionModifier).SetDriftAngle(180);
break;
case ModType.Piercing:
mod = new PiercingModifier();
break;
case ModType.Speed:
mod = new SpeedModifier();
break;
case ModType.Gatling:
mod = new GatlingModifier();
break;
case ModType.ZickZack:
mod = new ZickZackMotionModifier();
(mod as ZickZackMotionModifier).SetJitterStrength(10);
break;
case ModType.Shield:
mod = new ShieldModifier();
break;
case ModType.ChainHit:
mod = new ChainHitModifier();
break;
default:
Debug.LogError("No modifier for " + type + " found!");
return(null);
}
// Return mod
// ----------
return(mod);
}
void ICrowdControl.SetSlowed(string tag, float slowValue, float timeRemainging)
{
bool found = false;
foreach (SpeedModifier sm in speedModifiers)
{
if (sm.SameTag(tag))
{
sm.UpdateTimeRemainging(timeRemainging);
found = true;
}
}
if (!found)
{
SpeedModifier sm = new SpeedModifier(tag, slowValue, timeRemainging);
speedModifiers.Add(sm);
}
}
public void UpdateSlowEffects(float deltaTime)
{
SpeedModifier toRemove = null;
if (speedModifiers != null)
{
foreach (SpeedModifier sm in speedModifiers)
{
sm.DecrementTimer(deltaTime);
if (sm.HasFinished())
{
toRemove = sm;
}
}
}
if (toRemove != null)
{
speedModifiers.Remove(toRemove);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
X.Read(reader);
Y.Read(reader);
Z.Read(reader);
if (IsReadOrbital(reader.Version))
{
OrbitalX.Read(reader);
OrbitalY.Read(reader);
OrbitalZ.Read(reader);
OrbitalOffsetX.Read(reader);
OrbitalOffsetY.Read(reader);
OrbitalOffsetZ.Read(reader);
Radial.Read(reader);
}
if (IsReadSpeedModifier(reader.Version))
{
SpeedModifier.Read(reader);
}
InWorldSpace = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
public void addSpeedModifier(SpeedModifier mod)
{
speedModifiers.Add(mod);
AddSpeedValue(mod.value);
Debug.Log("Adding speed modifier. size: " + +climbingSpeed);
}
public override void TakeEffect(Entity actor)
{
speedModifier = new SpeedModifier(actor.GetCapability <Speed>().Value * 0.5f);
speedModifier.TakeEffect(actor);
Delay((int)(InternalTime * 1000), actor);
}
public SlowDown(float value)
{
Value = value;
modifier = new SpeedModifier(-value);
}
public SpeedUp(float value)
{
Value = value;
modifier = new SpeedModifier(value);
}
public SpeedDownSpell()
{
_modifier = new SpeedModifier(0.5f);
}
SpeedModifier(SpeedModifier template, int id, float timeout)
{
ID = id;
_type = template._type;
_value = template._value;
Timeout = timeout;
ApplicationTime = Time.time;
}
public static void ReleaseModifierID(SpeedModifier mod)
{
UsedIDs.Remove(mod.ID);
}
protected bool Equals(PlaybackSettings other)
{
return(SpeedModifier.Equals(other.SpeedModifier) && LeaveLightsOn == other.LeaveLightsOn);
}
