public void UpdateTurn(GameSession game, int id)
{
if (game.GameDatabase.GetTurnCount() < game.AssetDatabase.RandomEncMinTurns && !this.ForceVonNeumannAttack && !this.ForceVonNeumannAttackCycle)
{
return;
}
VonNeumannInfo vonNeumannInfo = game.GameDatabase.GetVonNeumannInfo(id);
bool flag = vonNeumannInfo == null || this.HomeWorldSystemId <= 0;
List <FleetInfo> list = game.GameDatabase.GetFleetInfosByPlayerID(this.PlayerID, FleetType.FL_NORMAL).ToList <FleetInfo>();
if (flag || list.FirstOrDefault <FleetInfo>((Func <FleetInfo, bool>)(x => x.Name == "Von Neumann NeoBerserker")) == null)
{
foreach (FleetInfo fleetInfo in list)
{
game.GameDatabase.RemoveFleet(fleetInfo.ID);
}
game.GameDatabase.RemoveEncounter(id);
}
else
{
vonNeumannInfo.Resources += vonNeumannInfo.ResourcesCollectedLastTurn;
vonNeumannInfo.ResourcesCollectedLastTurn = 0;
if (vonNeumannInfo.ProjectDesignId.HasValue)
{
this.BuildProject(game, ref vonNeumannInfo);
}
this.ProcessTargets(game, ref vonNeumannInfo);
this.SendCollector(game, ref vonNeumannInfo, this.ForceVonNeumannAttack);
game.GameDatabase.UpdateVonNeumannInfo(vonNeumannInfo);
}
}
public static void HandleMomRetreated(GameSession game, int id, int ru)
{
VonNeumannInfo vonNeumannInfo = game.GameDatabase.GetVonNeumannInfo(id);
if (vonNeumannInfo == null)
{
return;
}
vonNeumannInfo.Resources += ru;
game.GameDatabase.UpdateVonNeumannInfo(vonNeumannInfo);
}
private void BuildProject(GameSession game, ref VonNeumannInfo vi)
{
int num = Math.Min(game.AssetDatabase.GlobalVonNeumannData.BuildRate, (int)((double)vi.Resources * (double)game.AssetDatabase.DefaultStratModifiers[StratModifiers.OverharvestModifier]));
DesignInfo designInfo = game.GameDatabase.GetDesignInfo(vi.ProjectDesignId.Value);
if (vi.ConstructionProgress + num > designInfo.ProductionCost || this.ForceVonNeumannAttackCycle)
{
vi.Resources -= (int)((double)(designInfo.ProductionCost - vi.ConstructionProgress) / (double)game.AssetDatabase.DefaultStratModifiers[StratModifiers.OverharvestModifier]);
string name = "";
int? projectDesignId1 = vi.ProjectDesignId;
int designId1 = VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.SeekerMothership].DesignId;
if ((projectDesignId1.GetValueOrDefault() != designId1 ? 0 : (projectDesignId1.HasValue ? 1 : 0)) != 0)
{
name = "Von Neumann Seeker";
}
else
{
int?projectDesignId2 = vi.ProjectDesignId;
int designId2 = VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.BerserkerMothership].DesignId;
if ((projectDesignId2.GetValueOrDefault() != designId2 ? 0 : (projectDesignId2.HasValue ? 1 : 0)) != 0)
{
name = "Von Neumann Berserker";
}
else
{
int?projectDesignId3 = vi.ProjectDesignId;
int designId3 = VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.PlanetKiller].DesignId;
if ((projectDesignId3.GetValueOrDefault() != designId3 ? 0 : (projectDesignId3.HasValue ? 1 : 0)) != 0)
{
name = "Von Neumann System Killer";
}
}
}
int fleetID = game.GameDatabase.InsertFleet(this.PlayerId, 0, vi.SystemId, vi.SystemId, name, FleetType.FL_NORMAL);
game.GameDatabase.InsertShip(fleetID, vi.ProjectDesignId.Value, null, (ShipParams)0, new int?(), 0);
vi.ConstructionProgress = 0;
vi.ProjectDesignId = new int?();
}
else
{
vi.Resources -= (int)((double)game.AssetDatabase.GlobalVonNeumannData.BuildRate / (double)game.AssetDatabase.DefaultStratModifiers[StratModifiers.OverharvestModifier]);
vi.ConstructionProgress += num;
}
}
public void HandleHomeSystemDefeated(App app, FleetInfo fi, List <int> attackingPlayers)
{
VonNeumannInfo vonNeumannInfo = app.Game.GameDatabase.GetVonNeumannInfos().FirstOrDefault <VonNeumannInfo>((Func <VonNeumannInfo, bool>)(x =>
{
int?fleetId = x.FleetId;
int id = fi.ID;
if (fleetId.GetValueOrDefault() == id)
{
return(fleetId.HasValue);
}
return(false);
}));
if (vonNeumannInfo == null)
{
return;
}
foreach (int attackingPlayer in attackingPlayers)
{
float stratModifier = app.GameDatabase.GetStratModifier <float>(StratModifiers.ResearchModifier, attackingPlayer);
app.GameDatabase.SetStratModifier(StratModifiers.ResearchModifier, attackingPlayer, (object)(float)((double)stratModifier + 0.0500000007450581));
app.GameDatabase.InsertTurnEvent(new TurnEvent()
{
EventType = TurnEventType.EV_VN_HW_DEFEATED,
EventMessage = TurnEventMessage.EM_VN_HW_DEFEATED,
PlayerID = attackingPlayer,
TurnNumber = app.GameDatabase.GetTurnCount(),
ShowsDialog = true
});
}
foreach (FleetInfo fleetInfo in app.GameDatabase.GetFleetInfosByPlayerID(this.PlayerId, FleetType.FL_NORMAL).ToList <FleetInfo>())
{
app.GameDatabase.RemoveFleet(fleetInfo.ID);
}
app.GameDatabase.RemoveEncounter(vonNeumannInfo.Id);
}
public void SendCollector(GameSession game, ref VonNeumannInfo vi, bool forceHomeworldAttack = false)
{
List <FleetInfo> list = game.GameDatabase.GetFleetInfosByPlayerID(this.PlayerId, FleetType.FL_NORMAL).ToList <FleetInfo>();
VonNeumannGlobalData globalVonNeumannData = game.AssetDatabase.GlobalVonNeumannData;
FleetInfo fleetInfo = VonNeumann.GetCollectorFleetInfo(list);
if (fleetInfo == null)
{
DesignInfo designInfo = game.GameDatabase.GetDesignInfo(VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.CollectorMothership].DesignId);
if ((double)vi.Resources > (double)designInfo.ProductionCost / (double)game.AssetDatabase.DefaultStratModifiers[StratModifiers.OverharvestModifier])
{
vi.Resources -= (int)((double)designInfo.ProductionCost / (double)game.AssetDatabase.DefaultStratModifiers[StratModifiers.OverharvestModifier]);
vi.FleetId = new int?(game.GameDatabase.InsertFleet(this.PlayerId, 0, vi.SystemId, vi.SystemId, "Von Neumann Collector", FleetType.FL_NORMAL));
game.GameDatabase.InsertShip(vi.FleetId.Value, VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.CollectorMothership].DesignId, null, (ShipParams)0, new int?(), 0);
fleetInfo = game.GameDatabase.GetFleetInfo(vi.FleetId.Value);
}
else
{
vi.Resources = 0;
vi.FleetId = new int?(game.GameDatabase.InsertFleet(this.PlayerId, 0, vi.SystemId, vi.SystemId, "Von Neumann Collector", FleetType.FL_NORMAL));
game.GameDatabase.InsertShip(vi.FleetId.Value, VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.CollectorMothership].DesignId, null, (ShipParams)0, new int?(), 0);
fleetInfo = game.GameDatabase.GetFleetInfo(vi.FleetId.Value);
}
int sysId = vi.LastCollectionSystem;
if (!vi.TargetInfos.Any <VonNeumannTargetInfo>((Func <VonNeumannTargetInfo, bool>)(x => x.SystemId == sysId)) && sysId != 0)
{
vi.TargetInfos.Add(new VonNeumannTargetInfo()
{
SystemId = sysId,
ThreatLevel = 1
});
}
}
else if (vi.LastCollectionSystem != 0)
{
foreach (int num1 in game.GameDatabase.GetStarSystemOrbitalObjectIDs(fleetInfo.SystemID).ToList <int>())
{
PlanetInfo planetInfo = game.GameDatabase.GetPlanetInfo(num1);
LargeAsteroidInfo largeAsteroidInfo = game.GameDatabase.GetLargeAsteroidInfo(num1);
int num2 = globalVonNeumannData.SalvageCapacity - vi.ResourcesCollectedLastTurn;
if (planetInfo != null)
{
if (planetInfo.Resources > num2)
{
planetInfo.Resources -= num2;
vi.ResourcesCollectedLastTurn = globalVonNeumannData.SalvageCapacity;
break;
}
vi.ResourcesCollectedLastTurn += planetInfo.Resources;
planetInfo.Resources = 0;
game.GameDatabase.UpdatePlanet(planetInfo);
}
else if (largeAsteroidInfo != null)
{
if (largeAsteroidInfo.Resources > num2)
{
largeAsteroidInfo.Resources -= num2;
vi.ResourcesCollectedLastTurn = globalVonNeumannData.SalvageCapacity;
break;
}
vi.ResourcesCollectedLastTurn += largeAsteroidInfo.Resources;
largeAsteroidInfo.Resources = 0;
game.GameDatabase.UpdateLargeAsteroidInfo(largeAsteroidInfo);
}
}
vi.Resources += vi.ResourcesCollectedLastTurn;
fleetInfo.SystemID = vi.SystemId;
game.GameDatabase.UpdateFleetLocation(fleetInfo.ID, fleetInfo.SystemID, new int?());
}
vi.LastCollectionSystem = 0;
int turnCount = game.GameDatabase.GetTurnCount();
if (fleetInfo == null || turnCount <= vi.LastCollectionTurn + globalVonNeumannData.SalvageCycle && !forceHomeworldAttack && !this.ForceVonNeumannAttackCycle)
{
return;
}
vi.LastCollectionTurn = turnCount;
List <int> intList = new List <int>();
foreach (int num in game.GameDatabase.GetStarSystemIDs().ToList <int>())
{
int system = num;
if (!vi.TargetInfos.Any <VonNeumannTargetInfo>((Func <VonNeumannTargetInfo, bool>)(x => x.SystemId == system)))
{
int?systemOwningPlayer = game.GameDatabase.GetSystemOwningPlayer(system);
if (systemOwningPlayer.HasValue)
{
Player playerObject = game.GetPlayerObject(systemOwningPlayer.Value);
if (playerObject == null || playerObject.IsAI())
{
continue;
}
}
intList.Add(system);
}
}
if (intList.Count <= 0)
{
return;
}
fleetInfo.SystemID = forceHomeworldAttack || this.ForceVonNeumannAttackCycle ? game.GameDatabase.GetOrbitalObjectInfo(game.GameDatabase.GetPlayerInfo(game.LocalPlayer.ID).Homeworld.Value).StarSystemID : intList[App.GetSafeRandom().Next(intList.Count)];
vi.FleetId = new int?(fleetInfo.ID);
vi.LastCollectionSystem = fleetInfo.SystemID;
game.GameDatabase.UpdateFleetLocation(fleetInfo.ID, fleetInfo.SystemID, new int?());
}
private void ProcessTargets(GameSession game, ref VonNeumannInfo vi)
{
List <FleetInfo> list = game.GameDatabase.GetFleetInfosByPlayerID(this.PlayerId, FleetType.FL_NORMAL).ToList <FleetInfo>();
FleetInfo seekerFleetInfo = VonNeumann.GetSeekerFleetInfo(list);
FleetInfo berserkerFleetInfo = VonNeumann.GetBerserkerFleetInfo(list);
FleetInfo systemKillerFleetInfo = VonNeumann.GetSystemKillerFleetInfo(list);
int lastTargetSystem = vi.LastTargetSystem;
VonNeumannTargetInfo neumannTargetInfo1 = vi.TargetInfos.FirstOrDefault <VonNeumannTargetInfo>((Func <VonNeumannTargetInfo, bool>)(x => x.SystemId == lastTargetSystem));
if (neumannTargetInfo1 != null)
{
FleetInfo fleetInfo = (FleetInfo)null;
switch (neumannTargetInfo1.ThreatLevel)
{
case 1:
fleetInfo = seekerFleetInfo;
break;
case 2:
fleetInfo = berserkerFleetInfo;
break;
case 3:
fleetInfo = systemKillerFleetInfo;
break;
}
if (fleetInfo == null)
{
if (neumannTargetInfo1.ThreatLevel < 3)
{
++neumannTargetInfo1.ThreatLevel;
}
}
else
{
vi.TargetInfos.Remove(neumannTargetInfo1);
game.GameDatabase.RemoveVonNeumannTargetInfo(vi.Id, neumannTargetInfo1.SystemId);
fleetInfo.SystemID = vi.SystemId;
game.GameDatabase.UpdateFleetLocation(fleetInfo.ID, fleetInfo.SystemID, new int?());
vi.FleetId = new int?(fleetInfo.ID);
}
}
vi.LastTargetSystem = 0;
int turnCount = game.GameDatabase.GetTurnCount();
if (turnCount <= vi.LastTargetTurn + game.AssetDatabase.GlobalVonNeumannData.TargetCycle && !this.ForceVonNeumannAttackCycle)
{
return;
}
vi.LastTargetTurn = turnCount;
VonNeumannTargetInfo neumannTargetInfo2 = vi.TargetInfos.FirstOrDefault <VonNeumannTargetInfo>();
if (neumannTargetInfo2 == null)
{
return;
}
switch (neumannTargetInfo2.ThreatLevel)
{
case 1:
if (seekerFleetInfo != null)
{
seekerFleetInfo.SystemID = neumannTargetInfo2.SystemId;
vi.LastTargetSystem = neumannTargetInfo2.SystemId;
game.GameDatabase.UpdateFleetLocation(seekerFleetInfo.ID, seekerFleetInfo.SystemID, new int?());
vi.FleetId = new int?(seekerFleetInfo.ID);
break;
}
if (vi.ProjectDesignId.HasValue)
{
break;
}
vi.ProjectDesignId = new int?(VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.SeekerMothership].DesignId);
break;
case 2:
if (berserkerFleetInfo != null)
{
berserkerFleetInfo.SystemID = neumannTargetInfo2.SystemId;
vi.LastTargetSystem = neumannTargetInfo2.SystemId;
game.GameDatabase.UpdateFleetLocation(berserkerFleetInfo.ID, berserkerFleetInfo.SystemID, new int?());
vi.FleetId = new int?(berserkerFleetInfo.ID);
break;
}
if (vi.ProjectDesignId.HasValue)
{
break;
}
vi.ProjectDesignId = new int?(VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.BerserkerMothership].DesignId);
break;
case 3:
if (systemKillerFleetInfo != null)
{
systemKillerFleetInfo.SystemID = neumannTargetInfo2.SystemId;
vi.LastTargetSystem = neumannTargetInfo2.SystemId;
game.GameDatabase.UpdateFleetLocation(systemKillerFleetInfo.ID, systemKillerFleetInfo.SystemID, new int?());
vi.FleetId = new int?(systemKillerFleetInfo.ID);
break;
}
if (vi.ProjectDesignId.HasValue)
{
break;
}
vi.ProjectDesignId = new int?(VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.PlanetKiller].DesignId);
break;
}
}
public void AddInstance(GameDatabase gamedb, AssetDatabase assetdb, NamesPool namesPool)
{
if (this.NumInstances >= VonNeumann.MaxVonNeumanns)
{
return;
}
int val1 = this._outlyingStars.Count <KeyValuePair <StarSystemInfo, Vector3> >();
if (val1 == 0)
{
return;
}
Random safeRandom = App.GetSafeRandom();
int val2 = 5;
float num1 = 5f;
KeyValuePair <StarSystemInfo, Vector3> outlyingStar = this._outlyingStars[safeRandom.Next(Math.Min(val1, val2))];
this._outlyingStars.Remove(outlyingStar);
Vector3 origin = outlyingStar.Key.Origin + Vector3.Normalize(outlyingStar.Value) * num1;
App.Log.Trace(string.Format("Found von neumann homeworld target - Picked System = {0} Target Coords = {1}", (object)outlyingStar.Key.Name, (object)origin), "game");
StellarClass stellarClass = StarHelper.ChooseStellarClass(safeRandom);
this.HomeWorldSystemId = gamedb.InsertStarSystem(new int?(), namesPool.GetSystemName(), new int?(), stellarClass.ToString(), origin, false, true, new int?());
gamedb.GetStarSystemInfo(this.HomeWorldSystemId);
int num2 = 5;
float starOrbitStep = StarSystemVars.Instance.StarOrbitStep;
float num3 = StarHelper.CalcRadius(stellarClass.Size) + (float)num2 * ((float)num2 * 0.1f * starOrbitStep);
float x = Ellipse.CalcSemiMinorAxis(num3, 0.0f);
OrbitalPath path = new OrbitalPath();
path.Scale = new Vector2(x, num3);
path.InitialAngle = 0.0f;
this.HomeWorldPlanetId = gamedb.InsertPlanet(new int?(), this.HomeWorldSystemId, path, "VonNeumonia", "normal", new int?(), 0.0f, 0, 0, 5f);
PlanetInfo planetInfo = gamedb.GetPlanetInfo(this.HomeWorldPlanetId);
path = new OrbitalPath();
path.Scale = new Vector2(15f, 15f);
path.Rotation = new Vector3(0.0f, 0.0f, 0.0f);
path.DeltaAngle = 10f;
path.InitialAngle = 10f;
VonNeumannInfo vi = new VonNeumannInfo()
{
SystemId = this.HomeWorldSystemId,
OrbitalId = this.HomeWorldPlanetId,
Resources = assetdb.GlobalVonNeumannData.StartingResources,
ConstructionProgress = 0
};
float radius = StarSystemVars.Instance.SizeToRadius(planetInfo.Size);
vi.FleetId = new int?(gamedb.InsertFleet(this.PlayerId, 0, vi.SystemId, vi.SystemId, "Von Neumann NeoBerserker", FleetType.FL_NORMAL));
float num4 = radius + 2000f;
float num5 = 1000f;
Matrix matrix1 = gamedb.GetOrbitalTransform(this.HomeWorldPlanetId);
matrix1 = Matrix.CreateWorld(matrix1.Position, Vector3.Normalize(matrix1.Position), Vector3.UnitY);
Matrix matrix2 = matrix1;
matrix2.Position = matrix2.Position + matrix2.Forward * num4 - matrix2.Right * num5;
for (int index = 0; index < 3; ++index)
{
int shipID = gamedb.InsertShip(vi.FleetId.Value, VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.NeoBerserker].DesignId, null, (ShipParams)0, new int?(), 0);
gamedb.UpdateShipSystemPosition(shipID, new Matrix?(matrix2));
matrix2.Position += matrix2.Right * num5;
}
Random random = new Random();
float radians1 = (float)((random.CoinToss(0.5) ? -1.0 : 1.0) * 0.785398185253143);
float radians2 = random.NextInclusive(0.0f, 6.283185f);
Matrix rotationY1 = Matrix.CreateRotationY(radians1);
Matrix rotationY2 = Matrix.CreateRotationY(radians2);
Matrix world = Matrix.CreateWorld(rotationY1.Forward * (matrix1.Position.Length * 0.75f), rotationY2.Forward, Vector3.UnitY);
VonNeumann.VonNeumannShipDesigns index1 = (VonNeumann.VonNeumannShipDesigns)random.NextInclusive(21, 23);
int shipID1 = gamedb.InsertShip(vi.FleetId.Value, VonNeumann.StaticShipDesigns[index1].DesignId, null, (ShipParams)0, new int?(), 0);
gamedb.UpdateShipSystemPosition(shipID1, new Matrix?(world));
world.Position -= world.Right * 1000f;
int shipID2 = gamedb.InsertShip(vi.FleetId.Value, VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.Moon].DesignId, null, (ShipParams)0, new int?(), 0);
gamedb.UpdateShipSystemPosition(shipID2, new Matrix?(world));
world = Matrix.CreateWorld(world.Position + world.Right * 1000f * 2f, -world.Forward, Vector3.UnitY);
int shipID3 = gamedb.InsertShip(vi.FleetId.Value, VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.Moon].DesignId, null, (ShipParams)0, new int?(), 0);
gamedb.UpdateShipSystemPosition(shipID3, new Matrix?(world));
gamedb.InsertVonNeumannInfo(vi);
++this.NumInstances;
}
public override void Initialize()
{
this.m_LoadingMom = (Ship)null;
this.m_LoadingChilds = new List <Ship>();
this.m_SpawnedChilds = new List <VonNeumannChildControl>();
this.m_SpawnedMoms = new List <VonNeumannMomControl>();
this.m_SpawnLocations = new List <VonNeumannChildSpawnLocations>();
this.m_SpawnedDefensePlatforms = new List <Ship>();
this.m_SpawnedEnemies = new List <Ship>();
this.m_State = VonNeumannMomStates.COLLECT;
this.m_Orders = VonNeumannOrders.COLLECT;
this.m_NumChildrenToMaintain = 10;
this.m_Vanished = false;
this.m_TryFindParent = true;
this.m_VonNeumannID = 0;
VonNeumannInfo vonNeumannInfo = this.m_Game.GameDatabase.GetVonNeumannInfos().ToList <VonNeumannInfo>().FirstOrDefault <VonNeumannInfo>((Func <VonNeumannInfo, bool>)(x =>
{
int?fleetId1 = x.FleetId;
int fleetId2 = this.m_FleetID;
if (fleetId1.GetValueOrDefault() == fleetId2)
{
return(fleetId1.HasValue);
}
return(false);
}));
if (vonNeumannInfo != null)
{
this.m_VonNeumannID = vonNeumannInfo.Id;
}
Matrix rotationYpr = Matrix.CreateRotationYPR(this.m_VonNeumannMom.Maneuvering.Rotation);
rotationYpr.Position = this.m_VonNeumannMom.Maneuvering.Position + rotationYpr.Forward * 500f;
Vector3 right = rotationYpr.Right;
int designId = VonNeumann.StaticShipDesigns[VonNeumann.VonNeumannShipDesigns.CollectorProbe].DesignId;
int childrenToMaintain1 = this.m_NumChildrenToMaintain;
float radians = MathHelper.DegreesToRadians(360f / (float)childrenToMaintain1);
float num1 = radians * 0.5f;
float num2 = 1f;
for (int index = 0; index < childrenToMaintain1; ++index)
{
float num3 = radians * (float)((index % childrenToMaintain1 + 1) / 2) * num2 + num1;
this.m_SpawnLocations.Add(new VonNeumannChildSpawnLocations(this.m_VonNeumannMom, new Vector3((float)Math.Sin((double)num3), 0.0f, -(float)Math.Cos((double)num3)), 300f));
num2 *= -1f;
}
int childrenToMaintain2 = this.m_Game.AssetDatabase.GlobalVonNeumannData.MinChildrenToMaintain;
for (int index = 0; index < childrenToMaintain2; ++index)
{
VonNeumannChildSpawnLocations childSpawnLocations = this.m_SpawnLocations.FirstOrDefault <VonNeumannChildSpawnLocations>((Func <VonNeumannChildSpawnLocations, bool>)(x => x.CanSpawnAtLocation()));
if (childSpawnLocations != null)
{
Matrix worldMat = rotationYpr;
worldMat.Position = childSpawnLocations.GetSpawnLocation();
Ship newShip = CombatAIController.CreateNewShip(this.m_Game.Game, worldMat, designId, 0, this.m_VonNeumannMom.InputID, this.m_VonNeumannMom.Player.ObjectID);
if (newShip != null)
{
this.m_LoadingChilds.Add(newShip);
childSpawnLocations.SpawnAtLocation(newShip);
}
}
}
if (this.m_LoadingChilds.Count <= 0)
{
return;
}
this.m_State = VonNeumannMomStates.INTEGRATECHILD;
}
