public MemoryManager(NestManager nestMan) { _nestMan = nestMan; // Start the watching thread. StartMemoryWatch(); }
//lets this ant know that it has been put down, sets it upright and turns senses back on public void Dropped(NestManager nest) { //turn the right way up transform.rotation = Quaternion.identity; transform.position = new Vector3(transform.position.x, GetComponent <CapsuleCollider>().radius * 2, transform.position.z); move.isBeingCarried = false; if (transform.parent.tag == Naming.Ants.CarryPosition) { int id = simulation.GetNestID(nest); transform.parent = GameObject.Find("P" + id).transform; } //make ant inactive in this nest // oldNest = nest; //? This is commented out in Gregs version myNest = nest; droppedRecently = (int)Times.v[Times.DroppedWait]; //? commented out in both versions? nextAssessment = simulation.TotalElapsedSimulatedTime("s") + RandomGenerator.Instance.Range(0.5f, 1f) * Times.v[Times.MaxAssessmentWait]; ChangeState(BehaviourState.Inactive); //turns senses on if non passive ant if (passive == false) { sensesCol.enabled = true; } }
private void CleanUp() { if (_cleanedUp) { return; } int[] nestAllegiance = new int[Simulation.NestInfo.Count]; foreach (AntManager ant in Simulation.Ants) { NestManager nest = ant.myNest; // If the ant is being carried, it is assigned to the carrier's nest if (ant.transform.parent.tag == "CarryPosition") { nest = ant.transform.parent.parent.GetComponent <AntManager>().myNest; } nestAllegiance[Simulation.GetNestID(nest)]++; } string nestNumbersOutput = ""; foreach (int nestNumbers in nestAllegiance) { nestNumbersOutput += "," + nestNumbers; } Dictionary <string, float> runOutput = CalculateTandemValues(); WriteLine(nestNumbersOutput.Substring(1)); WriteLine("Absolute Emigration Accuracy: " + Simulation.emigrationData.emigrationAbsoluteAccuracy); WriteLine("Relative Emigration Accuracy: " + Simulation.emigrationData.emigrationRelativeAccuracy); WriteLine("Emigration Completion: " + Simulation.emigrationData.emigrationAbsoluteAccuracy); WriteLine("FTRs Completed: " + (int)runOutput["forward success"]); WriteLine("FTRs Failed: " + (int)runOutput["forward failed"]); WriteLine("FTR Mean Duration: " + runOutput["forward mean duration"]); WriteLine("FTR Mean Distance: " + runOutput["forward mean distance"]); WriteLine("FTR Mean Speed: " + runOutput["forward mean speed"]); WriteLine("FTR Failure Rate/min: " + runOutput["forward failures/min"]); WriteLine("RTRs Completed: " + (int)runOutput["reverse success"]); WriteLine("RTRs Failed: " + (int)runOutput["reverse failed"]); WriteLine("RTR Mean Duration: " + runOutput["reverse mean duration"]); WriteLine("RTR Mean Distance: " + runOutput["reverse mean distance"]); WriteLine("RTR Mean Speed: " + runOutput["reverse mean speed"]); WriteLine("RTR Failure Rate/min: " + runOutput["reverse failures/min"]); WriteLine("Discovery Time: " + Simulation.emigrationData.discoveryTime); WriteLine("First Recruiter Time: " + Simulation.emigrationData.firstRecruiter); WriteLine("First Tandem Time: " + Simulation.emigrationData.firstTandem); WriteLine("First Carry Time: " + Simulation.emigrationData.firstCarry); WriteLine("First Reverse Time: " + Simulation.emigrationData.firstReverse); WriteLine("End of Emigration Time: " + Simulation.emigrationData.endOfEmigration); _cleanedUp = true; }
public NestInfo(NestManager nest, int nestId, bool isStartingNest, GameObject assessing, GameObject recruiting, GameObject inactive, GameObject reversing) { Nest = nest; NestId = nestId; IsStartingNest = isStartingNest; AntsAssessing = assessing; AntsRecruiting = recruiting; AntsPassive = inactive; AntsReversing = reversing; }
private void CheckQuorum(NestManager nest) { //check the quorum of this nest until quorum is met once. if (IsQuorumReached()) { perceivedQuorum = quorumThreshold; } else { perceivedQuorum = RandomGenerator.Instance.NormalRandom(nest.GetQuorum(), Other.v[Other.QuorumAssessNoise]); } }
public UiSettingManager(NestManager nestMan) { _nestMan = nestMan; // If we aren't a background +1 app opened. if(!nestMan.IsBackgroundTask) { AppOpenedCount++; } nestMan.OnResuming += BaconMan_OnResuming; }
// //switches ants allegiance to this nest and sends them back to their old one to recruit some more private void RecruitToNest(NestManager nest) { recruitmentStage = RecruitmentStage.GoingToOldNest; myNest = nest; CheckQuorum(nest); waitOldNestTime = (int)Times.v[Times.RecruitTryTime]; leader = null; //? BUGFIX == random case where an assessor -> recruiter but still had leader set to something, so caused a null exception ChangeState(BehaviourState.Recruiting); }
private void RecruitingMovement() { // If recruiter needs to wait for the follower, ant should not move (next turn time is increased so the tandem leader doesn't turn immediately after regaining contact) if (ant.IsTandemRunning() && ShouldTandemLeaderWait() == true) { nextTurnTime += Time.fixedDeltaTime; return; } // Update direction only if the required time has elapsed if (simulation.TotalElapsedSimulatedTime("s") >= nextTurnTime) { // Recruiters leading a tandem run or transporting (social carry) will need to return to their new nest. if (ant.IsTandemRunning() || ant.IsTransporting()) { WalkToNest(ant.myNest); UpdateTandemDistance(); } // Recruiters not tandem running or carrying move back and forth between the new and old nests. else { // The target nest is either the old or new nest, depending on the current recruiter direction NestManager targetNest = (ant.recruitmentStage == RecruitmentStage.GoingToOldNest) ? ant.oldNest : ant.myNest; // If the recruiter has reached the target nest, then walk randomly inside while waiting/searching for recruits if (ant.currentNest == targetNest) { RandomWalk(maxVarBase); } else // Else walk towards the target nest { WalkToNest(targetNest); } } ResetTurnParameters(false); } // Move forward at the speed based on the ant's current behaviour/activity if (ant.IsTandemRunning()) { MoveForward(Speed.v[Speed.TandemRunLead], true); } else if (ant.IsTransporting()) { MoveForward(Speed.v[Speed.Carrying], true); } else // If waiting or moving between nests then move at standard speed { MoveForward(Speed.v[Speed.Scouting], true); } }
//called whenever an ant leaves a nest public void LeftNest() { currentNest = null; inNest = false; //when an assessor leaves the nest then make decision about wether to recruit TO that nest if (state == BehaviourState.Assessing && assessTime == 0) { if (assessmentStage == 0) { NestAssessmentVisit(); } } }
protected void Start() { nestManager = GameObject.FindObjectOfType <NestManager>(); if (CurrentOrder == null) { NestInstance potentialNest = nestManager.RandomNest(); if (potentialNest != null) { CurrentInstruction = new Goto(potentialNest.nestPosition + Vector3.forward, 0, this); Instructions.Push(new CreateNest(nestPrefab, potentialNest, protectionTimer, this)); } } }
private void ConstructNest() { if (nestConstructionTimer <= 0) { nestConstructionTimer = nestConstructionTime; NestManager.SpawnNest(buildingSiteLocation, nest.Player); Map.Refresh(); MoveToPosition(nest.Position); state = "nest"; } else { nestConstructionTimer -= Time.deltaTime; } }
private void AssignParentFromNest(NestManager nest, string prefix, Color?colour) { if (nest != null) { prefix += simulation.GetNestID(nest); } if (transform.parent.name != prefix) { transform.parent = GameObject.Find(prefix).transform; } if (colour.HasValue) { SetPrimaryColour(colour.Value); } }
// Based on the ant's current location, return the next waypoint to walk to in order to reach the desired nest. // Order of waypoints starting from a different nest is as follows: // current nest door -> desired nest door -> desired nest centre private void WalkToNest(NestManager desiredNestManager) { GameObject desiredNest = desiredNestManager.gameObject; GameObject desiredNestDoor = desiredNestManager.door; if (ant.currentNest != null) { GameObject currentNest = ant.currentNest.gameObject; GameObject currentNestDoor = ant.currentNest.GetComponent <NestManager>().door; // If the ant is in the wrong nest, it must walk towards the nest door and exit the nest if (currentNest != desiredNest) { if (currentNest != desiredNest) //? need to check this equality works properly { // If the ant is not close to the door they must walk towards it (prevents getting stuck on walls) if (DoorSearch(Length.v[Length.DoorSenseRange]) == null) { WalkToGameObject(currentNestDoor, false); } // else the ant is close to the door, so they can walk directly out towards their desired nest else { WalkToGameObject(desiredNestDoor, true); } } } // Else the ant is already in the desired nest, so move towards the nest centre else { WalkToGameObject(desiredNest, true); } } // If the ant is not in a nest, walk towards the desired nest. else { //If the ant is close to the desired nest door, walk directly into the nest. if (DoorSearch(Length.v[Length.DoorSenseRange]) == desiredNestDoor) { WalkToGameObject(desiredNest, false); } // Otherwise move towards the desired nest door. else { WalkToGameObject(desiredNestDoor, true); } } }
public bool DEBUG_ANT = false; // Used for debugging // Use this for initialization void Start() { oldNest = GameObject.Find(Naming.World.InitialNest).NestManager(); carryPosition = transform.Find(Naming.Ants.CarryPosition); sensesCol = transform.Find(Naming.Ants.SensesArea).GetComponent <Collider>(); move = gameObject.AntMovement(); nestThreshold = RandomGenerator.Instance.NormalRandom(Other.v[Other.QualityThreshMean], Other.v[Other.QualityThreshNoise]); perceivedQuality = float.MinValue; finishedRecruiting = false; //make sure the value is within contraints if (nestThreshold > 1) { nestThreshold = 1; } else if (nestThreshold < 0) { nestThreshold = 0; } }
//returns the ID of the nest that is passed in public int GetNestID(NestManager nest) { return(nests.IndexOf(nest.transform)); }
public NestExtender(IPlayer player, NestManager nest) { this.m_player = player; this.m_nest = nest; }
private void Reverse(NestManager nest) { ChangeState(BehaviourState.Reversing); reverseTime = (int)Times.v[Times.ReverseTryTime]; }
public MessageManager(NestManager nestMan) { _nestMan = nestMan; }
public CacheManager(NestManager nestMan) { _nestMan = nestMan; }
// Checks if the current nest is of type nestType in the current stack! // Only BeginNests that have been decompiled will be tested for! private NestManager.Nest IsInNest( NestManager.Nest.NestType nestType ) { int i = _NestChain.Count - 1; if( i == -1 ) return null; if( _NestChain[i].Type == nestType ) { return _NestChain[i]; } return null; }
private NestManager.Nest GetMostRecentEndNest( NestManager.Nest.NestType nestType ) { for( int i = _Nester.Nests.Count - 1; i >= 0; -- i ) { if( _Nester.Nests[i] is NestManager.NestEnd && _Nester.Nests[i].Type == nestType ) { return _Nester.Nests[i]; } } return null; }
public AuthManager(NestManager nestMan) { _nestMan = nestMan; }
public UserManager(NestManager nestMan) { _nestMan = nestMan; _mAuthMan = new AuthManager(_nestMan); }
/// <summary> /// Called once the plugin is enabled. /// Meaning the start methods will be /// called when needed. /// </summary> public void OnEnabled() { // Create a new nest each time // the plugin is enabled. Nest = new NestManager(); }
public TileManager(NestManager nestMan) { _nestMan = nestMan; }
public void InitDecompile() { _NestChain.Clear(); _Nester = new NestManager{Decompiler = this}; CurrentTokenIndex = -1; CodePosition = 0; FieldToken.LastField = null; // TODO: Corrigate detection and version. DefaultParameterToken._NextParamIndex = 0; if( Package.Version > 300 ) { var func = _Container as UFunction; if( func != null && func.Params != null ) { DefaultParameterToken._NextParamIndex = func.Params.FindIndex( p => p.HasPropertyFlag( Flags.PropertyFlagsLO.OptionalParm ) ); } } // Reset these, in case of a loop in the Decompile function that did not finish due exception errors! _IsWithinClassContext = false; _CanAddSemicolon = false; _MustCommentStatement = false; _PostIncrementTabs = 0; _PostDecrementTabs = 0; _PreIncrementTabs = 0; _PreDecrementTabs = 0; PreComment = String.Empty; PostComment = String.Empty; _TempLabels = new List<ULabelEntry>(); if( _Labels != null ) { for( int i = 0; i < _Labels.Count; ++ i ) { // No duplicates, caused by having multiple goto's with the same destination if( !_TempLabels.Exists( p => p.Position == _Labels[i].Position ) ) { _TempLabels.Add( _Labels[i] ); } } } }
//this is called whenever an ant enters a nest public void EnteredNest(NestManager nest) { currentNest = nest; inNest = true; /* // this part isn't in gregs? may be from somewhere else * if (state == BehaviourState.Recruiting) * { * if (nest == oldNest) * { * recruitmentStage = RecruitmentStage.GoingToNewNest; * return; * } * else if (nest == myNest && !IsQuorumReached()) // don't wait if quorum reached * { * recruitmentStage = RecruitmentStage.WaitingInNewNest; * _recruitmentWaitStartSeconds = simulation.TickManager.TotalElapsedSimulatedSeconds; * return; * } * } */ //? I think this case would be covered by the block below //ignore ants that have just been dropped here if (nest == myNest && state == BehaviourState.Inactive) { return; } //ignore ants that are carrying or are being carried //? transform.parent.tag == Naming.Ants.CarryPosition is being used for carried ants - could just move isBeingCarried into antmanager if (carryPosition.childCount > 0 || transform.parent.tag == Naming.Ants.CarryPosition) { return; } //if this ant has been lead to this nest then tell leader that it's done its job if (state == BehaviourState.Following && leader != null) { if (leader.state == BehaviourState.Recruiting && nest != leader.oldNest) { leader.StopLeading(); StopFollowing(); if (passive) //? i don't think passive ants can be tandem followers { myNest = nest; ChangeState(BehaviourState.Inactive); return; } else { nestToAssess = nest; ChangeState(BehaviourState.Assessing); } } else if (leader.state == BehaviourState.Reversing && nest == leader.oldNest) { myNest = leader.myNest; oldNest = leader.oldNest; leader.StopLeading(); StopFollowing(); RecruitToNest(myNest); } } // Behaviour for recruiters entering their new nest if (state == BehaviourState.Recruiting && nest == myNest) { if (finishedRecruiting == true) { ChangeState(BehaviourState.Inactive); finishedRecruiting = false; droppedRecently = 0; // Allows this ant to be reverse lead if the emigration is still continuing (this ant was recruited from the other potential nest) return; } else { // If the quorum is not yet reached, there is a chance that a recruiter will reassess their new nest if (follower == null && RandomGenerator.Instance.Range(0f, 1f) < Other.v[Other.RecAssessNewProb] && !IsQuorumReached()) { nestToAssess = nest; ChangeState(BehaviourState.Assessing); } else if (waitNewNestTime == 0) // If the recruiter needs to now wait in the new nest, set the wait counter { waitNewNestTime = Mathf.RoundToInt(quorumThreshold * simulation.Settings.WaitNewNestFactor.Value); // Recruiters wait in the new nest for time dependent on the quorum threshold } } } if (state == BehaviourState.Recruiting && nest == oldNest) { //if no passive ants left in old nest then turn around and return home if (finishedRecruiting == true || nest.GetPassive() == 0) { recruitmentStage = RecruitmentStage.GoingToNewNest; finishedRecruiting = true; return; } //if recruiting and this is old nest then assess with probability pRecAssessOld else if (follower == null && RandomGenerator.Instance.Range(0f, 1f) < Other.v[Other.RecAssessOldProb]) { nestToAssess = nest; ChangeState(BehaviourState.Assessing); return; } } if (state == BehaviourState.Reversing && nest == oldNest) { if (nest.GetPassive() == 0) { recruitmentStage = RecruitmentStage.GoingToNewNest; ChangeState(BehaviourState.Recruiting); finishedRecruiting = true; return; } } //if either ant is following or this isn't one of the ants known nests then assess it if (((state == BehaviourState.Scouting || state == BehaviourState.Recruiting) && nest != oldNest && nest != myNest) || state == BehaviourState.Following && leader.state != BehaviourState.Reversing && nest != leader.oldNest) { if (follower != null) { follower.FailedTandemFollowerBehaviour(); StopLeading();//? Obscure bugfix } nestToAssess = nest; ChangeState(BehaviourState.Assessing); } else { /* //? This bit is commented out * int id = simulation.GetNestID(nest); * //if this nest is my old nest and there's nothing to recruit from it then stop coming here * if (nest == oldNest && GameObject.Find("P" + id).transform.childCount == 0) //? could have a better way to check passive ants left in nest * //oldNest = null; */ /* //? Don't think this is needed * //if recruiting and this is your nest then go back to looking around for ants to recruit * if (state == BehaviourState.Recruiting && nest == myNest && follower == null) * { * RecruitToNest(myNest); * }*/ } /* //? not sure what this is for * // Assessing ant has entered a nest, make sure it updates the assement bit * if (state == BehaviourState.Assessing) * { * //? move.AssessingDirectionChange(); * }*/ }
// Checks if we're currently within a nest of type nestType in any stack! private NestManager.Nest IsWithinNest( NestManager.Nest.NestType nestType ) { for( int i = _NestChain.Count - 1; i >= 0; -- i ) { if( _NestChain[i].Type == nestType ) { return _NestChain[i]; } } return null; }
/*//?private void StoreAssessmentHistory() * { * if (nestAssessmentVisitNumber != 2) * { * return; * } * * if (move.intersectionNumber != 0f) * { * float area = (2.0f * assessmentFirstLengthHistory * assessmentSecondLengthHistory) / (3.14159265359f * move.intersectionNumber); * currentNestArea = area; * } * * // reset values * assessmentFirstLengthHistory = 0f; * assessmentSecondLengthHistory = 0f; * assessmentFirstTimeHistory = 0; * assessmentSecondTimeHistory = 0; * nestAssessmentVisitNumber = 0; * move.intersectionNumber = 0f; * }*/ //assesses nest and takes appropriate action private void AssessNest(NestManager nest) { //reset current nest area //?currentNestArea = 0f; // Nest quality measurement (not buffon's needle, random value from normal distribution, constrained between 0-1) float q = RandomGenerator.Instance.NormalRandom(nest.quality, Other.v[Other.AssessmentNoise]); if (q < 0f) { q = 0f; } else if (q > 1f) { q = 1f; } //if an inactive (& non-passive) ant decides that his current isn't good enough then go look for another if (state == BehaviourState.Inactive && nest == myNest) { perceivedQuality = q; if (q < nestThreshold) { // oldNest = myNest; //? this is commented in greg's version ChangeState(BehaviourState.Scouting); } } else { //if not using comparison then check if this nest is as good or better than threshold if (comparisonAssess == false && q >= nestThreshold) { if (nest != myNest) { oldNest = myNest; //? this is commented in greg's version } if (follower != null) { follower.myNest = nest; StopLeading(); } perceivedQuality = q; RecruitToNest(nest); } //if using comparison then check if this reaches threshold and is better than previous nest else if (comparisonAssess == true && q >= nestThreshold && (myNest == null || q > perceivedQuality)) { if (nest != myNest) { oldNest = myNest; //? this is commented in greg's version } if (follower != null) { follower.myNest = nest; //? Should the follower do this? StopLeading(); } perceivedQuality = q; RecruitToNest(nest); } else // The new nest failed the assessment, so resume the previous state { if (previousState == BehaviourState.Scouting) { ChangeState(BehaviourState.Scouting); } else if (previousState == BehaviourState.Recruiting) { RecruitToNest(myNest); } } } }