public BreathingRate(ActivityLevel activityLevel)
{
switch (activityLevel)
{
case ActivityLevel.AtRest:
{
this.ChemAg_Ih = 0.0075;
this.BioAg_RadPar_Ih = 0.0075;
this.ChemAg_UnitlessFactor = 0.5;
} break;
case ActivityLevel.Light:
{
this.ChemAg_Ih = 0.015;
this.BioAg_RadPar_Ih = 0.015;
this.ChemAg_UnitlessFactor = 1;
} break;
case ActivityLevel.Moderate:
{
this.ChemAg_Ih = 0.03;
this.BioAg_RadPar_Ih = 0.03;
this.ChemAg_UnitlessFactor = 2;
} break;
case ActivityLevel.Heavy:
{
this.ChemAg_Ih = 0.075;
this.BioAg_RadPar_Ih = 0.075;
this.ChemAg_UnitlessFactor = 5;
} break;
}
}
//Activity Level
public void updateActivityLevel(ActivityLevel level)
{
bool changed = false;
lock (activityLevelLock)
{
switch (level)
{
case ActivityLevel.IN_GAME:
lastInGameActivityTime = parent.currentMillisecond;
currentVessel = Guid.Empty;
break;
case ActivityLevel.IN_FLIGHT:
lastInFlightActivityTime = parent.currentMillisecond;
lastInGameActivityTime = parent.currentMillisecond;
break;
}
if (level > activityLevel)
{
activityLevel = level;
changed = true;
}
}
if (changed)
{
parent.clientActivityLevelChanged(this);
}
}
private void refreshLoadedVesselRosterPartOnly(Dictionary <string, KeepFitCrewMember> roster,
KeepFitVesselRecord vesselRecord,
Vessel vessel)
{
ActivityLevel vesselDefaultActivityLevel = getDefaultActivityLevel(vessel);
foreach (Part part in vessel.Parts)
{
if (part.CrewCapacity == 0)
{
continue;
}
ActivityLevel bestPartActivityLevel = vesselDefaultActivityLevel;
// check all modules on the part in case we have multiple KeepFit modules for some reason
foreach (KeepFitPartModule kfModule in part.FindModulesImplementing <KeepFitPartModule>())
{
ActivityLevel partActivityLevel = kfModule.activityLevel;
if (partActivityLevel > bestPartActivityLevel)
{
bestPartActivityLevel = partActivityLevel;
}
}
foreach (ProtoCrewMember partCrewMember in part.protoModuleCrew)
{
updateRosters(roster, vesselRecord, partCrewMember.name, bestPartActivityLevel, true);
}
}
}
private void refreshLoadedVesselRosterCLS(Dictionary <string, KeepFitCrewMember> roster,
KeepFitVesselRecord vesselRecord,
Vessel vessel)
{
ActivityLevel vesselDefaultActivityLevel = getDefaultActivityLevel(vessel);
ConnectedLivingSpace.ICLSAddon cls = module.GetCLS();
foreach (ConnectedLivingSpace.ICLSSpace space in cls.Vessel.Spaces)
{
ActivityLevel spaceBestActivityLevel = vesselDefaultActivityLevel;
foreach (ConnectedLivingSpace.ICLSPart part in space.Parts)
{
if (part.Part.CrewCapacity == 0)
{
continue;
}
// check all modules on the part in case we have multiple KeepFit modules for some reason
foreach (KeepFitPartModule kfModule in part.Part.FindModulesImplementing <KeepFitPartModule>())
{
ActivityLevel partActivityLevel = kfModule.activityLevel;
if (partActivityLevel > spaceBestActivityLevel)
{
spaceBestActivityLevel = partActivityLevel;
}
}
foreach (ConnectedLivingSpace.ICLSKerbal partCrewMember in space.Crew)
{
updateRosters(roster, vesselRecord, partCrewMember.Kerbal.name, spaceBestActivityLevel, true);
}
}
}
}
public void resetProperties()
{
username = "";
screenshot = null;
watchPlayerName = String.Empty;
receivedHandshake = false;
sharedCraftFile = null;
sharedCraftName = String.Empty;
sharedCraftType = KMPCommon.CraftType.VAB;
lastUDPACKTime = 0;
queuedOutMessagesHighPriority = new ConcurrentQueue <byte[]>();
queuedOutMessagesSplit = new ConcurrentQueue <byte[]>();
queuedOutMessages = new ConcurrentQueue <byte[]>();
lock (activityLevelLock)
{
activityLevel = Client.ActivityLevel.INACTIVE;
lastInGameActivityTime = parent.currentMillisecond;
lastInFlightActivityTime = parent.currentMillisecond;
}
lock (timestampLock)
{
lastReceiveTime = parent.currentMillisecond;
connectionStartTime = parent.currentMillisecond;
lastSyncTime = parent.currentMillisecond;
}
}
/// <summary>
/// Calculates Total Daily Energy Expenditure (TDEE) using selected activity level of user.
/// TDEE: Minimum amount of calories required to maintain weight while considering activity level.
/// </summary>
/// <param name="activityLevel">User's current average level of activity</param>
/// <param name="BMR">Basal Metabolic Rate</param>
/// <returns>Rounded TDEE</returns>
private static double calculateTDEE(ActivityLevel activityLevel, double BMR)
{
double activityFactor = 0;
switch (activityLevel)
{
case ActivityLevel.Sedentary:
activityFactor = 1.2;
break;
case ActivityLevel.LightlyActive:
activityFactor = 1.375;
break;
case ActivityLevel.Moderate:
activityFactor = 1.55;
break;
case ActivityLevel.Active:
activityFactor = 1.725;
break;
case ActivityLevel.VeryActive:
activityFactor = 1.9;
break;
}
return(Math.Round(BMR * activityFactor));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Activity_Level,Barking_Level")] ActivityLevel activityLevel)
{
if (id != activityLevel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(activityLevel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ActivityLevelExists(activityLevel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(activityLevel));
}
public void TestCalculateUserCalories(Gender gender, ActivityLevel activityLevel, WeightLoseGain weightLoseGain, double finalresult)
{
var user = new ApplicationUser
{
Id = "userId",
FirstName = "Test",
LastName = "Testov",
Age = 20,
CurrentWeight = 100,
Height = 200,
Gender = gender,
BirthDate = DateTime.UtcNow.Date,
ActivityLevel = activityLevel,
WeightLoseGain = weightLoseGain,
DailyCalories = 3000,
RemainingCalories = 3000,
Protein = 200,
RemainingProtein = 200,
Carbs = 400,
RemainingCarbs = 400,
Fat = 100,
RemainingFat = 100,
};
var service = new UsersService(
this.userRepository.Object,
this.imageRepository.Object);
var result = service.CalculateUserCalories(user);
Assert.Equal(finalresult, result);
}
public void resetProperties()
{
username = "";
screenshot = null;
watchPlayerName = String.Empty;
canBeReplaced = false;
receivedHandshake = false;
sharedCraftFile = null;
sharedCraftName = String.Empty;
sharedCraftType = 0;
lastUDPACKTime = 0;
queuedOutMessages = new Queue <byte[]>();
lock (activityLevelLock)
{
activityLevel = ServerClient.ActivityLevel.INACTIVE;
lastInGameActivityTime = parent.currentMillisecond;
lastInFlightActivityTime = parent.currentMillisecond;
}
lock (timestampLock)
{
lastReceiveTime = parent.currentMillisecond;
connectionStartTime = parent.currentMillisecond;
}
}
public UserInfoModel(int age, int height, decimal weight, Gender gender, ActivityLevel activityFactor)
{
Age = age;
Height = height;
Weight = weight;
Gender = gender;
ActivityLevel = activityFactor;
}
public Person(int weight, int height, int age, Sex sex, ActivityLevel activityLevel, Goal goal)
{
this.Weight = weight;
this.Height = height;
this.Age = age;
this.Sex = sex;
this.ActivityLevel = activityLevel;
this.Goal = goal;
}
public Plan(string name, ActivityLevel activityLevel, Goal goal, decimal target, Pace pace, int duration = 0)
{
Name = name;
ActivityLevel = activityLevel;
Goal = goal;
Target = target;
Pace = pace;
Duration = duration;
Status = Status.Inactive;
}
internal GoalBuilder()
{
this.startingWeight = 82;
this.goalWeight = 78;
this.height = 177;
this.age = 25;
this.genderType = GenderType.male;
this.goalType = GoalType.loseweight;
this.activityLevel = ActivityLevel.heavy;
}
public async Task <IActionResult> Create([Bind("Id,Activity_Level,Barking_Level")] ActivityLevel activityLevel)
{
if (ModelState.IsValid)
{
_context.Add(activityLevel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(activityLevel));
}
public SurveyResult SubmitWithValidData_ReturnResultsPage()
{
Email.SendKeys("*****@*****.**");
State.SendKeys("ak");
FavoritePark.SendKeys("Glacier National Park");
ActivityLevel.SendKeys("Inactive");
SubmitButton.Click();
return(new SurveyResult(driver));
}
public User(String name, String password, String goal, String activity, String gender, DateTime birthday,
int height, double currentWeight, double goalWeight)
{
this.name = name;
this.password = password;
switch (goal)
{
case "lose":
this.goal = Goal.lose;
break;
case "maintain":
this.goal = Goal.maintain;
break;
case "gain":
this.goal = Goal.gain;
break;
}
switch (activity)
{
case "veryActive":
this.activity = ActivityLevel.veryActive;
break;
case "active":
this.activity = ActivityLevel.active;
break;
case "lightlyActive":
this.activity = ActivityLevel.lightlyActive;
break;
case "notVeryActive":
this.activity = ActivityLevel.notVeryActive;
break;
}
switch (gender)
{
case "male":
this.gender = Gender.male;
break;
case "female":
this.gender = Gender.female;
break;
}
this.birthday = birthday;
this.height = height;
this.currentWeight = currentWeight;
this.goalWeight = goalWeight;
}
public Goal(double startingWeight, double goalWeight, double height, int age, GenderType gender,
GoalType goalType,
ActivityLevel level)
{
if (startingWeight < 0)
{
throw new ArgumentException("Starting weight can not be a negative number!");
}
if (goalWeight < 0)
{
throw new ArgumentException("Goal weight can not be a negative number!");
}
if (height < 0)
{
throw new ArgumentException("Height can not be a negative number!");
}
if (age < 0)
{
throw new ArgumentException("Age can not be a negative number!");
}
if (!Enum.IsDefined(typeof(GenderType), gender))
{
throw new ArgumentException("The provided gender goalType is not valid!");
}
if (!Enum.IsDefined(typeof(GoalType), goalType))
{
throw new ArgumentException("The provided goal goalType is not valid!");
}
if (!Enum.IsDefined(typeof(ActivityLevel), level))
{
throw new ArgumentException("The provided activity level is not valid!");
}
//Guard.WhenArgument(startingWeight, "Starting weight can not be a negative number!").IsLessThan(0).Throw();
//Guard.WhenArgument(goalWeight, "Goal weight can not be a negative number!").IsLessThan(0).Throw();
//Guard.WhenArgument(height, "Height can not be a negative number!").IsLessThan(0).Throw();
//Guard.WhenArgument(age, "Age can not be a negative number!").IsLessThan(0).Throw();
this.StartingWeight = startingWeight;
this.GoalWeight = goalWeight;
this.Height = height;
this.Age = age;
this.Gender = gender;
this.GoalType = goalType;
this.ActivityLevel = level;
}
internal void DrawActivityLevel(ActivityLevel activityLevel)
{
Texture2D texActivityLevel;
uiResources.texIconsActivityLevels.TryGetValue(activityLevel, out texActivityLevel);
if (texActivityLevel == null)
{
GUILayout.Label("(" + activityLevel + ")");
}
else
{
GUILayout.Label(new GUIContent(uiResources.texIconsActivityLevels[activityLevel], activityLevel.ToString()));
}
}
private void refreshNonLoadedVesselRoster(Dictionary <string, KeepFitCrewMember> roster,
KeepFitVesselRecord vesselRecord,
Vessel vessel)
{
ActivityLevel defaultActivityLevel = getDefaultActivityLevel(vessel);
foreach (ProtoPartSnapshot part in vessel.protoVessel.protoPartSnapshots)
{
foreach (ProtoCrewMember crewMember in part.protoModuleCrew)
{
updateRosters(roster, vesselRecord, crewMember.name, defaultActivityLevel, false);
}
}
}
public bool CompareTo(Dog otherDog)
{
if (otherDog.ActivityLevel == Enums.EScale.None)
{
}
else if (!ActivityLevel.Equals(otherDog.ActivityLevel))
{
return(false);
}
if (otherDog.SheddingLevel == Enums.EScale.None)
{
}
else if (!SheddingLevel.Equals(otherDog.SheddingLevel))
{
return(false);
}
if (otherDog.GroomingLevel == Enums.EScale.None)
{
}
else if (!GroomingLevel.Equals(otherDog.GroomingLevel))
{
return(false);
}
if (otherDog.IntelligenceLevel == Enums.EScale.None)
{
}
else if (!IntelligenceLevel.Equals(otherDog.IntelligenceLevel))
{
return(false);
}
if (!GoodWithChildren.Equals(otherDog.GoodWithChildren))
{
return(false);
}
if (!Coatlength.Equals(otherDog.Coatlength))
{
return(false);
}
if (!Size.Equals(otherDog.Size))
{
return(false);
}
return(true);
}
internal void DrawActivityLevel(ActivityLevel activityLevel)
{
Texture2D texActivityLevel;
uiResources.texIconsActivityLevels.TryGetValue(activityLevel, out texActivityLevel);
if (texActivityLevel == null)
{
GUILayout.Label("(" + activityLevel + ")");
}
else
{
GUILayout.Label(new GUIContent(uiResources.texIconsActivityLevels[activityLevel], activityLevel.ToString()));
}
}
public UserInfoModel GetUserInformation()
{
int age = 0;
int height = 0;
decimal weight = 0;
Gender gender = default(Gender);
ActivityLevel activityLevel = default(ActivityLevel);
age = Settings.GetValueOrDefault(USER_AGE, age);
height = Settings.GetValueOrDefault(USER_HEIGHT, height);
weight = Settings.GetValueOrDefault(USER_WEIGHT, weight);
gender = (Gender)Settings.GetValueOrDefault(USER_GENDER, (int)gender);
activityLevel = (ActivityLevel)Settings.GetValueOrDefault(USER_ACTIVITY, (int)activityLevel);
return(new UserInfoModel(age, height, weight, gender, activityLevel));
}
public override void OnAwake()
{
this.Log_DebugOnly("Awake", "Part[{0}] strActivityLevel[{1}]", this.name, this.strActivityLevel);
activityLevel = ActivityLevel.COMFY;
if (strActivityLevel != null)
{
try
{
activityLevel = (ActivityLevel)Enum.Parse(typeof(ActivityLevel), strActivityLevel);
}
catch (ArgumentException)
{
this.Log_DebugOnly("Awake", "Part[{0}] strActivityLevel[{1}] is not a valid ActivityLevel", this.name, this.strActivityLevel);
}
}
}
private void initActivityLevel()
{
if (activityLevel == ActivityLevel.UNKNOWN)
{
activityLevel = ActivityLevel.COMFY;
if (strActivityLevel != null)
{
try
{
activityLevel = (ActivityLevel)Enum.Parse(typeof(ActivityLevel), strActivityLevel);
}
catch (ArgumentException)
{
this.Log_DebugOnly("initActivityLevel", "Part[{0}] strActivityLevel[{1}] is not a valid ActivityLevel", this.name, this.strActivityLevel);
}
}
}
}
private void initActivityLevel()
{
if (activityLevel == ActivityLevel.UNKNOWN)
{
activityLevel = ActivityLevel.COMFY;
if (strActivityLevel != null)
{
try
{
activityLevel = (ActivityLevel)Enum.Parse(typeof(ActivityLevel), strActivityLevel);
}
catch (ArgumentException)
{
this.Log_DebugOnly("initActivityLevel", "Part[{0}] strActivityLevel[{1}] is not a valid ActivityLevel", this.name, this.strActivityLevel);
}
}
}
}
private void refreshLoadedVesselRoster(Dictionary <string, KeepFitCrewMember> roster,
KeepFitVesselRecord vesselRecord,
Vessel vessel)
{
foreach (Part part in vessel.Parts)
{
if (part.CrewCapacity == 0)
{
continue;
}
bool hasSeat = false;
bool hasCommandModule = false;
ActivityLevel partActivityLevel = getDefaultActivityLevel(vessel);
foreach (PartModule module in part.Modules)
{
if (module is KerbalSeat)
{
hasSeat = true;
}
else if (module is ModuleCommand)
{
hasCommandModule = true;
}
else if (module is KeepFitPartModule)
{
KeepFitPartModule keepFitPartModule = (KeepFitPartModule)module;
if (keepFitPartModule.activityLevel > partActivityLevel)
{
partActivityLevel = keepFitPartModule.activityLevel;
}
}
}
foreach (ProtoCrewMember partCrewMember in part.protoModuleCrew)
{
updateRosters(roster, vesselRecord, partCrewMember.name, partActivityLevel, true);
}
}
}
private Color GetActivityColor(ActivityLevel activity)
{
Color c = cNone.Color;
switch (activity)
{
case ActivityLevel.Low:
c = cLow.Color;
break;
case ActivityLevel.Average:
c = cAverage.Color;
break;
case ActivityLevel.High:
c = cHigh.Color;
break;
case ActivityLevel.Great:
c = cGreat.Color;
break;
}
return c;
}
//BMR
//If you are sedentary(little or no exercise) : Calorie-Calculation = BMR x 1.2
//If you are lightly active(light exercise/sports 1-3 days/week) : Calorie-Calculation = BMR x 1.375
//If you are moderatetely active(moderate exercise/sports 3-5 days/week) : Calorie-Calculation = BMR x 1.55
//If you are very active(hard exercise/sports 6-7 days a week) : Calorie-Calculation = BMR x 1.725
//If you are extra active(very hard exercise/sports & physical job or 2x training) : Calorie-Calculation = BMR x 1.9
public decimal GetDailyCaloriesEstimation(decimal bmr, ActivityLevel activityFactor)
{
switch (activityFactor)
{
case ActivityLevel.Sedentary:
return(bmr * 1.2m);
case ActivityLevel.LightlyActive:
return(bmr * 1.375m);
case ActivityLevel.ModeratetelyActive:
return(bmr * 1.55m);
case ActivityLevel.VeryActive:
return(bmr * 1.725m);
case ActivityLevel.ExtraActive:
return(bmr * 1.9m);
default: return(0);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="model">The model used for calculations</param>
public ActivityLevelsCalculator(CsvModel model)
{
this.model = model;
this.activityValueSupported = this.model.SupportedValues.Contains(SensorData.Activity);
this.vmuValueSupported = this.model.SupportedValues.Contains(SensorData.Vmu);
// set array of activity levels depending of the enum
this.activityLevels = new ActivityLevel[Enum.GetNames(typeof(ActivityLevels)).Length];
// set structures and set them to zero.
int position = 0;
foreach (ActivityLevels level in Enum.GetValues(typeof(ActivityLevels)))
{
ActivityLevel l = new ActivityLevel();
l.Level = level;
l.Count = 0;
l.Percent = 0.0;
this.activityLevels[position] = l;
position++;
}
}
private KeepFitCrewMember updateRosters(Dictionary <string, KeepFitCrewMember> roster,
KeepFitVesselRecord vessel,
string name,
ActivityLevel activityLevel,
bool activityLevelReliable)
{
this.Log_DebugOnly("updateRosters", "updating crewMember[{0}] activityLevel[{1}]]", name, activityLevel);
KeepFitCrewMember keepFitCrewMember = null;
roster.TryGetValue(name, out keepFitCrewMember);
if (keepFitCrewMember != null)
{
this.Log_DebugOnly("updateRosters", "crewMember[{0}] was in the old roster", name);
}
else
{
this.Log_DebugOnly("updateRosters", "crewMember[{0}] wasn't in the old roster", name);
// not in the old roster - add him to the new one ...
keepFitCrewMember = new KeepFitCrewMember(name, false);
keepFitCrewMember.fitnessLevel = gameConfig.initialFitnessLevel;
keepFitCrewMember.activityLevel = activityLevel;
roster[name] = keepFitCrewMember;
}
if (activityLevelReliable)
{
keepFitCrewMember.activityLevel = activityLevel;
}
vessel.crew[name] = keepFitCrewMember;
this.Log_DebugOnly("updateRosters", "crewMan[{0}] activityLevel[{1}]", name, activityLevel);
return(keepFitCrewMember);
}
private Color GetActivityColor(ActivityLevel activity)
{
Color c = cNone.Color;
switch (activity)
{
case ActivityLevel.Low:
c = cLow.Color;
break;
case ActivityLevel.Average:
c = cAverage.Color;
break;
case ActivityLevel.High:
c = cHigh.Color;
break;
case ActivityLevel.Great:
c = cGreat.Color;
break;
}
return(c);
}
private float getFitnessModifier(ActivityLevel activityLevel, float elapsedSeconds)
{
float secondsPerDay = 60 * 60 * 24;
float fitnessModifier;
switch (activityLevel)
{
case ActivityLevel.CRAMPED:
// cramped - fitness goes down 5% per day by default
fitnessModifier = (gameConfig.degradationWhenCramped * elapsedSeconds) / secondsPerDay;
break;
case ActivityLevel.COMFY:
// comfy - fitness goes down 1% per day by defaultt@
fitnessModifier = (gameConfig.degradationWhenComfy * elapsedSeconds) / secondsPerDay;
break;
case ActivityLevel.NEUTRAL:
// neutral - fitness is static by default
fitnessModifier = (gameConfig.degradationWhenNeutral * elapsedSeconds) / secondsPerDay;
break;
case ActivityLevel.EXERCISING:
// exercising - fitness goes up 1% per day by default
fitnessModifier = (gameConfig.degradationWhenExercising * elapsedSeconds) / secondsPerDay;
break;
default:
// how did we even get here?
fitnessModifier = 0;
break;
}
return(fitnessModifier);
}
public virtual IQueryable <TEntity> GetQuery <TEntity>(ActivityLevel level = ActivityLevel.Active)
where TEntity : Entity
{
var query = _context.Set <TEntity>().Where(x => !x.DeletedAt.HasValue);
if (level != ActivityLevel.All)
{
query = level == ActivityLevel.Active ? query.Where(x => x.IsActive) : query.Where(x => !x.IsActive);
}
if (EntityShouldBeFilteredByUser <TEntity>())
{
query = FilterByUser(query);
return(query);
}
if (EntityShouldBeFilteredByTenant <TEntity>())
{
query = FilterByTenant(query);
}
return(query);
}
private double GetActivityLevelValue(ActivityLevel level)
{
var value = 0.0;
switch (level)
{
case ActivityLevel.Sedentary:
value = 1.2;
break;
case ActivityLevel.Slightly_Active:
value = 1.4;
break;
case ActivityLevel.Moderately_Active:
value = 1.6;
break;
case ActivityLevel.Very_Active:
value = 1.75;
break;
case ActivityLevel.Extra_Active:
value = 2;
break;
case ActivityLevel.Professional_Athlete:
value = 2.3;
break;
default:
break;
}
return(value);
}
/// <summary>
/// Set ActivityLevel field</summary>
/// <param name="activityLevel_">Nullable field value to be set</param>
public void SetActivityLevel(ActivityLevel? activityLevel_)
{
SetFieldValue(7, 0, activityLevel_, Fit.SubfieldIndexMainField);
}
//Activity Level
public void updateActivityLevel(ActivityLevel level)
{
bool changed = false;
lock (activityLevelLock)
{
switch (level)
{
case ActivityLevel.IN_GAME:
lastInGameActivityTime = parent.currentMillisecond;
currentVessel = Guid.Empty;
break;
case ActivityLevel.IN_FLIGHT:
lastInFlightActivityTime = parent.currentMillisecond;
lastInGameActivityTime = parent.currentMillisecond;
break;
}
if (level > activityLevel)
{
activityLevel = level;
changed = true;
}
}
if (changed)
parent.clientActivityLevelChanged(this);
}
public void resetProperties()
{
username = "";
screenshot = null;
watchPlayerName = String.Empty;
receivedHandshake = false;
sharedCraftFile = null;
sharedCraftName = String.Empty;
sharedCraftType = 0;
lastUDPACKTime = 0;
queuedOutMessages = new ConcurrentQueue<byte[]>();
lock (activityLevelLock)
{
activityLevel = Client.ActivityLevel.INACTIVE;
lastInGameActivityTime = parent.currentMillisecond;
lastInFlightActivityTime = parent.currentMillisecond;
}
lock (timestampLock)
{
lastReceiveTime = parent.currentMillisecond;
connectionStartTime = parent.currentMillisecond;
lastSyncTime = parent.currentMillisecond;
}
}
internal ActivityLevelFloatValue(ActivityLevel level, float time)
{
this.level = level;
this.time = time;
}
public FloatAndActivityLevel(ActivityLevel level, float value)
{
this.level = level;
this.value = value;
}
private float getFitnessModifier(ActivityLevel activityLevel, float elapsedSeconds)
{
float secondsPerDay = 60 * 60 * 24;
float fitnessModifier;
switch (activityLevel)
{
case ActivityLevel.CRAMPED:
// cramped - fitness goes down 5% per day by default
fitnessModifier = (gameConfig.degradationWhenCramped * elapsedSeconds) / secondsPerDay;
break;
case ActivityLevel.COMFY:
// comfy - fitness goes down 1% per day by defaultt@
fitnessModifier = (gameConfig.degradationWhenComfy * elapsedSeconds) / secondsPerDay;
break;
case ActivityLevel.NEUTRAL:
// neutral - fitness is static by default
fitnessModifier = (gameConfig.degradationWhenNeutral * elapsedSeconds) / secondsPerDay;
break;
case ActivityLevel.EXERCISING:
// exercising - fitness goes up 1% per day by default
fitnessModifier = (gameConfig.degradationWhenExercising * elapsedSeconds) / secondsPerDay;
break;
default:
// how did we even get here?
fitnessModifier = 0;
break;
}
return fitnessModifier;
}
private KeepFitCrewMember updateRosters(Dictionary<string, KeepFitCrewMember> roster,
KeepFitVesselRecord vessel,
string name,
ActivityLevel activityLevel,
bool activityLevelReliable)
{
this.Log_DebugOnly("updateRosters", "updating crewMember[{0}] activityLevel[{1}]]", name, activityLevel);
KeepFitCrewMember keepFitCrewMember = null;
roster.TryGetValue(name, out keepFitCrewMember);
if (keepFitCrewMember != null)
{
this.Log_DebugOnly("updateRosters", "crewMember[{0}] was in the old roster", name);
}
else
{
this.Log_DebugOnly("updateRosters", "crewMember[{0}] wasn't in the old roster", name);
// not in the old roster - add him to the new one ...
keepFitCrewMember = new KeepFitCrewMember(name, false);
keepFitCrewMember.fitnessLevel = gameConfig.initialFitnessLevel;
keepFitCrewMember.activityLevel = activityLevel;
roster[name] = keepFitCrewMember;
}
if (activityLevelReliable)
{
keepFitCrewMember.activityLevel = activityLevel;
}
vessel.crew[name] = keepFitCrewMember;
this.Log_DebugOnly("updateRosters", "crewMan[{0}] activityLevel[{1}]", name, activityLevel);
return keepFitCrewMember;
}
public void resetProperties()
{
username = "******";
screenshots = new Screenshot[parent.settings.screenshotBacklog];
watchPlayerName = String.Empty;
watchPlayerIndex = 0;
canBeReplaced = false;
receivedHandshake = false;
sharedCraftFile = null;
sharedCraftName = String.Empty;
sharedCraftType = 0;
throttleState.reset();
lastUDPACKTime = 0;
queuedOutMessages = new ConcurrentQueue<byte[]>();
lock (activityLevelLock)
{
activityLevel = ServerClient.ActivityLevel.INACTIVE;
lastInGameActivityTime = parent.currentMillisecond;
lastInFlightActivityTime = parent.currentMillisecond;
}
lock (timestampLock)
{
lastReceiveTime = parent.currentMillisecond;
connectionStartTime = parent.currentMillisecond;
}
}
