protected unsafe override void HandleHuman(Human* human) { var spreading = human->IsSpreading(); var infecting = human->IsInfected(); var diseased = human->IsDiseased(); human->DoDiseaseTick((short)_data.DiseaseToSimulate.SpreadingTime); if (human->IsSpreading() != spreading) { if (spreading) lock (_data.Cells[human->CurrentCell]) _data.Cells[human->CurrentCell].Spreading--; else lock (_data.Cells[human->CurrentCell]) _data.Cells[human->CurrentCell].Spreading++; } if (human->IsInfected() != infecting) { if (infecting) lock (_data.Cells[human->CurrentCell]) _data.Cells[human->CurrentCell].Infecting--; else lock (_data.Cells[human->CurrentCell]) _data.Cells[human->CurrentCell].Infecting++; } if (human->IsDiseased() != diseased) { if (diseased) lock (_data.Cells[human->CurrentCell]) _data.Cells[human->CurrentCell].Diseased--; else lock (_data.Cells[human->CurrentCell]) _data.Cells[human->CurrentCell].Diseased++; } }
protected unsafe override void HandleHuman(Human* human) { if (!human->IsInfected()) return; var rand = RANDOM.Next(100); int ageGroup = (int)human->GetAge() / 32; if (human->GetGender() == EGender.Female) ageGroup += 4; if (rand <= _data.DiseaseToSimulate.HealingFactor[ageGroup]) { lock (_data.Cells[human->CurrentCell]) { if (human->IsSpreading()) --_data.Cells[human->CurrentCell].Spreading; if(human->IsDiseased()) --_data.Cells[human->CurrentCell].Diseased; --_data.Cells[human->CurrentCell].Infecting; } human->HealHuman(); } }
public void MoveHuman(Human* ptr, int destination) { lock(_data.Cells) { PopulationCell currentcell = _data.Cells[ptr->CurrentCell]; PopulationCell destinationcell = _data.Cells[destination]; if (ptr->IsInfected()) { --currentcell.Infecting; ++destinationcell.Infecting; } if (ptr->IsSpreading()) { --currentcell.Spreading; ++destinationcell.Spreading; } if (ptr->IsDiseased()) { --currentcell.Diseased; ++destinationcell.Diseased; } if (ptr->GetGender() == EGender.Male) { switch (ptr->GetAge()) { case EAge.Baby: --currentcell.MaleBabies; ++destinationcell.MaleBabies; break; case EAge.Child: --currentcell.MaleChildren; ++destinationcell.MaleChildren; break; case EAge.Adult: --currentcell.MaleAdults; ++destinationcell.MaleAdults; break; case EAge.Senior: --currentcell.MaleSeniors; ++destinationcell.MaleSeniors; break; } } else { switch (ptr->GetAge()) { case EAge.Baby: --currentcell.FemaleBabies; ++destinationcell.FemaleBabies; break; case EAge.Child: --currentcell.FemaleChildren; ++destinationcell.FemaleChildren; break; case EAge.Adult: --currentcell.FemaleAdults; ++destinationcell.FemaleAdults; break; case EAge.Senior: --currentcell.FemaleSeniors; ++destinationcell.FemaleSeniors; break; } } } ptr->CurrentCell = destination; }
public SimulationData(DateTime startTime) : base("SD") { Cells = new PopulationCell[0]; // 10808574 Humans = new Human[0]; // ~82000000 Deaths = new HumanSnapshot[0]; DeathCount = 0; _time = startTime; }
protected unsafe override void HandleHuman(Human* human) { if(!human->IsDiseased()) return; //TODO: |f| pretty basic stuff right here might wanna spice this up a little var rand = RANDOM.Next(100); int ageGroup = (int)human->GetAge() / 32; if (human->GetGender() == EGender.Female) ageGroup += 4; if (rand <= _data.DiseaseToSimulate.MortalityRate[ageGroup]) { human->KillHuman(); lock (_data.Cells[human->CurrentCell]) { if (human->IsSpreading()) --_data.Cells[human->CurrentCell].Spreading; --_data.Cells[human->CurrentCell].Infecting; --_data.Cells[human->CurrentCell].Diseased; int agegroup = (int)human->GetAge() / 32 + ((human->GetGender() == 0)? 4 : 0); _data.Cells[human->CurrentCell].Data[agegroup]--; } lock (_data.Deaths) _data.AddDeadPeople(new List<HumanSnapshot>() { HumanSnapshot.InitializeFromRuntime( (byte)human->GetGender(), (byte)human->GetAgeInYears(), (byte)human->GetProfession(), human->HomeCell, human->CurrentCell, true) }); } }
/// <summary> /// Generates the ultimative matrix. It spreads /// the people ALLL over their departments. /// /// **In-Place** /// </summary> /// <param name="populationArray">The already initialized /// PopulationCell-matrix which will be used for most stuff. /// This array will be modified!</param> /// <param name="humanArray">The array of Humans. This array will be modified!</param> /// <param name="rawData">The raw DepartmentInfos. This array will be modified!</param> /// <param name="width">width of the populationArray (used for offsets)</param> /// <param name="height">height of the populationArray (used for offsets)</param> public void GenerateMatrix( PopulationCell[] populationArray, Human[] humanArray, IEnumerable<DepartmentInfo> rawData, int width, int height) { WIDTH = width; HEIGHT = height; if (populationArray.Length != WIDTH * HEIGHT) throw new ArgumentException( "The argument has to be an array of PopulationCell with a length of '" + WIDTH * HEIGHT + "'.", "populationArray"); Combiner comb = new Combiner(populationArray, humanArray); int departmentsCount = rawData.Count(); // the parallel call. Parallel.ForEach(rawData, Constants.DEFAULT_PARALLELOPTIONS, (item) => { Human[] humans; var res = _dummy? DummyPopulate(item, out humans) : Populate(item, out humans); // populate the department. comb.Enqueue(res, humans); res = null; humans = null; DepartmentCalculationFinished.Raise(this, new GeneratorEventArgs { Name = item.Name, Total = departmentsCount }); WriteMessage("Calculated: " + item.Name); }); comb.Wait(); comb.Dispose(); }
private void MovePlumber(Human* ptr) { //Working Mindset -> Plumber going to different households each hour //Assert : Plumber is at Home at 0 o'clock; switch (ptr->GetMindset()) { case PopulationData.EMindset.Working: if (_data.CurrentHour > 7 && _data.CurrentHour < 18) { LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 5, 74)); } //return home at 18 o'clock else if (_data.CurrentHour == 18) { if (!ptr->IsAtHome()) LetHumanTravelHome(ptr); else return; } else return; break; case PopulationData.EMindset.DayOff: if (_data.CurrentHour < 11) { //sleep return; } else if (_data.CurrentHour < 20 && ptr->IsAtHome()) { if (RANDOM.Next(20) == 19) LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 10, 50)); } else if (_data.CurrentHour == 20 && !ptr->IsAtHome()) LetHumanTravelHome(ptr); else return; break; } }
private void MovePupil(Human* ptr) { switch (ptr->GetMindset()) { //Working Mindset -> Pupil going to school this day //Assert : Pupil is at Home at 0 o'clock case PopulationData.EMindset.Working: //Pupil is at Home in the Morning if (_data.CurrentHour < 7) { return; } //Pupil should be in school from 7-10 else if (_data.CurrentHour == 7) { LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 2, 125)); } else if (_data.CurrentHour < 11) { return; //Pupil should stay in school } //pupil has chance that school ends else if (_data.CurrentHour < 14) { if (!ptr->IsAtHome()) { if (RANDOM.Next(3) == 2) LetHumanTravelHome(ptr); else return; } else return; } //School ends definately else if (_data.CurrentHour == 14) { if (!ptr->IsAtHome()) LetHumanTravelHome(ptr); else return; } else if (_data.CurrentHour == 15) { if (RANDOM.Next(2) == 1) LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 2, 25)); else return; } //Return pupil home if he isn't already else if (_data.CurrentHour == 18) { if (!ptr->IsAtHome()) LetHumanTravelHome(ptr); else return; } //in the evening pupil should be at home else return; break; //Dayoff Behaviour //Wander around aimlessly case PopulationData.EMindset.DayOff: if (_data.CurrentHour < 7) return; else if (_data.CurrentHour < 18) LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 0, 25)); else if (_data.CurrentHour == 18 && !ptr->IsAtHome()) LetHumanTravelHome(ptr); else return; break; } }
private void MoveDeskJobber(Human* ptr) { switch (ptr->GetMindset()) { //Working Mindset -> Deskjobber has 9 to 5 job //Assert : Deskjobber is at Home at 0 o'clock; case PopulationData.EMindset.Working: //Go to work if (_data.CurrentHour == 9) { LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 0, 75)); } //Go home else if (_data.CurrentHour == 18) { LetHumanTravelHome(ptr); } //In the morning and evening stay at home else return; break; case PopulationData.EMindset.DayOff: if (_data.CurrentHour < 11) { //sleep return; } else if (_data.CurrentHour < 20 && ptr->IsAtHome()) { if (RANDOM.Next(20) == 19) LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 10, 50)); } else if (_data.CurrentHour == 20 && !ptr->IsAtHome()) { LetHumanTravelHome(ptr); } else return; break; } }
private void MoveHousewife(Human* ptr) { switch (ptr->GetMindset()) { //Working Mindset -> Housewife doesn't go to work is either at home in the city or by friends //Assert : Housewife is at Home at 0 o'clock; case PopulationData.EMindset.DayOff: case PopulationData.EMindset.Working: //Run around aimlessly^^ if (_data.CurrentHour > 6 && _data.CurrentHour < 20) { //chance to go shopping/visit friends/work LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 0, 5)); } //return home at 20 o'clock else if (_data.CurrentHour == 20) { if (!ptr->IsAtHome()) LetHumanTravelHome(ptr); else return; } else return; break; } }
/// <summary> /// The Dummy-implementation. /// </summary> private Tuple<int, PopulationCell>[] DummyPopulate(DepartmentInfo depInfo, out Human[] humanArray) { int areaSize = depInfo.Coordinates.Length; Tuple<int, PopulationCell>[] tmpArray = new Tuple<int, PopulationCell>[areaSize]; int tmpCounter = 0; humanArray = new Human[depInfo.GetTotal()]; int humanCounter = 0; int[] popsPerPoint = depInfo.Population.Select(x => x / areaSize).ToArray(); foreach (Point point in depInfo.Coordinates) { PopulationCell cell = new PopulationCell(); for (int i = 0; i < 8; i++) { EGender gender = (i < 4) ? EGender.Male : EGender.Female; var bounds = GetAgeBounds(i); int lowerAgeBound = bounds.Item1; int upperAgeBound = bounds.Item2; for (int n = 0; n < popsPerPoint[i]; n++) { int thisAge = RANDOM.Next(lowerAgeBound, upperAgeBound + 1); humanArray[humanCounter++] = Human.Create(gender, thisAge, point.Flatten(WIDTH)); cell.Data[i]++; } } tmpArray[tmpCounter++] = new Tuple<int, PopulationCell>(point.Flatten(WIDTH), cell); } return tmpArray; }
private void MoveCommuter(Human* ptr) { switch (ptr->GetMindset()) { //Working Mindset -> Commuter goes to work in a city that is 0,5-2 hours away from home //Assert : Commuter is at Home at 0 o'clock; case PopulationData.EMindset.Working: //travel to distant workplace if (_data.CurrentHour == 6) { LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 125, 400)); } //return home else if (_data.CurrentHour == 17) { LetHumanTravelHome(ptr); } //Stay home in the morning and evening else return; break; case PopulationData.EMindset.DayOff: if (_data.CurrentHour < 11) { //sleep return; } else if (_data.CurrentHour < 20 && ptr->IsAtHome()) { if (RANDOM.Next(20) == 19) LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 10, 50)); } else if (_data.CurrentHour == 20 && !ptr->IsAtHome()) { LetHumanTravelHome(ptr); } else return; break; } }
private unsafe void AssignProfession(Human* hptr, EAge previousAge) { EAge newAgegroup = hptr->GetAge(); if (newAgegroup != previousAge) { if (newAgegroup == EAge.Child) { hptr->SetProfession(EProfession.Pupil); } else if (newAgegroup == EAge.Adult) { int choice = RANDOM.Next(6); switch (choice) { case 0: hptr->SetProfession(EProfession.Student); break; case 1: hptr->SetProfession(EProfession.Plumber); break; case 2: hptr->SetProfession(EProfession.Commuter); break; case 3: hptr->SetProfession(EProfession.DeskJobber); break; case 4: hptr->SetProfession(EProfession.TravellingSalesman); break; case 5: hptr->SetProfession(EProfession.Housewife); break; } } else if (newAgegroup == EAge.Senior) { hptr->SetProfession(EProfession.Housewife); } else { throw new Exception("Someone seemed to have found the fountain of Youth" + "atleast he wasn't a baby before this Agetick and now he is. MAGIC!"); } } else { if (hptr->GetProfession() == EProfession.Student && hptr->GetAgeInYears() >= 30) { int choice = RANDOM.Next(5); switch (choice) { case 0: hptr->SetProfession(EProfession.Plumber); break; case 1: hptr->SetProfession(EProfession.Commuter); break; case 2: hptr->SetProfession(EProfession.DeskJobber); break; case 3: hptr->SetProfession(EProfession.TravellingSalesman); break; case 4: hptr->SetProfession(EProfession.Housewife); break; } } } }
private void MoveTravellingSalesman(Human* ptr) { switch (ptr->GetMindset()) { //Working Mindset -> Travelling Salesman travels through Germany, changes location each day, // returns home on friday case PopulationData.EMindset.Working: //Returns home on friday if (_data.CurrentDay == DayOfWeek.Friday) { //Travel Home on Friday if (_data.CurrentHour == 4) LetHumanTravelHome(ptr); } //on every other day travel through germany else { if (_data.CurrentHour == 4) { LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 400, 800)); } else return; } break; case PopulationData.EMindset.DayOff: if (_data.CurrentHour < 12) { //sleep return; } else if (_data.CurrentHour < 20 && ptr->IsAtHome()) { if (RANDOM.Next(20) == 19) LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 10, 50)); } else if (_data.CurrentHour == 20 && !ptr->IsAtHome()) { LetHumanTravelHome(ptr); } else return; break; } }
public void Enqueue(Tuple<int, PopulationCell>[] cells, Human[] humans) { _queueCells.Enqueue(cells); _queueHumans.Enqueue(humans); if (_taskCells == null || _taskCells.Status != TaskStatus.Running) _taskCells = Task.Run(() => AddCells()); if (_taskHumans == null || _taskHumans.Status != TaskStatus.Running) _taskHumans = Task.Run(() => AddHumans()); }
protected unsafe abstract void HandleHuman(Human* human);
public Combiner(PopulationCell[] cellArray, Human[] humanArray) { _cells = cellArray; _humans = humanArray; _humanPoint = 0; _queueCells = new ConcurrentQueue<Tuple<int, PopulationCell>[]>(); _queueHumans = new ConcurrentQueue<Human[]>(); }
private Tuple<int, PopulationCell>[] PopulateDepartment(DepartmentInfo depInfo, out Human[] humanArray) { List<Human> humanList = new List<Human>(depInfo.GetTotal()); int areaSize = depInfo.Coordinates.Length; // number of points to be populated. Tuple<int, PopulationCell>[] resultArray = // the array which will be returned. new Tuple<int,PopulationCell>[areaSize]; int resultArrayIndex = 0; // running index for the array. Point origin = CalculateInitialPoint(depInfo.Coordinates); // the origin as an fixpoint for every point. int maximumDistance = depInfo.Coordinates.Max( // the maximum distance possible. point => point.Distance(origin)) + 1; int[] factors = new int[maximumDistance]; // array of factor for each distance. factors[0] = 225; // start factor. for (int i = 1; i < maximumDistance; i++) // creating every factor for each distance. { int previousFactor = factors[i - 1]; int minus = (int)(previousFactor / 3f / 6); int random = RANDOM.Next(previousFactor / 3) - minus; random = (int)(random * (1 - i / (float)maximumDistance)); if (previousFactor - random <= 0) random = 5; factors[i] = previousFactor - random; } foreach (Point currentPoint in depInfo.Coordinates) { int currentDistance = currentPoint.Distance(origin); // distance of this point to the origin. PopulationCell currentCell = new PopulationCell(); for (int i = 0; i < 8; i++) // for each age-group. { int additionalRand = RANDOM.Next(10) - 5; int numberForEvenSpread = // number of humans if everything would be even/the same. (int)(depInfo.Population[i] / (float)areaSize); int numberOfPeopleToSet = // number of humans to be set for this age-group. (int)(numberForEvenSpread * (factors[currentDistance] + additionalRand) / 100f); EGender gender = (i < 4) ? // the first four are male, the last female. EGender.Male : EGender.Female; var bounds = GetAgeBounds(i); // the age-boundaries for the corresponding age-group. int lowerAgeBound = bounds.Item1; int upperAgeBound = bounds.Item2; for (int setCount = 0; setCount < numberOfPeopleToSet; setCount++) { int thisAge = RANDOM.Next(lowerAgeBound, upperAgeBound + 1); Human thisHuman = Human.Create(gender, thisAge, currentPoint.Flatten(WIDTH)); humanList.Add(thisHuman); currentCell.Data[i]++; // 'adds' the human to its cell. depInfo.Population[i]--; // 'removes' the human out of the population. } } areaSize--; // 'removes' point from rest-area. resultArray[resultArrayIndex++] = new Tuple<int, PopulationCell>( currentPoint.Flatten(WIDTH), currentCell); } humanArray = humanList.ToArray(); humanList = null; return resultArray; }
/// <summary> /// The standard method to populate. /// </summary> private Tuple<int, PopulationCell>[] Populate(DepartmentInfo depInfo, out Human[] humanArray) { // the count of cells. int areaSize = depInfo.Coordinates.Length; // precalculating humans. (~ +- 10%) for (int i = 0; i < depInfo.Population.Length; ++i) depInfo.Population[i] = (int)Math.Round( depInfo.Population[i] * (1 - (RANDOM.Next(20) - 10) / 100f)); // initializing array. var resultArray = new Tuple<int, PopulationCell>[areaSize]; int resultIndex = 0; // the origin used as fixpoint. Point origin = CalculateInitialPoint(depInfo.Coordinates); // maximum distance possible. (returns a relative small number) int maxDistance = depInfo.Coordinates.Max(p => p.Distance(origin)) + 1; // array of factors double[] factors = new double[maxDistance]; factors[0] = 1.5; // start factor. for (int i = 1; i < maxDistance; i++) // creating every factor for each distance. { //TODO | dj | randomise // (-(1/maxDistance * i)^2 + 1.75) * 100 double one = 1d / maxDistance * i; double two = Math.Pow(one, 2); double three = factors[0]; double four = three - two; factors[i] = four; } // array for each age-group, holding a list of Tuple of cell-indices and count. Queue<Tuple<int, ushort>>[] agesOfCells = new Queue<Tuple<int, ushort>>[8]; agesOfCells.Initialize<Queue<Tuple<int, ushort>>>(); int humanCount = 0; // going through all points and set the counts. foreach (Point point in depInfo.Coordinates) { PopulationCell cell = new PopulationCell(); int cellIndex = point.Flatten(WIDTH); double factor = factors[point.Distance(origin)]; for (int i = 0; i < 8; ++i) { ushort toSet = (ushort)Math.Round(depInfo.Population[i] / (double)areaSize * factor); cell.Data[i] = toSet; agesOfCells[i].Enqueue(new Tuple<int,ushort>(cellIndex, toSet)); depInfo.Population[i] -= toSet; //if (cell.Data[i] == 0) // Console.WriteLine("0 people in {0}", cellIndex); } if (cell.Total == 0 && depInfo.Population.Sum() != 0) { int j = 0; do { j = RANDOM.Next(8); } while (depInfo.Population[j] == 0); cell.Data[j] = 1; agesOfCells[j].Enqueue(new Tuple<int,ushort>(cellIndex, 1)); depInfo.Population[j] -= 1; } areaSize--; humanCount += cell.Total; resultArray[resultIndex++] = new Tuple<int,PopulationCell>(cellIndex, cell); } // initializing human array humanArray = new Human[humanCount]; int humanIndex = 0; // going through all ages and creating the humans. for (int i = 0; i < 8; ++i) { var queue = agesOfCells[i]; var bounds = GetAgeBounds(i); // age-bounds (for random). int lowerAge = bounds.Item1; int upperAge = bounds.Item2; // gender. EGender gender = (i < 4) ? EGender.Male : EGender.Female; // for each cell. while (queue.Count > 0) //foreach (Tuple<int, ushort> cellTuple in queue) { var cellTuple = queue.Dequeue(); int cellIndex = cellTuple.Item1; ushort count = cellTuple.Item2; // for each human (who shall be created). ushort c = count; while (c-- > 0) //for (int c = 0; c < count; ++c) { int thisHumanAge = RANDOM.Next(lowerAge, upperAge + 1); Human thisHuman = Human.Create(gender, thisHumanAge, cellIndex); humanArray[humanIndex++] = thisHuman; } } agesOfCells[i] = null; // not necessary, but who knows :P } return resultArray; }
private unsafe void TryInfection(Human* human, Disease disease, int probability) { // get index for FactorContainer int ageIndex = (byte)human->GetAge() / 32; ageIndex += human->GetGender() == EGender.Male ? 0 : 4; int resistance = disease.ResistanceFactor.Data[ageIndex]; if (resistance < probability) { int factor = probability - resistance; int rand = RANDOM.Next(100); if (rand <= factor) { human->Infect((short)disease.IncubationPeriod, (short)disease.IdleTime); lock (_data.Cells[human->CurrentCell]) _data.Cells[human->CurrentCell].Infecting++; } } }
/// <summary> /// Moves a selected Human to another Area in the PopulationCellGrid. /// </summary> /// <param name="data">Reference to SimulationData</param> /// <param name="currentcell">The cell the human to move is currently in</param> /// <param name="human">The index of the selected human in the current cell</param> /// <param name="destinationcell">The index of the cell the human should be moved to</param> private void LetHumanTravel(Human* ptr, int destinationcell) { int maxcelldiffernce = Math.Max(Math.Abs(ptr->CurrentCell % _data.ImageWidth - destinationcell % _data.ImageWidth), Math.Abs(ptr->CurrentCell / _data.ImageWidth - destinationcell / _data.ImageWidth)); if (maxcelldiffernce < 75) { //Add the selected Human in the Destinationcell MoveHuman(ptr, destinationcell); } else { ptr->TravellingCounter = (byte)((maxcelldiffernce / 5) / 70); ptr->DesiredCell = destinationcell; ptr->SetTravelling(true); } }
private void MoveStudent(Human* ptr) { switch (ptr->GetMindset()) { //Working Mindset -> Student going to University this day //Assert : Student is at Home at 0 o'clock; It isn't suturday or sunday; University traveltime <= 1h case PopulationData.EMindset.Working: //Student can have lectures during day including breaks if (_data.CurrentHour > 8 && _data.CurrentHour < 18) { if (ptr->IsAtHome()) { //chance to go to university if (RANDOM.Next(3) == 2) LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 3, 75)); else return; } else { //chance to go home if (RANDOM.Next(9) == 8) LetHumanTravelHome(ptr); else return; } } //No lectures after 18 o'clock else if (_data.CurrentHour == 18) { LetHumanTravelHome(ptr); } //in the morning/evening student is at home else return; break; //DayOff Mindset : case EMindset.DayOff: if (_data.CurrentHour == 6 && !ptr->IsAtHome()) { LetHumanTravelHome(ptr); } else if (_data.CurrentHour > 6 && _data.CurrentHour < 19) { if (ptr->IsAtHome() && RANDOM.Next(6) == 5) { LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 0, 74)); } } else if (_data.CurrentHour == 19 && !ptr->IsAtHome()) { LetHumanTravelHome(ptr); } else if (_data.CurrentHour == 22 && RANDOM.Next(2) == 1) { //Party LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 25, 75)); } else return; break; } }
private void LetHumanTravelHome(Human* ptr) { LetHumanTravel(ptr, ptr->HomeCell); }
private void SetUp() { r = new Random((int)DateTime.Now.Ticks); h1 = Human.Create(EGender.Female, AGE_FEMALE, HOMECELL); h2 = Human.Create(EGender.Male, AGE_MALE, HOMECELL); }
private unsafe void UpdateHumanChangeToCell(Human* hptr, SimulationData data, EAge previousAge) { EAge newAge = hptr->GetAge(); if (previousAge != newAge) { lock (data.Cells[hptr->CurrentCell]) { PopulationCell currentcell = data.Cells[hptr->CurrentCell]; if (hptr->GetGender() == EGender.Female) { if (newAge == EAge.Child) { --currentcell.FemaleBabies; ++currentcell.FemaleChildren; } else if (newAge == EAge.Adult) { --currentcell.FemaleChildren; ++currentcell.FemaleAdults; } else if (newAge == EAge.Senior) { --currentcell.FemaleAdults; ++currentcell.FemaleSeniors; } } else { if (newAge == EAge.Child) { --currentcell.MaleBabies; ++currentcell.MaleChildren; } else if (newAge == EAge.Adult) { --currentcell.MaleChildren; ++currentcell.MaleAdults; } else if (newAge == EAge.Senior) { --currentcell.MaleAdults; ++currentcell.MaleSeniors; } } } } }
/// <summary> /// Factory method from which Humans are created /// </summary> /// <param name="gender">Gender of the Human to create</param> /// <param name="age">Age in Years of the Human to create (1-110)</param> /// <param name="homeCell">HomeCell of the Human to create</param> /// <returns>The newly created Human struct</returns> public static Human Create(EGender gender, int age, int homeCell) { var human = new Human(homeCell); human.SetGender(gender); human.SetAge(age); human.SetDeath(false); if (human.GetAge() == EAge.Baby) { human.SetMindset(EMindset.Stationary); } else if (human.GetAge() == EAge.Child) { human.SetProfession(EProfession.Pupil); human.SetMindset(EMindset.Working); } else if (human.GetAge() == EAge.Adult) { int result = RANDOM.Next(100); if (result < 10) { human.SetProfession(EProfession.Student); //10% human.SetMindset(EMindset.Working); } else if (result < 35) { human.SetProfession(EProfession.Plumber); //25% human.SetMindset(EMindset.Working); } else if (result < 60) { human.SetProfession(EProfession.DeskJobber); //25% human.SetMindset(EMindset.Working); } else if (result < 80) { human.SetProfession(EProfession.Commuter); //20% human.SetMindset(EMindset.Working); } else if (result < 90) { human.SetProfession(EProfession.TravellingSalesman);//10% human.SetMindset(EMindset.Working); } else { human.SetProfession(EProfession.Housewife); //10% human.SetMindset(EMindset.Working); } } else if (human.GetAge() == EAge.Senior) { human.SetProfession(EProfession.Unemployed); human.SetMindset(EMindset.HomeStaying); } return human; }
/// <summary> /// Reads the information out of /// the given file and sets the /// corresponding values. /// </summary> /// <param name="filePath">The path to the .dep-file.</param> /// <exception cref="IOException">Might be thrown.</exception> public void InitializeFromFile(string filePath) { var reader = new DepartmentMapReader(filePath); reader.IterationPassed += ReadFileIterationPassed.Raise; DepartmentInfo[] deps = reader.ReadFile(); Image img = reader.ReadImage(); ImageWidth = img.Width; ImageHeight = img.Height; WriteMessage("Calculating Total-Population..."); int maxPopulation = deps.Sum(x => x.GetTotal()); // getting maximum population Humans = new Human[(int)(maxPopulation * 1.05f)]; // adding 5% :) WriteMessage("Generating Matrix..."); Cells = new PopulationCell[ImageWidth * ImageHeight]; MatrixGenerator mg = new MatrixGenerator(false); mg.DepartmentCalculationFinished += DepartmentCalculated.Raise; mg.GenerateMatrix(Cells, Humans, deps, ImageWidth, ImageHeight); WriteMessage("...Matrix generated."); }