public void Init(WorkoutPanel workoutPanel, bool isCreatingNewWorkout, bool shouldAutoSelectInputField)
{
currentWorkoutPanel = workoutPanel;
WorkoutData workoutToEdit = workoutPanel.workoutData;
currentWorkoutData = workoutToEdit;
_workoutNameInputField.text = workoutToEdit.name;
Show();
if (workoutIconShower != null)
{
workoutIconShower.Init(workoutToEdit.workoutType);
}
this.isCreatingNewWorkout = isCreatingNewWorkout;
if (shouldAutoSelectInputField)
{
_workoutNameInputField.Select();
}
_secondsBetweenExercisesInputField.text = workoutToEdit.secondsBetweenExercises.ToString();
if (workoutToEdit.hasTenSecTimer)
{
_tenSecSlider.value = 0;
}
else
{
_tenSecSlider.value = 1;
}
}
public void AddWorkoutFromPlanPanel()
{
WorkoutData copiedWorkout = new WorkoutData();
copiedWorkout.name = workoutData.name;
copiedWorkout.workoutType = workoutData.workoutType;
copiedWorkout.secondsBetweenExercises = workoutData.secondsBetweenExercises;
copiedWorkout.exerciseData = new List <ExerciseData> ();
foreach (ExerciseData exercise in workoutData.exerciseData)
{
ExerciseData copiedExercise = ExerciseData.Copy(
exercise.name,
exercise.secondsToCompleteSet,
exercise.totalInitialSets,
exercise.totalSets,
exercise.repsPerSet,
exercise.weight,
exercise.exerciseType
);
copiedWorkout.exerciseData.Add(copiedExercise);
}
WorkoutHUD.Instance.AddWorkoutPanel(copiedWorkout, false);
WorkoutManager.Instance.Save();
}
public void EstablishPlayOrEndButton()
{
WorkoutData activeWorkout = WorkoutManager.Instance.ActiveWorkout;
bool inProgress = false;
foreach (ExerciseData exercise in activeWorkout.exerciseData)
{
if (exercise.totalSets < exercise.totalInitialSets)
{
inProgress = true;
}
}
if (inProgress == true)
{
_startWorkoutButton.gameObject.SetActive(false);
_stopWorkoutButton.gameObject.SetActive(true);
}
else
{
_startWorkoutButton.gameObject.SetActive(true);
_stopWorkoutButton.gameObject.SetActive(false);
}
}
void CreateWorkoutPanel()
{
WorkoutData copiedWorkout = new WorkoutData();
copiedWorkout.name = currentWorkoutData.name;
copiedWorkout.workoutType = currentWorkoutData.workoutType;
copiedWorkout.secondsBetweenExercises = currentWorkoutData.secondsBetweenExercises;
copiedWorkout.exerciseData = new List <ExerciseData> ();
foreach (ExerciseData exercise in copiedWorkout.exerciseData)
{
ExerciseData copiedExercise = ExerciseData.Copy(
exercise.name,
exercise.secondsToCompleteSet,
exercise.totalInitialSets,
exercise.totalSets,
exercise.repsPerSet,
exercise.weight,
exercise.exerciseType
);
copiedWorkout.exerciseData.Add(copiedExercise);
}
WorkoutHUD.Instance.AddWorkoutPanel(copiedWorkout, false);
SoundManager.Instance.PlayButtonPressSound();
WorkoutManager.Instance.Save();
Hide();
Canvas.ForceUpdateCanvases();
WorkoutHUD.Instance.workoutsScrollRect.verticalScrollbar.value = 0f;
Canvas.ForceUpdateCanvases();
}
public WorkoutPanel AddWorkoutPanel(WorkoutData workoutData, bool isFromButton)
{
WorkoutPanel newWorkoutPanel = Instantiate(WorkoutMenuItemPrefab);
if (workoutData != null)
{
newWorkoutPanel.workoutData = workoutData;
}
if (isFromButton)
{
workoutData = new WorkoutData();
workoutData.exerciseData = new List <ExerciseData> ();
workoutData.minutes = 0;
workoutData.workoutType = WorkoutType._singleDumbell;
}
newWorkoutPanel.Init(workoutData);
newWorkoutPanel.transform.SetParent(workoutPanelsGridLayoutGroup.transform);
newWorkoutPanel.transform.localScale = Vector3.one;
if (isFromButton)
{
newWorkoutPanel.SelectTitle();
}
return(newWorkoutPanel);
}
public static WorkoutData Copy(WorkoutData workoutDataToCopy)
{
WorkoutData copiedWorkout = new WorkoutData();
copiedWorkout.name = workoutDataToCopy.name;
copiedWorkout.workoutType = workoutDataToCopy.workoutType;
copiedWorkout.secondsBetweenExercises = workoutDataToCopy.secondsBetweenExercises;
copiedWorkout.hasTenSecTimer = workoutDataToCopy.hasTenSecTimer;
copiedWorkout.exerciseData = new List <ExerciseData> ();
foreach (ExerciseData exercise in workoutDataToCopy.exerciseData)
{
ExerciseData copiedExercise = ExerciseData.Copy(
exercise.name,
exercise.secondsToCompleteSet,
exercise.totalInitialSets,
exercise.totalSets,
exercise.repsPerSet,
exercise.weight,
exercise.exerciseType
);
copiedWorkout.exerciseData.Add(copiedExercise);
}
return(copiedWorkout);
}
public ExerciseMenuItem AddExercisePanel(WorkoutData workoutData, ExerciseData exerciseData, bool isFromButton)
{
ExerciseMenuItem newExerciseMenuItem = Instantiate(_exerciseMenuItemPrefab);
if (workoutData != null)
{
exerciseData = new ExerciseData();
workoutData.exerciseData.Add(exerciseData);
}
if (isFromButton)
{
exerciseData.totalSets = 3;
exerciseData.totalInitialSets = 3;
exerciseData.repsPerSet = 10;
exerciseData.secondsToCompleteSet = 60;
}
if (exerciseData != null)
{
newExerciseMenuItem.Init(exerciseData);
}
if (isFromButton)
{
newExerciseMenuItem.SelectTitle();
Header.Instance.SetUpForExercisesMenu(WorkoutManager.Instance.ActiveWorkout);
}
newExerciseMenuItem.transform.SetParent(exercisePanelsGridLayoutGroup.transform);
newExerciseMenuItem.transform.localScale = Vector3.one;
return(newExerciseMenuItem);
}
void AddCustom()
{
if (_isForWorkouts)
{
WorkoutData emptyWorkoutData = new WorkoutData();
emptyWorkoutData.name = "New Workout";
EditWorkoutPanel.Instance.Init(emptyWorkoutData, true, false);
}
else
{
//WorkoutHUD.Instance.AddExercisePanel(WorkoutManager.Instance.ActiveWorkout, null, true);
ExerciseData emptyExerciseData = new ExerciseData();
emptyExerciseData.name = "New Exercise";
emptyExerciseData.totalInitialSets = 3;
emptyExerciseData.totalSets = 3;
emptyExerciseData.repsPerSet = 10;
emptyExerciseData.weight = 0;
emptyExerciseData.secondsToCompleteSet = 90;
EditExercisePanel.Instance.Init(emptyExerciseData, true, true);
}
Exit();
Canvas.ForceUpdateCanvases();
WorkoutHUD.Instance.workoutsScrollRect.verticalScrollbar.value = 0f;
Canvas.ForceUpdateCanvases();
}
public void Init(WorkoutData workoutData)
{
this.workoutData = workoutData;
UpdateColor();
fitBoyIlluminator.Init(workoutData.workoutType);
UpdateText();
}
public PlanInfo(WorkoutData data, string id, Color color)
{
Title = String.Format("{0} (Week {1}, Day {2})", data.Title, data.Week, data.Day);
Exercises = "";
Id = id;
FieldColor = color;
if (!data.IsNull)
{
Exercises = string.Join(", ", data.Exercises.Select(t => t.Name));
ExerciseDetails = new List <DetailedInfo>();
for (int i = 0; i < data.WorkoutMatrix[0].Length; i++)
{
if (data.WorkoutMatrix[5][i] == 0)
{
var info = new DetailedInfo();
info.ExName = data.Exercises[data.WorkoutMatrix[0][i]].Name;
string repText = data.RepText[data.WorkoutMatrix[1][i]];
var reps = data.Reps[data.WorkoutMatrix[2][i]];
if (repText[0] == '-')
{
repText = String.Format("Max Reps -{0}", reps);
}
else if (repText[0] == '%')
{
repText = String.Format("{0}% of Max Reps", reps);
}
info.RepText = repText;
ExerciseDetails.Add(info);
}
}
}
}
/// <summary>
/// Initializes class instance.
/// </summary>
public DetailsPageViewModel()
{
_workoutModel = WorkoutModel.Instance;
_workoutModel.FinishWorkout();
WorkoutData workoutData = _workoutModel.WorkoutData;
HeaderData = new DetailsHeaderData
{
StartTime = workoutData.StartTime,
LocalTime = workoutData.LocalTime,
Title = "Workout\ndetails"
};
int[] bpmRangeOccurrences = workoutData.BpmRangeOccurrences;
ElapsedTime = string.Format("{0:hh\\.mm\\\'ss}", workoutData.ElapsedTime);
Distance = (workoutData.Distance / 1000).ToString("F2") + " " + SettingsService.Instance.Distance.Unit;
AveragePace = workoutData.Pace.ToString("F2") + " min/" + SettingsService.Instance.Distance.Unit;
Intensity = Array.LastIndexOf(bpmRangeOccurrences, bpmRangeOccurrences.Max()).ToString();
InitCommands();
AddEventListeners();
}
public async Task <IActionResult> PutWorkoutData(int id, WorkoutData workoutData)
{
if (id != workoutData.ID)
{
return(BadRequest());
}
_context.Entry(workoutData).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkoutDataExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(int id, [Bind("ID,WorkoutTime,WorkoutName,WorkoutWeight,WorkoutReps,WorkoutSets")] WorkoutData workoutData)
{
if (id != workoutData.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(workoutData);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkoutDataExists(workoutData.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(workoutData));
}
public void Init(WorkoutPlayerController controller, WorkoutData workout)
{
_controller = controller;
DetermineETA(workout);
_etaText.color = ColorManager.Instance.ActiveColorLight;
_batteryText.color = ColorManager.Instance.ActiveColorLight;
_timeText.color = ColorManager.Instance.ActiveColorLight;
}
void Awake()
{
planData.planDifficulty = PlanDifficulty.easy;
planData.name = "Beginner";
planData.description = "Dumbells required.";
planData.workoutData.Add(WorkoutData.Copy(homeGymBeginnerPush.GetWorkoutData()));
planData.workoutData.Add(WorkoutData.Copy(homeGymBeginnerPull.GetWorkoutData()));
planData.workoutData.Add(WorkoutData.Copy(homeGymBeginnerLegs.GetWorkoutData()));
}
public async Task <ActionResult <WorkoutData> > PostWorkoutData(WorkoutData workoutData)
{
_context.Workouts.Add(workoutData);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetWorkoutData", new { id = workoutData.ID }, workoutData));
}
public WorkoutData DeepCopy(WorkoutData data)
{
WorkoutData newData = new WorkoutData();
newData.Name = data.Name;
newData.Description = data.Description;
newData.Type = data.Type;
newData.ExerciseArray = data.ExerciseArray;
return(newData);
}
void Awake()
{
planData.planDifficulty = PlanDifficulty.medium;
planData.name = "Intermediate";
planData.description = "Dumbells, Bench, Pull-Up Bar required";
planData.workoutData.Add(WorkoutData.Copy(homeGymIntermediateChestTriceps.GetWorkoutData()));
planData.workoutData.Add(WorkoutData.Copy(homeGymIntermediateBackBiceps.GetWorkoutData()));
planData.workoutData.Add(WorkoutData.Copy(homeGymIntermediateLegs.GetWorkoutData()));
planData.workoutData.Add(WorkoutData.Copy(homeGymIntermediateShoulders.GetWorkoutData()));
}
public void SetUpForExercisesMenu(WorkoutData workoutData)
{
if (string.IsNullOrEmpty(workoutData.name))
{
UpdateMiddleLabel("Enter workout name");
}
else
{
_middleLabel.text = workoutData.name;
}
}
void Awake()
{
planData.planDifficulty = PlanDifficulty.hard;
planData.name = "Advanced";
planData.description = "Dumbells, Bench, Pull-Up Bar, Dips Bar, Barbell required";
planData.workoutData.Add(WorkoutData.Copy(gymAdvancedChestTriceps.GetWorkoutData()));
planData.workoutData.Add(WorkoutData.Copy(gymAdvancedBackBiceps.GetWorkoutData()));
planData.workoutData.Add(WorkoutData.Copy(gymAdvancedLegs.GetWorkoutData()));
planData.workoutData.Add(WorkoutData.Copy(gymAdvancedShoulders.GetWorkoutData()));
planData.workoutData.Add(WorkoutData.Copy(gymAdvancedCoreAndMore.GetWorkoutData()));
}
public async Task <IActionResult> Create([Bind("ID,WorkoutTime,WorkoutName,WorkoutWeight,WorkoutReps,WorkoutSets")] WorkoutData workoutData)
{
if (ModelState.IsValid)
{
_context.Add(workoutData);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(workoutData));
}
public void Init()
{
Initialize = false;
CurrentWorkout = new WorkoutData();
CurrentWorkout.Name = "";
CurrentWorkout.Description = "";
CurrentWorkout.Type = "";
CurrentWorkout.ExerciseArray = new SaveExerciseData();
TextName.GetComponent <InputField>().text = CurrentWorkout.Name;
TextDescription.GetComponent <InputField>().text = CurrentWorkout.Description;
}
public void Init(WorkoutPlayerController controller, WorkoutData workout)
{
_controller = controller;
DetermineCompletionValue(workout);
DetermineMinutesRemaining(workout);
DetermineETA(workout);
_completionValue.color = ColorManager.Instance.ActiveColorLight;
_etaValue.color = ColorManager.Instance.ActiveColorLight;
_timeLeftValue.color = ColorManager.Instance.ActiveColorLight;
_completionLabel.color = ColorManager.Instance.ActiveColorLight;
_etaLabel.color = ColorManager.Instance.ActiveColorLight;
_timeLeftLabel.color = ColorManager.Instance.ActiveColorLight;
}
public static void SaveWorkout(WorkoutData data)
{
var oldProgress = LoadProgress();
WorkoutData[] newProgress = new WorkoutData[oldProgress.Length + 1];
for (int i = 0; i < oldProgress.Length; i++)
{
newProgress[i] = oldProgress[i];
}
data.Completion = DateTime.Now.ToBinary();
newProgress[oldProgress.Length] = data;
SaveProgress(newProgress);
}
public void Init()
{
Initialize = false;
BackgroundTimer.Start();
CurrentWorkout = new WorkoutData();
CurrentWorkout.Name = "";
CurrentWorkout.Description = "";
// CurrentWorkout.ExerciseArray = new List<ExerciseData>();
CurrentWorkout.ExerciseArray = new SaveExerciseData();
// UserExerciseData = UserBlobManager.GetComponent<UserBlobManager>().UserExerciseData;
// UserWorkoutData = UserBlobManager.GetComponent<UserBlobManager>().UserWorkoutData;
int CurrentWorkoutIndex = UserBlobManager.GetComponent <UserBlobManager>().CurrentWorkoutIndex;
CurrentWorkout.Name = UserBlobManager.GetComponent <UserBlobManager> ().UserWorkoutData.Workout[CurrentWorkoutIndex].Name;
CurrentWorkout.Description = UserBlobManager.GetComponent <UserBlobManager> ().UserWorkoutData.Workout[CurrentWorkoutIndex].Description;
CurrentWorkout.Type = UserBlobManager.GetComponent <UserBlobManager>().UserWorkoutData.Workout[CurrentWorkoutIndex].Type;
// CurrentWorkout.ExerciseArray = new List<ExerciseData>(UserBlobManager.GetComponent<UserBlobManager> ().UserWorkoutData.Workout[CurrentWorkoutIndex].ExerciseArray);
CurrentWorkout.ExerciseArray = (UserBlobManager.GetComponent <UserBlobManager> ().UserWorkoutData.Workout[CurrentWorkoutIndex].ExerciseArray);
UIText_WorkoutName.GetComponent <Text> ().text = CurrentWorkout.Name;
SelectedExercise = 0;
SelectedWorkoutExcercise = 0;
ClearExerciseScrollList();
PopulateExerciseScrollList();
ClearWorkoutScrollList();
PopulateWorkoutScrollList();
if (CurrentWorkout.ExerciseArray.Exercise.Length > 6)
{
SetScrollRectPositionFromIntWithOffset(0, 2.6, 100, CurrentWorkout.ExerciseArray.Exercise.Length, WorkoutContentPanel);
}
else
{
WorkoutContentPanel.localPosition = new Vector3(0, 0, 0);
}
if (UserBlobManager.GetComponent <UserBlobManager> ().UserExerciseData.Exercise.Length > 8)
{
SetScrollRectPositionFromIntWithOffset(0, 2.6, 100, NumFilteredExercises, ExerciseContentPanel);
}
else
{
ExerciseContentPanel.localPosition = new Vector3(0, 0, 0);
}
}
void AddWorkoutPanel(WorkoutData workoutData)
{
WorkoutPanel newWorkoutPanel = Instantiate(WorkoutPanelPrefab);
if (workoutData != null)
{
newWorkoutPanel.workoutData = workoutData;
}
newWorkoutPanel.UpdateText();
newWorkoutPanel.transform.SetParent(workoutPanelsGridLayoutGroup.transform);
newWorkoutPanel.transform.localScale = Vector3.one;
}
public void Init(WorkoutData workout, int currentIndex)
{
TryClear();
foreach (ExerciseData exercise in workout.exerciseData)
{
SmartCarouselItem newCarouselItem = CreateCarouselItem(exercise);
_carouselItems.Add(newCarouselItem);
}
_centermostCarouselItem = _carouselItems[0];
StartCoroutine(TweenToItemByIndexCo(currentIndex));
}
public void ShowExercisesForWorkout(WorkoutData workoutToOpen)
{
Header.Instance.SetUpForExercisesMenu();
addWorkoutPanelButton.transform.localScale = Vector3.zero;
addExercisePanelButton.transform.localScale = Vector3.one;
workoutPanelsGridLayoutGroup.transform.localScale = Vector3.zero;
exercisePanelsGridLayoutGroup.transform.localScale = Vector3.one;
foreach (ExerciseData exercise in workoutToOpen.exerciseData)
{
AddExercisePanel(null, exercise);
}
}
public void GenerateRandomWorkout()
{
WorkoutPanel[] workoutPanels = FindObjectsOfType <WorkoutPanel>();
if (workoutPanels != null)
{
foreach (WorkoutPanel workoutPanel in workoutPanels)
{
if (workoutPanel.workoutData.workoutType == WorkoutType.wod)
{
AreYouSurePanel.Instance.DeleteWorkout(workoutPanel);
}
}
}
DetermineViableExercises();
randomWorkout = new WorkoutData();
string newWorkoutName = "W.O.D. " + DateTime.Now.Month + "/" + DateTime.Now.Day;
randomWorkout.name = randomWorkout.name = newWorkoutName;
randomWorkout.workoutType = WorkoutType.wod;
randomWorkout.secondsBetweenExercises = secondsBetweenExercises;
randomWorkout.exerciseData = new List <ExerciseData>();
while (randomWorkout.minutes < desiredMinutesInWorkout - 3)
{
bool foundExercise = false;
while (!foundExercise)
{
int randomExerciseIndex = UnityEngine.Random.Range(0, viableExercises.Count);
if (randomWorkout.exerciseData.Contains(viableExercises[randomExerciseIndex]))
{
foundExercise = false;
//return;
}
else
{
randomWorkout.exerciseData.Add(viableExercises[randomExerciseIndex]);
randomWorkout.EstablishMinutes();
foundExercise = true;
}
}
}
//Add randomWorkout to app
WorkoutHUD.Instance.AddWorkoutPanel(randomWorkout, false);
SoundManager.Instance.PlayButtonPressSound();
WorkoutManager.Instance.Save();
}
/// <summary>
/// Initializes class instance.
/// </summary>
public DetailsPageViewModel()
{
_workoutModel = WorkoutModel.Instance;
_workoutModel.FinishWorkout();
WorkoutData workoutData = _workoutModel.WorkoutData;
HeaderData = new DetailsHeaderData
{
StartTime = workoutData.StartTime,
LocalTime = workoutData.LocalTime,
Title = "Workout\ndetails"
};
int[] bpmRangeOccurrences = workoutData.BpmRangeOccurrences;
ItemsData = new List <DetailsItemData>
{
new DetailsItemData
{
Name = "time",
Value = string.Format("{0:hh\\.mm\\\'ss}", workoutData.ElapsedTime),
Icon = "images/details_time_icon.png"
},
new DetailsItemData
{
Name = "distance",
Value = (workoutData.Distance / 1000).ToString("F2") + " " + SettingsService.Instance.Distance.Unit,
Icon = "images/details_distance_icon.png"
},
new DetailsItemData
{
Name = "average pace",
Value = workoutData.Pace.ToString("F2") + " min/" + SettingsService.Instance.Distance.Unit,
Icon = "images/details_average_pace_icon.png"
},
new DetailsItemData
{
Name = "intensity",
Value = Array.LastIndexOf(bpmRangeOccurrences, bpmRangeOccurrences.Max()).ToString(),
Icon = "images/details_intensity_icon.png",
IsActionButtonVisible = true
}
};
InitCommands();
AddEventListeners();
}
