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;
}
}
}
