private void Start() { gameState = FindObjectOfType <Game>().getGameState(); energyConsumption = gameState.getEnergyConsumption(); activeScenarioModel = fetchSelectedScenarioModelIf(!sceneSettings.getIsDebugMode()); enableInformationPointsIf((activeScenarioModel is NoScenarioModel)); activeScenario = determineActiveScenario(); player.disablePlayerControls(); displayIntroduction(); }
/// <summary> /// this counts the energy consumption, the delay and the hops. /// </summary> /// <param name="packt"></param> /// <param name="enCon"></param> /// <param name="sender"></param> /// <param name="Reciver"></param> public void ComputeOverhead(Packet packt, EnergyConsumption enCon, Sensor sender, Sensor Reciver) { if (enCon == EnergyConsumption.Transmit) { // calculate the energy double Distance_M = Operations.DistanceBetweenTwoSensors(sender, Reciver); double UsedEnergy_Nanojoule = EnergyModel.Transmit(packt.PacketLength, Distance_M); double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule); sender.ResidualEnergy = sender.ResidualEnergy - UsedEnergy_joule; PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule; packt.UsedEnergy_Joule += UsedEnergy_joule; packt.Hops += 1; double delay = DelayModel.DelayModel.Delay(sender, Reciver, packt); packt.Delay += delay; PublicParamerters.TotalDelayMs += delay; PublicParamerters.TotalRoutingDistance += Distance_M; PublicParamerters.TotalNumberOfHops += 1; switch (packt.PacketType) { case PacketType.Data: PublicParamerters.EnergyConsumedForDataPackets += UsedEnergy_joule; // data packets. break; default: PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; // other packets. break; } } else if (enCon == EnergyConsumption.Recive) { if (Reciver != null) { double UsedEnergy_Nanojoule = EnergyModel.Receive(packt.PacketLength); double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule); Reciver.ResidualEnergy = Reciver.ResidualEnergy - UsedEnergy_joule; packt.UsedEnergy_Joule += UsedEnergy_joule; PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule; switch (packt.PacketType) { case PacketType.Data: PublicParamerters.EnergyConsumedForDataPackets += UsedEnergy_joule; // data packets. break; default: PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; // other packets. break; } } } }
/// <summary> /// this counts the energy consumption, the delay and the hops. /// </summary> /// <param name="packt"></param> /// <param name="enCon"></param> /// <param name="sender"></param> /// <param name="Reciver"></param> public void ComputeOverhead(Packet packt, EnergyConsumption enCon, Sensor sender, Sensor Reciver) { if (enCon == EnergyConsumption.Transmit) { // calculate the energy double Distance_M = Operations.DistanceBetweenTwoSensors(sender, Reciver); double UsedEnergy_Nanojoule = EnergyModel.Transmit(packt.PacketLength, Distance_M); double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule); sender.ResidualEnergy = sender.ResidualEnergy - UsedEnergy_joule; PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule; packt.UsedEnergy_Joule += UsedEnergy_joule; // packt.RoutingDistance += Distance_M; packt.Hops += 1; double delay = DelayModel.DelayModel.Delay(sender, Reciver, packt); packt.Delay += delay; PublicParamerters.TotalDelayMs += delay; PublicParamerters.TotalNumberOfHops += 1; PublicParamerters.TotalRoutingDistance += Distance_M; if (Settings.Default.SaveRoutingLog) { RoutingLog log = new RoutingLog(); log.PacketType = packt.PacketType; log.IsSend = true; log.NodeID = sender.ID; log.Operation = "To:" + Reciver.ID; log.Time = DateTime.Now; log.Distance_M = Distance_M; log.UsedEnergy_Nanojoule = UsedEnergy_Nanojoule; log.RemaimBatteryEnergy_Joule = sender.ResidualEnergy; log.PID = packt.PID; sender.Logs.Add(log); } switch (packt.PacketType) { case PacketType.Data: PublicParamerters.EnergyConsumedForDataPackets += UsedEnergy_joule; // data packets. break; default: PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; // other packets. break; } } else if (enCon == EnergyConsumption.Recive) { if (Reciver != null) { double UsedEnergy_Nanojoule = EnergyModel.Receive(packt.PacketLength); double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule); Reciver.ResidualEnergy = Reciver.ResidualEnergy - UsedEnergy_joule; packt.UsedEnergy_Joule += UsedEnergy_joule; PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule; switch (packt.PacketType) { case PacketType.Data: PublicParamerters.EnergyConsumedForDataPackets += UsedEnergy_joule; // data packets. break; default: PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; // other packets. break; } } } }
public void EvaluateTraits(CreatureManager hManager, string speciesName) { List <Gene> genes = new List <Gene>(); if (!GlobalGEPSettings.RANDOMIZED_TRAITS || traitIndices.Count == 0) { traitIndices = GlobalGEPSettings.speciesTraitLayouts[speciesName]; } foreach (KeyValuePair <string, int[][]> thisTrait in traitIndices) { string key = thisTrait.Key; //For every chromosome a trait is linked to... //i = chromosome index (when a trait is on multiple chromosomes) for (int i = 0; i < thisTrait.Value.Length; i++) { //Index [i][0] will ALWAYS be the chromosome index int chromosomeIndex = thisTrait.Value[i][0]; //For every gene this trait is linked to (on this chromosome)... //j = gene index for this chromosome for (int j = 1; j < thisTrait.Value[i].Length; j++) { //Get the gene index int geneIndex = thisTrait.Value[i][j]; //Add the gene at the chromosomeIndex and geneIndex to a list to be evaluated //Accesses the genome rather than making a copy ensuring the genes accessed later on match exactly the current genome genes.Add(genome[chromosomeIndex].genes[geneIndex]); } } List <Trait> thisTraitList = AccessTraits(genes); //For each trait (keyValuePair) evaluate the genes //Could put the results into a dictionary - this way would be more polymorphic as would search for (or add) a row for each trait and search by name // instead of individual variables, or an array which requires the developer to remember which index is which switch (key.ToLower()) { case "eye left colour": eyeColours[0] = new GeneColour(thisTraitList); if (eyeColours[1] == null && eyeStyle != null) { if (eyeStyle.eyeMatching) { eyeColours[1] = eyeColours[0]; UnityEngine.Debug.Log("Eye Matching, Assigned 1 = 0"); } } break; case "eye right colour": eyeColours[1] = new GeneColour(thisTraitList); if (eyeColours[0] == null && eyeStyle != null) { if (eyeStyle.eyeMatching) { eyeColours[0] = eyeColours[1]; UnityEngine.Debug.Log("Eye Matching, Assigned 0 = 1"); } } break; case "eye style": eyeStyle = new EyeStyle(thisTraitList); if (eyeStyle.eyeMatching) { if (eyeColours[0] != null) { eyeColours[1] = eyeColours[0]; } else if (eyeColours[1] != null) { eyeColours[0] = eyeColours[1]; } else { UnityEngine.Debug.Log("Error: Both eye colours are currently NULL"); } } break; case "hair colour": hairColour = new GeneColour(thisTraitList); break; case "skin colour": skinColour = new GeneColour(thisTraitList); break; case "growth rate": growthRate = new GrowthRate(thisTraitList); break; case "life expectancy": lifeExpectancy = new LifeExpectancy(thisTraitList); break; case "reproductive age": reproductiveAge = new ReproductiveAge(thisTraitList); break; case "gestation period": gestationPeriod = new GestationPeriod(thisTraitList); break; case "energy level": energyLevel = new EnergyLevel(thisTraitList); break; case "energy consumption": energyConsumption = new EnergyConsumption(thisTraitList); break; case "food level": foodLevel = new FoodLevel(thisTraitList); break; case "food consumption": foodConsumption = new FoodConsumption(thisTraitList); break; case "water level": waterLevel = new WaterLevel(thisTraitList); break; case "water consumption": waterConsumption = new WaterConsumption(thisTraitList); break; case "strength": case "intellect": case "constitution": case "wisdom": case "charisma": case "vanity": attributesList.Add(new AttributeTrait(thisTraitList)); break; } genes.Clear(); } }
private void Awake() { gameObject.AddComponent <EnergyConsumption>(); EnergyConsumption energyConsumption = this.GetComponent <EnergyConsumption>(); }
public GameState() { energyConsumption = new EnergyConsumption(); }
private void Start() { gameState = GameObject.FindObjectOfType <Game>().getGameState(); energyConsumption = gameState.getEnergyConsumption(); }
/// <summary> /// /// </summary> /// <param name="packt"></param> /// <param name="enCon"></param> /// <param name="Reciver"></param> public void ComputeOverhead(Packet packt, EnergyConsumption enCon, Sensor Reciver) { if (enCon == EnergyConsumption.Transmit) { if (ID != PublicParamerters.SinkNode.ID) { // calculate the energy double Distance_M = Operations.DistanceBetweenTwoSensors(this, Reciver); double UsedEnergy_Nanojoule = EnergyModel.Transmit(packt.PacketLength, Distance_M); double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule); ResidualEnergy = this.ResidualEnergy - UsedEnergy_joule; PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule; packt.UsedEnergy_Joule += UsedEnergy_joule; packt.RoutingDistance += Distance_M; packt.Hops += 1; double delay = DelayModel.DelayModel.Delay(this, Reciver); packt.Delay += delay; PublicParamerters.TotalDelayMs += delay; if (Settings.Default.SaveRoutingLog) { RoutingLog log = new RoutingLog(); log.PacketType = PacketType.Data; log.IsSend = true; log.NodeID = this.ID; log.Operation = "To:" + Reciver.ID; log.Time = DateTime.Now; log.Distance_M = Distance_M; log.UsedEnergy_Nanojoule = UsedEnergy_Nanojoule; log.RemaimBatteryEnergy_Joule = ResidualEnergy; log.PID = packt.PID; this.Logs.Add(log); } // for control packet. if (packt.PacketType == PacketType.Control) { // just to remember how much energy is consumed here. PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; } } if (Settings.Default.ShowRoutingPaths) { OpenChanel(Reciver.ID, packt.PID); } } else if (enCon == EnergyConsumption.Recive) { double UsedEnergy_Nanojoule = EnergyModel.Receive(packt.PacketLength); double UsedEnergy_joule = ConvertToJoule(UsedEnergy_Nanojoule); ResidualEnergy = ResidualEnergy - UsedEnergy_joule; packt.UsedEnergy_Joule += UsedEnergy_joule; PublicParamerters.TotalEnergyConsumptionJoule += UsedEnergy_joule; if (packt.PacketType == PacketType.Control) { // just to remember how much energy is consumed here. PublicParamerters.EnergyComsumedForControlPackets += UsedEnergy_joule; } } }