public void SetUpDNADelegates(UMAData umaData)
{
targetAvatar.RecipeUpdated.RemoveListener(SetUpDNADelegates);
if (umaData.umaRecipe.raceData)
{
lastRace = umaData.umaRecipe.raceData;
foreach (IDNAConverter dcb in umaData.umaRecipe.raceData.dnaConverterList)
{
if (dcb.GetType() == typeof(DynamicDNAConverterBehaviour) || dcb.GetType() == typeof(DynamicDNAConverterController))
{
if (dcb.GetType() == typeof(DynamicDNAConverterBehaviour))
{
(dcb as DynamicDNAConverterBehaviour).AddDnaCallbackDelegate(ChangeCharacterRedness, "skinRedness");
(dcb as DynamicDNAConverterBehaviour).AddDnaCallbackDelegate(ChangeCharacterGreenness, "skinGreenness");
(dcb as DynamicDNAConverterBehaviour).AddDnaCallbackDelegate(ChangeCharacterBlueness, "skinBlueness");
}
else
{
(dcb as DynamicDNAConverterController).AddDnaCallbackDelegate(ChangeCharacterRedness, "skinRedness");
(dcb as DynamicDNAConverterController).AddDnaCallbackDelegate(ChangeCharacterGreenness, "skinGreenness");
(dcb as DynamicDNAConverterController).AddDnaCallbackDelegate(ChangeCharacterBlueness, "skinBlueness");
}
}
}
if (delegateDNAEditor)
{
delegateDNAEditor.Initialize(targetAvatar);
}
startingSkinColor = new Color(targetAvatar.GetColor("Skin").color.r, targetAvatar.GetColor("Skin").color.g, targetAvatar.GetColor("Skin").color.b);
}
}
private async Task BuildRaceTraceAsync(int year, int round)
{
try
{
_dataIsLoadingObserver.UpdateIsLoading(true);
var driverTask = _driverService.GetDriversForRaceAsync(year, round);
var lapTimesForDriversTask = GetLapTimesForDriversAsync(year, round);
await Task.WhenAll(driverTask, lapTimesForDriversTask);
_driverCollection = driverTask.Result;
var lapTimesForDrivers = lapTimesForDriversTask.Result;
_driveTeamLookup = _driverCollection.ToDictionary(key => key.DriverCode, value => value.Team);
_raceData = CreateRaceDataCollection(lapTimesForDrivers);
var referenceTime = CalculateReferenceTime(_driverCollection, _raceData);
_dataIsLoadingObserver.UpdateIsLoading(false);
CalculateRaceTrace(referenceTime);
}
catch (Exception ex)
{
var errorOccurrence = new ErrorOccurrence("Calculating race trace.", ex);
_dataIsLoadingObserver.ErrorOccured(errorOccurrence);
}
}
RaceData GetEditorAddedAsset(int?raceHash = null, string raceName = "")
{
RaceData foundRaceData = null;
if (editorAddedAssets.Count > 0)
{
foreach (RaceData edRace in editorAddedAssets)
{
if (edRace != null)
{
if (raceHash != null)
{
if (UMAUtils.StringToHash(edRace.raceName) == raceHash)
{
foundRaceData = edRace;
}
}
else if (raceName != null)
{
if (raceName != "")
{
if (edRace.raceName == raceName)
{
foundRaceData = edRace;
}
}
}
}
}
}
return(foundRaceData);
}
public RaceDataItemViewModel(RaceData raceData, DateTime?startTime)
{
this.RaceData = raceData;
this.TotalTime = startTime == null
? new DateTime(0)
: new DateTime((raceData.TimeStamp - (DateTime)startTime).Ticks);
}
private void AddRaceDataAsset(RaceData raceDataAsset, List <string> compatibleRaces)
{
if (!compatibleRaces.Contains(raceDataAsset.raceName))
{
compatibleRaces.Add(raceDataAsset.raceName);
}
}
/// <summary>
/// Checks if the given RaceData is in the globalLibrary or an assetBundle
/// </summary>
/// <param name="_raceData"></param>
/// <returns></returns>
protected bool RaceInIndex(RaceData _raceData)
{
if (UMAContext.Instance != null)
{
if (UMAContext.Instance.HasRace(_raceData.raceName) != null)
{
return(true);
}
}
AssetItem ai = UMAAssetIndexer.Instance.GetAssetItem <RaceData>(_raceData.raceName);
if (ai != null)
{
return(true);
}
string path = AssetDatabase.GetAssetPath(_raceData);
if (UMAAssetIndexer.Instance.InAssetBundle(path))
{
return(true);
}
return(false);
}
RaceData CreatRace(UmaTPose umaTpose)//创建Race文件
{
if (umaTpose == null)
{
return(null);
}
RaceData rd = new RaceData();
RaceData targetrd = new RaceData();
rd.expressionSet = expressionSet;
rd.dnaConverterList = new DnaConverterBehaviour[2];
rd.dnaConverterList[0] = dnaConverterBehaviour;
rd.dnaConverterList[1] = RaceMap.Instance.tutorialDan;
rd.dnaRanges = new DNARangeAsset[1];
rd.dnaRanges[0] = danRange;
rd.TPose = umaTpose;
rd.raceName = objBase.Name;
string tempPath = string.Format("{0}/{1}_Race.asset", Fold, objBase.Name);
IObjectBase race = new ObjectBase(tempPath);
race.CreatAsset(rd);
return(rd);
}
private (IReadOnlyCollection <Driver> Drivers, RaceData raceData) BuildRaceData(DriverCodeGenerator driverCodeGenerator,
LapDataGenerator lapDataGenerator,
string team)
{
var drivers = new List <Driver>
{
new Driver(new Name("DriverOne", "One"), driverCodeGenerator.Generate(), team,
new FinishStatus(new Position(1), "Finished")),
new Driver(new Name("DriverTwo", "Two"), driverCodeGenerator.Generate(), team,
new FinishStatus(new Position(2), "Finished")),
new Driver(new Name("DriverThree", "Three"), driverCodeGenerator.Generate(), team,
new FinishStatus(new Position(3), "Finished")),
};
var driverRaceData = new[]
{
BuildDriverRaceData(lapDataGenerator, drivers[0].DriverCode.Code,
new [] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(3) }),
BuildDriverRaceData(lapDataGenerator, drivers[1].DriverCode.Code,
new [] { TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(11), TimeSpan.FromSeconds(12) }),
BuildDriverRaceData(lapDataGenerator, drivers[2].DriverCode.Code,
new [] { TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(17), TimeSpan.FromSeconds(19) }),
};
var raceData = new RaceData(driverRaceData);
return(drivers, raceData);
}
public void CreatPrefab()
{
#region cloths
EditorUtility.DisplayProgressBar(sex.ToString(), "clothes resources are dealing...", 1 / 7f);
IEditorCloth cloths = EditorClothFactory.Creat(sex, restype);
cloths.CreatPrefab();
#endregion
#region race
EditorUtility.DisplayProgressBar(sex.ToString(), "create race...", 2 / 7f);
TPoseEditor pose = TPoseEditorFactory.Creat(sex, obj, restype);
RaceData rd = pose.CreatTPose();
#endregion
#region animator
EditorUtility.DisplayProgressBar(sex.ToString(), "animations resources are dealing...", 3 / 7f);
IEditorAnimation anim = EditorAnimationFactory.Creat(sex, restype);
RuntimeAnimatorController controller = anim.Creat();
#endregion
#region base
EditorUtility.DisplayProgressBar(sex.ToString(), "body parts resources are dealing...", 5 / 7f);
List <SlotOverlayItem> sos = new List <SlotOverlayItem>();
SlotOverlayItem eyeItem = new SlotOverlayItem();
BaseClothItemEditor eyes = new EyesEditor(obj, restype);
SlotDataAsset eyes_slot = eyes.CreatSlot();
OverlayDataAsset eyes_overlay = eyes.CreatOverlay();
eyeItem.slot = eyes_slot;
eyeItem.overlay = eyes_overlay;
eyeItem.partIndex = eyes.WearPos;
SlotOverlayItem faceItem = new SlotOverlayItem();
BaseClothItemEditor face = new FaceEditor(obj, restype);
SlotDataAsset face_slot = face.CreatSlot();
OverlayDataAsset face_overlay = face.CreatOverlay();
faceItem.slot = face_slot;
faceItem.overlay = face_overlay;
faceItem.partIndex = face.WearPos;
sos.Add(eyeItem);
sos.Add(faceItem);
#endregion
#region CharacterPlayer
EditorUtility.DisplayProgressBar(sex.ToString(), "create character...", 7 / 7f);
Dictionary <string, object> dic = new Dictionary <string, object>();
dic["animatorController"] = controller;
dic["race"] = rd;
dic["sos"] = sos;
string assetpath = string.Format("{0}/{1}.prefab", prefabFold, obj.Name);
IPrefabItem prefab = new PrefabItem(assetpath);
prefab.CreatPrefab(null, CreatPrefabFinish, dic);
#endregion
}
#pragma warning restore 618
/*IEnumerator CleanRacesFromResourcesAndBundles()
* {
* yield return null;
* Resources.UnloadUnusedAssets();
* yield break;
* }*/
#pragma warning disable 618
//We need to override AddRace Too because if the element is not in the list anymore it causes an error...
override public void AddRace(RaceData race)
{
if (race == null)
{
return;
}
race.UpdateDictionary();
try
{
base.AddRace(race);
}
catch
{
//if there is an error it will be because RaceElementList contained an empty refrence
List <RaceData> newRaceElementList = new List <RaceData>();
for (int i = 0; i < raceElementList.Length; i++)
{
if (raceElementList[i] != null)
{
raceElementList[i].UpdateDictionary();
newRaceElementList.Add(raceElementList[i]);
}
}
raceElementList = newRaceElementList.ToArray();
base.AddRace(race);
}
}
/// <summary>
/// Calculates the reference time.
/// </summary>
/// <param name="drivers">The drivers.</param>
/// <param name="raceData">The race data.</param>
/// <returns>An instance <see cref="ReferenceTime"/>.</returns>
public ReferenceTime Calculate(IReadOnlyCollection <Driver> drivers, RaceData raceData)
{
var referenceTime = _calculationStrategy.Calculate(drivers, raceData);
_referenceTimeObservation.UpdateReferenceTime(referenceTime);
return(referenceTime);
}
private IRaceDataManager GetRaceDataManager()
{
var raceDataManager = new Mock <IRaceDataManager>();
raceDataManager.Setup(m => m.GetByRaceIdAsync(1, 1)).ReturnsAsync(new[]
{
new RaceData {
Id = 1, SensorId = 1, StartListId = 1, TimeStamp = DateTime.Now
},
new RaceData {
Id = 2, SensorId = 2, StartListId = 1, TimeStamp = DateTime.Now
},
new RaceData {
Id = 3, SensorId = 3, StartListId = 1, TimeStamp = DateTime.Now
},
new RaceData {
Id = 4, SensorId = 4, StartListId = 1, TimeStamp = DateTime.Now
},
new RaceData {
Id = 5, SensorId = 5, StartListId = 1, TimeStamp = DateTime.Now
}
});
var raceData = new RaceData {
Id = 1, SensorId = 2, StartListId = 1, TimeStamp = DateTime.Now
};
raceDataManager.Setup(m => m.CreateAsync(raceData)).Returns(Task.CompletedTask);
return(raceDataManager.Object);
}
void PutOnBase(Object baseObj)
{
GameObject data = GameObject.Instantiate(baseObj) as GameObject;
PlayerData pd = data.GetComponent <PlayerData>();
RaceData race = pd.race;
umaContext.raceLibrary.AddRace(race);
umaData.umaRecipe.SetRace(race);
if (pd.anim != null && pd.anim.animationClips != null && pd.anim.animationClips.Length > 0)
{
umaDynamicAvatar.context = umaContext;
umaDynamicAvatar.animationController = pd.anim;
}
pd.InitializeSlotData(characterSlotOverlay);
GameObject.DestroyImmediate(data);
InitilzeFlag = true;
if (InitializeCb != null)
{
InitializeCb();
}
}
public void UpdateNewRace()
{
umaRace = umaData.umaRecipe.raceData;
var position = transform.position;
var rotation = transform.rotation;
if (umaChild != null)
{
umaData.cleanMesh(false);
umaData.firstBake = true;
position = umaData.umaRoot.transform.position;
rotation = umaData.umaRoot.transform.rotation;
Destroy(umaChild);
}
umaChild = Instantiate(umaData.umaRecipe.raceData.racePrefab) as GameObject;
umaChild.transform.parent = transform;
UMAData newUMA = umaChild.GetComponentInChildren <UMAData>();
umaData.Assign(newUMA);
umaData.umaGenerator = umaGenerator;
umaData.umaRoot.transform.position = position;
umaData.umaRoot.transform.rotation = rotation;
// umaData.animationController = animationController ?? newUMA.animationController;
umaData.animationController = animationController;
if (animationController == null)
{
umaData.animationController = newUMA.animationController;
}
newUMA.animator = null;
DestroyImmediate(newUMA);
umaData.myRenderer.enabled = false;
umaData.Dirty(true, true, true);
}
// Drop area for compatible Races
private void CompatibleRacesDropArea(Rect dropArea, List <string> compatibleRaces)
{
Event evt = Event.current;
//make the box clickable so that the user can select raceData assets from the asset selection window
if (evt.type == EventType.MouseUp)
{
if (dropArea.Contains(evt.mousePosition))
{
compatibleRacePickerID = EditorGUIUtility.GetControlID(new GUIContent("crfObjectPicker"), FocusType.Passive);
EditorGUIUtility.ShowObjectPicker <RaceData>(null, false, "", compatibleRacePickerID);
Event.current.Use(); //stops the Mismatched LayoutGroup errors
return;
}
}
if (evt.commandName == "ObjectSelectorUpdated" && EditorGUIUtility.GetObjectPickerControlID() == compatibleRacePickerID)
{
RaceData tempRaceDataAsset = EditorGUIUtility.GetObjectPickerObject() as RaceData;
if (tempRaceDataAsset)
{
AddRaceDataAsset(tempRaceDataAsset, compatibleRaces);
}
Event.current.Use(); //stops the Mismatched LayoutGroup errors
return;
}
if (evt.type == EventType.DragUpdated)
{
if (dropArea.Contains(evt.mousePosition))
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
}
}
if (evt.type == EventType.DragPerform)
{
if (dropArea.Contains(evt.mousePosition))
{
DragAndDrop.AcceptDrag();
UnityEngine.Object[] draggedObjects = DragAndDrop.objectReferences as UnityEngine.Object[];
for (int i = 0; i < draggedObjects.Length; i++)
{
if (draggedObjects[i])
{
RaceData tempRaceDataAsset = draggedObjects[i] as RaceData;
if (tempRaceDataAsset)
{
AddRaceDataAsset(tempRaceDataAsset, compatibleRaces);
continue;
}
var path = AssetDatabase.GetAssetPath(draggedObjects[i]);
if (System.IO.Directory.Exists(path))
{
RecursiveScanFoldersForAssets(path, compatibleRaces);
}
}
}
}
}
}
void SelectByRace(object Race)
{
RaceData rc = Race as RaceData;
List <AssetItem> recipeItems = UAI.GetAssetItems(rc.baseRaceRecipe as UMAPackedRecipeBase);
SelectByAssetItems(recipeItems);
}
public WardrobeSetEditor(RaceData race, List <WardrobeSettings> wardrobeSet, UMAData.UMARecipe recipe, bool allowWardrobeCollectionSlot)
{
_recipe = recipe;
_wardrobeSet = wardrobeSet;
_race = race;
_allowWardrobeCollectionSlot = allowWardrobeCollectionSlot;
}
private void AddRaceDataAsset(RaceData raceDataAsset, SerializedProperty crossCompatibilitySettingsData)
{
if (raceDataAsset.raceName == serializedObject.FindProperty("raceName").stringValue)
{
return;
}
bool found = false;
for (int i = 0; i < crossCompatibilitySettingsData.arraySize; i++)
{
var ccRaceName = crossCompatibilitySettingsData.GetArrayElementAtIndex(i).FindPropertyRelative("ccRace").stringValue;
if (ccRaceName == raceDataAsset.raceName)
{
found = true;
}
}
if (!found)
{
crossCompatibilitySettingsData.InsertArrayElementAtIndex(crossCompatibilitySettingsData.arraySize);
crossCompatibilitySettingsData.GetArrayElementAtIndex(crossCompatibilitySettingsData.arraySize - 1).FindPropertyRelative("ccRace").stringValue = raceDataAsset.raceName;
serializedObject.ApplyModifiedProperties();
}
//if (!compatibleRaces.Contains(raceDataAsset.raceName))
// compatibleRaces.Add(raceDataAsset.raceName);
}
public async Task <ICollection <SplitTimeModel> > GetSplittimesForSkier(int skierId, int runNo)
{
return(await Task.Run(() =>
{
var raceDatas = new AdoRaceDataDao(connectionFactory).FindAllBySkierId(skierId);
raceDataForThisRaceRun = raceDatas.FirstOrDefault(data => data.RaceId == RaceControlModel.StartListModel.raceId);
ActualSplitimes = new ObservableCollection <SplitTimeModel>();
if (raceDataForThisRaceRun != null)
{
var splittimes = new AdoSplitTimeDao(connectionFactory).FindByRaceDataId(raceDataForThisRaceRun.Id).Where(splittime => splittime.RunNo == runNo);
EvaluateWinnerSplittimes();
foreach (var splittime in splittimes)
{
ActualSplitimes.Add(new SplitTimeModel
{
RaceDataId = splittime.RaceDataId,
RunNo = splittime.RunNo,
SplitTimeNo = splittime.SplittimeNo,
Time = splittime.Time,
TimeOffsetToWinner = GetTimeOffsetToWinner(splittime.Time, splittime.SplittimeNo)
});
}
}
return ActualSplitimes;
}));
}
/// <summary>
/// Gets the asset hash and name for the given object
/// </summary>
private void GetEvilAssetNameAndHash(System.Type type, Object o, ref string assetName, int assetHash)
{
if (o is SlotDataAsset)
{
SlotDataAsset sd = o as SlotDataAsset;
assetName = sd.slotName;
assetHash = sd.nameHash;
}
else if (o is OverlayDataAsset)
{
OverlayDataAsset od = o as OverlayDataAsset;
assetName = od.overlayName;
assetHash = od.nameHash;
}
else if (o is RaceData)
{
RaceData rd = o as RaceData;
assetName = rd.raceName;
assetHash = UMAUtils.StringToHash(assetName);
}
else
{
assetName = o.name;
assetHash = UMAUtils.StringToHash(assetName);
}
}
public void UpdateNewRace()
{
umaRace = umaData.umaRecipe.raceData;
var position = transform.position;
var rotation = transform.rotation;
if (umaChild != null)
{
umaData.cleanMesh(false);
umaData.firstBake = true;
position = umaData.umaRoot.transform.position;
rotation = umaData.umaRoot.transform.rotation;
Destroy(umaChild);
}
umaChild = Instantiate(umaData.umaRecipe.raceData.racePrefab) as GameObject;
umaChild.transform.parent = transform;
UMAData newUMA = umaChild.GetComponentInChildren<UMAData>();
umaData.Assign(newUMA);
umaData.umaGenerator = umaGenerator;
umaData.umaRoot.transform.position = position;
umaData.umaRoot.transform.rotation = rotation;
// umaData.animationController = animationController ?? newUMA.animationController;
umaData.animationController = animationController;
if (animationController == null) umaData.animationController = newUMA.animationController;
newUMA.animator = null;
DestroyImmediate(newUMA);
umaData.myRenderer.enabled = false;
umaData.Dirty(true, true, true);
}
public void TestCaufieldDataFeed()
{
var testData =
@"<?xml version=""1.0""?>
<races>
<race name=""TestName"">
<horses>
<horse name=""Horse1"">
<number>1</number>
</horse>
<horse name=""Horse2"">
<number>2</number>
</horse>
</horses>
<prices>
<price>
<priceType>WinFixedOdds</priceType>
<horses>
<horse number=""1"" Price=""5.2""/>
<horse number=""2"" Price=""3.4""/>
</horses>
</price>
</prices>
</race>
</races>";
var caufieldDataFeed = new CaufieldDataFeed();
caufieldDataFeed.RaceDataReceived += delegate(object sender, RaceDataEventArgs e)
{
RaceData expected = new RaceData {
RaceName = "TestName"
};
expected.Horses.Add(1, new Horse {
Name = "Horse1", Number = 1
});
expected.Horses.Add(2, new Horse {
Name = "Horse2", Number = 2
});
Price price = new Price {
PriceType = "WinFixedOdds"
};
price.HorsePrices.Add(new HorsePrice {
Price = 5.2, HorseNumber = 1
});
price.HorsePrices.Add(new HorsePrice {
Price = 3.4, HorseNumber = 2
});
expected.Prices.Add(price);
Assert.Single(e.RaceData);
Assert.Equal(expected, e.RaceData[0]);
};
using (MemoryStream fs = new MemoryStream(Encoding.UTF8.GetBytes(testData)))
{
caufieldDataFeed.Ingest(fs);
}
}
private RaceData CreateRaceData(Domain.Race race, IEnumerable <Domain.Bet> bets)
{
RaceData raceData = new RaceData
{
Id = race.Id,
Status = race.Status.GetDescription()
};
IEnumerable <Bet> betsOnRace = bets?.Where(b => b.Race?.Id == race.Id);
raceData.TotalMoneyOnRace = betsOnRace.Sum(b => b.Stake);
if (race.Horses != null)
{
IList <HorseData> horsesData = new List <HorseData>();
foreach (Horse horse in race.Horses)
{
HorseData horseData = new HorseData
{
Id = horse.Id,
Name = horse.Name,
NumberOfBets = bets?.Where(b => b.Horse?.Id == horse.Id).Count() ?? 0
};
horseData.PayoutIfWon = horseData.NumberOfBets * horse.Odds;
horsesData.Add(horseData);
}
raceData.Horses = horsesData;
}
return(raceData);
}
/// <summary>
/// Forces DCS to update its recipes to include all recipes that are in Resources or in downloaded assetBundles (optionally filtering by assetBundle name)
/// </summary>
/// <param name="forceUpdateRaceLibrary">If true will force RaceLibrary to add any races that were in any downloaded assetBundles and then call this Refresh again.</param>
/// <param name="bundleToGather">Limit the recipes found tto a defined asset bundle</param>
public override void Refresh(bool forceUpdateRaceLibrary = true, string bundleToGather = "")
{
if (!initialized)
{
Init();
return;
}
RaceData[] possibleRaces = new RaceData[0];
if (forceUpdateRaceLibrary)
{
possibleRaces = context.raceLibrary.GetAllRaces(); //if any new races are added by this then RaceLibrary will Re-Trigger this if there was anything new so dont do anything else
}
else
{
possibleRaces = (context.raceLibrary as DynamicRaceLibrary).GetAllRacesBase();
for (int i = 0; i < possibleRaces.Length; i++)
{
//we need to check that this is not null- the user may not have downloaded it yet
if (possibleRaces[i] != null)
{
if (!Recipes.ContainsKey(possibleRaces[i].raceName) && possibleRaces[i].raceName != "RaceDataPlaceholder")
{
Recipes.Add(possibleRaces[i].raceName, new Dictionary <string, List <UMATextRecipe> >());
}
}
}
GatherCharacterRecipes("", bundleToGather);
GatherRecipeFiles("", bundleToGather);
}
}
public ActionResult <IList <RankingSkierOutDto> > Get(int runningRaceId, int runNo)
{
IList <RankingSkierOutDto> rankingSkierOutDtos = new List <RankingSkierOutDto>();
IList <RaceData> finishedStartListMemberRaceDatas = new List <RaceData>();
if (runNo < 1 || runNo > 2)
{
return(BadRequest());
}
Race runningRace = _adoRaceDao.FindById(runningRaceId);
if (runningRace == null)
{
return(NotFound());
}
IEnumerable <StartListMember> startListMembers = _adoStartListDao.FindAllByRaceIdAndRunNo(runningRaceId, runNo);
if (startListMembers == null)
{
return(NotFound());
}
foreach (var startListMember in startListMembers)
{
RaceData raceData = _adoRaceDataDao.FindAllBySkierId(startListMember.SkierId)
.FirstOrDefault(data => data.RaceId == runningRaceId);
if (raceData != null && (!raceData.Finished && !raceData.Disqualified))
{
finishedStartListMemberRaceDatas.Add(raceData);
}
}
foreach (var finishedStartListMemberRaceData in finishedStartListMemberRaceDatas)
{
var lastSplitTime = _adoSplitTimeDao.FindByRaceDataId(finishedStartListMemberRaceData.Id)
.FirstOrDefault(splitTimeEntry => (splitTimeEntry.SplittimeNo == runningRace.Splittimes) &&
splitTimeEntry.RunNo == runNo);
if (lastSplitTime == null)
{
continue;
}
var skier = _adoSkierDao.FindById(finishedStartListMemberRaceData.SkierId);
rankingSkierOutDtos.Add(new RankingSkierOutDto()
{
FirstName = skier.FirstName,
LastName = skier.LastName,
Nation = skier.Nation,
ProfileImage = skier.ProfileImage,
EndTime = lastSplitTime.Time
});
}
var orderedRankingSkierOutDtos = rankingSkierOutDtos.OrderBy(dto => dto.EndTime);
rankingSkierOutDtos = orderedRankingSkierOutDtos.ToList();
for (int i = 1; i <= rankingSkierOutDtos.Count; i++)
{
rankingSkierOutDtos[i - 1].Ranking = i;
}
return(Ok(rankingSkierOutDtos));
}
public RaceJsonRepository(IDataFolder dataFolder)
{
this.dataFolder = dataFolder;
this.mutex = new ReaderWriterLockSlim();
this.serializer = JsonSerializer.CreateDefault();
this.serializer.Converters.Add(new SexJsonConverter());
this.raceData = null;
}
void SelectOverlaysByRace(object Race)
{
RaceData rc = Race as RaceData;
List <AssetItem> recipeItems = UAI.GetAssetItems(rc.baseRaceRecipe as UMAPackedRecipeBase);
recipeItems = recipeItems.Where(x => x._Type == typeof(OverlayDataAsset)).ToList();
SelectByAssetItems(recipeItems);
}
public static void CreateRaceData()
{
RaceData asset = ScriptableObject.CreateInstance <RaceData>();
AssetDatabase.CreateAsset(asset, "Assets/RaceData.asset");
AssetDatabase.SaveAssets();
EditorUtility.FocusProjectWindow();
Selection.activeObject = asset;
}
public void UpdateTest()
{
RaceData testRaceData = raceDataDao.FindById(3);
testRaceData.SkierId = 45;
raceDataDao.Update(testRaceData);
Assert.True(raceDataDao.FindById(3).SkierId == 45);
}
/// <summary>
/// Adds a button for adding dna to a newly created UMATextRecipe
/// </summary>
/// <returns></returns>
protected virtual bool AddDNAButtonUI()
{
RaceData standardRaceData = null;
if (_recipe != null)
{
standardRaceData = _recipe.raceData;
}
if (standardRaceData == null)
return false;
//This enables us to create a new recipe using the Editor menu command but also add DNA to it based on the set race's converters
var currentDNA = _recipe.GetAllDna();
//we also need current slots because GetAllDna returns a zero length array if _recipe.slotdatalist == null
SlotData[] currentSlots = _recipe.GetAllSlots();
bool couldAddDNA = false;
bool DNAConvertersAdded = false;
if (currentDNA.Length == 0 && currentSlots != null)
{
var thisDNAConverterList = standardRaceData.dnaConverterList;
foreach (IDNAConverter DnaConverter in thisDNAConverterList)
{
if (DnaConverter != null)
{
if(DnaConverter.DNATypeHash != 0)
couldAddDNA = true;
}
}
if (couldAddDNA)
{
if (GUILayout.Button("Add DNA"))
{
foreach (IDNAConverter DnaConverter in thisDNAConverterList)
{
if (DnaConverter != null)
{
DNAConvertersAdded = true;
//the recipe already has the DNAConverter, it just doesn't have the values it requires to show the output in the DNA tab of the recipe
//_recipe.AddDNAUpdater(DnaConverter);
Type thisType = DnaConverter.DNAType;
if (DnaConverter is IDynamicDNAConverter)
{
var dna = _recipe.GetOrCreateDna(thisType, DnaConverter.DNATypeHash);
if (((IDynamicDNAConverter)DnaConverter).dnaAsset != null)
{
((DynamicUMADnaBase)dna).dnaAsset = ((IDynamicDNAConverter)DnaConverter).dnaAsset;
}
}
else
{
_recipe.GetOrCreateDna(thisType, DnaConverter.DNATypeHash);
}
}
}
}
}
}
return DNAConvertersAdded;
}
public async Task <List <RaceData> > GetRaceData(int runnerid)
{
var racedata = new List <RaceData>();
//Get times by runner
var listoftimes = await TimeServices.GetListOfTimesbyRunnerId(runnerid);
//Creates list of dates
Dictionary <int, DateTime> eventdates = new Dictionary <int, DateTime>();
Dictionary <int, string> eventseason = new Dictionary <int, string>();
//Select times from a event
var practices = listoftimes.GroupBy(ev => new { ev.EventId }).Select(grp => grp.First()).ToList();
foreach (var practice in practices)
{
var tmpevent = await EventServices.GetEventById(practice.EventId.GetValueOrDefault());
//if event is not a race remove form the list of races
if (!tmpevent.IsRace)
{
listoftimes.RemoveAll(e => e.EventId == practice.EventId.GetValueOrDefault());
}
else
//if event is a race creates a dictionary with Key the event Id and content the race date to use later
{
eventdates.Add(tmpevent.Id, tmpevent.RaceDate);
eventseason.Add(tmpevent.Id, tmpevent.Season);
}
}
//Creates RaceData
//Group list of times by Season
var groupseason = eventseason.GroupBy(d => d.Value);
foreach (var group in groupseason)
{
var raceresults = new List <RaceResult>();
foreach (var id in group)
{
var racesplits = listoftimes.Where(e => e.EventId == id.Key).ToList();
var raceresult = new RaceResult {
Date = eventdates[id.Key], Time = racesplits.Last().Times.TotalMilliseconds,
Distance = racesplits.Last().Distance
};
raceresults.Add(raceresult);
}
var races = new RaceData {
Season = group.Key, RaceResults = raceresults
};
racedata.Add(races);
}
return(racedata);
}
public void Hide()
{
Destroy(umaChild);
umaChild = null;
umaData.umaRoot = null;
umaData.myRenderer = null;
umaData.animator = null;
umaData._hasUpdatedBefore = false;
umaData.firstBake = true;
umaData.ClearBoneData();
umaRace = null;
}
public void Hide()
{
Destroy(umaChild);
umaChild = null;
umaData.umaRoot = null;
umaData.myRenderer = null;
umaData.animator = null;
umaData._hasUpdatedBefore = false;
umaData.firstBake = true;
umaData.boneHashList.Clear();
umaData.animatedBones = new Transform[0];
umaData.tempBoneData = new UMAData.BoneData[0];
umaRace = null;
}
/// <summary>
/// Hide the avatar and clean up its components.
/// </summary>
public virtual void Hide()
{
if (umaData != null)
{
umaData.CleanTextures();
umaData.CleanMesh(true);
umaData.CleanAvatar();
Destroy(umaData.umaRoot);
umaData.umaRoot = null;
umaData.myRenderer = null;
umaData.animator = null;
umaData.firstBake = true;
umaData.skeleton = null;
}
umaRace = null;
}
public void AddRace(RaceData race)
{
for (int i = 0; i < raceElementList.Length; i++)
{
if (raceElementList[i].raceName == race.raceName)
{
raceElementList[i] = race;
return;
}
}
var list = new RaceData[raceElementList.Length + 1];
Array.Copy(raceElementList, list, raceElementList.Length );
list[raceElementList.Length] = race;
raceElementList = list;
raceDictionary.Add(race.raceName, race);
}
public void Write(string filename, List<CheckpointLocation> checkpointLocations, RaceData data)
{
using (StreamWriter w = new StreamWriter(filename, false, Encoding.UTF8))
{
WriteCheckpointLocations(checkpointLocations, w);
Dictionary<string, decimal> maxTeamsOnCheckpoint = new Dictionary<string, decimal>();
foreach (string checkpoint in data.CheckpointAndTimeFrame.Keys)
{
int max = data.CheckpointAndTimeFrame[checkpoint].Values.Max(r => r.Count);
maxTeamsOnCheckpoint[checkpoint] = max;
}
HashSet<string> checkpointNames = new HashSet<string>();
foreach (CheckpointLocation checkpoint in checkpointLocations)
checkpointNames.Add(checkpoint.Name);
WriteHeatMapData(data, checkpointNames, maxTeamsOnCheckpoint, w);
WriteTeamData(data, checkpointNames, maxTeamsOnCheckpoint, w);
}
}
private void WriteHeatMapData(RaceData data, HashSet<string> checkpointNames, Dictionary<string, decimal> maxTeamsOnCheckpoint, StreamWriter w)
{
bool firstHeatmap = true;
w.WriteLine("CheckpointHeatMaps = [");
for (int d=0; d<data.EndTimeFrame; d += Configuration.OutputSampleTime.Minutes)
{
if (!firstHeatmap)
w.WriteLine(",");
firstHeatmap= false;
bool firstCheckpoint = true;
w.WriteLine(" {");
w.WriteLine(" time: \"{0}\",", data.ConvertTimeFrameToDateTime(d));
w.WriteLine(" map: [");
if (data.TimeFrameAndCheckpoint.ContainsKey(d))
{
foreach (string checkpoint in data.TimeFrameAndCheckpoint[d].Keys)
{
if (checkpointNames.Contains(checkpoint))
{
if (!firstCheckpoint)
w.WriteLine(",");
firstCheckpoint = false;
decimal max = maxTeamsOnCheckpoint[checkpoint];
decimal count = data.TimeFrameAndCheckpoint[d][checkpoint].Count;
count = 50.0m * count / max;
w.Write(" {{ location: CheckpointLocations[\"{0}\"], weight: {1} }}", checkpoint, (int)count);
}
}
w.WriteLine("");
}
w.WriteLine(" ]");
w.Write(" }");
}
w.WriteLine("];");
}
public void UpdateNewRace()
{
umaRace = umaData.umaRecipe.raceData;
if (animationController != null)
{
umaData.animationController = animationController;
// umaData.animator.runtimeAnimatorController = animationController;
}
umaData.umaGenerator = umaGenerator;
umaData.Dirty(true, true, true);
}
private static void CalculateSummarizedScores(RaceData data)
{
foreach (string teamName in data.TeamTeamScore.Keys)
{
int score = 0;
var scoresByCheckpoint = data.TeamTeamScore[teamName].OrderBy(s => data.CheckpointRegistration[s.Checkpoint].Position);
foreach (TeamScoreRegistration reg in scoresByCheckpoint)
{
score += reg.Fixed.Value;
reg.Start = score;
score += reg.Work.Value;
reg.End = score;
}
}
}
private void InitializeRegistrations(RaceData data, IList<CheckpointTimeRegistration> checkpointTimes, IList<TeamScoreRegistration> teamScores)
{
DateTime? start = null;
DateTime? end = null;
// Validate data and calculate min/max
foreach (CheckpointTimeRegistration reg in checkpointTimes)
{
if (reg.Start == null && reg.End != null)
reg.Start = reg.End - Configuration.OutputSampleTime;
else if (reg.End == null && reg.Start != null)
reg.End = reg.Start + Configuration.OutputSampleTime;
if (start == null || reg.Start != null && reg.Start < start)
start = reg.Start;
if (end == null || reg.End != null && reg.End > end)
end = reg.End;
reg.Team = reg.Team.Trim();
}
data.StartTime = Trim(start.Value, Configuration.OutputSampleTime);
data.EndTime = end.Value;
data.EndTimeFrame = data.ConvertDateTimeToTimeFrame(data.EndTime);
// Update checkpoint time frames
foreach (CheckpointTimeRegistration reg in checkpointTimes)
{
if (reg.Start != null)
reg.StartTimeFrame = data.ConvertDateTimeToTimeFrame(reg.Start.Value);
if (reg.End != null)
reg.EndTimeFrame = data.ConvertDateTimeToTimeFrame(reg.End.Value);
}
foreach (TeamScoreRegistration reg in teamScores)
{
if (reg.Fixed == null)
reg.Fixed = 0;
if (reg.Work == null)
reg.Work = 0;
}
}
public RaceData CalcuateData(
List<TeamRegistration> teams,
List<CheckpointTimeRegistration> checkpointTimes,
List<TeamScoreRegistration> teamScores,
List<CheckpointRegistration> checkpoints,
List<CheckpointLocation> checkpointLocations)
{
RaceData data = new RaceData();
data.Teams = teams;
InitializeRegistrations(data, checkpointTimes, teamScores);
CalculateCheckpointLocations(checkpoints, checkpointLocations, data);
List<CheckpointRegistration> extendedCheckpoints = new List<CheckpointRegistration>();
for (int i=0; i<checkpoints.Count; ++i)
{
CheckpointRegistration c1 = checkpoints[i];
extendedCheckpoints.Add(c1);
for (int j = i+1; j < checkpoints.Count; ++j)
{
if (i != j)
{
CheckpointRegistration c2 = checkpoints[j];
if (c1.Location != null && c2.Location != null)
{
CheckpointRegistration c = new CheckpointRegistration
{
Checkpoint = c1.Checkpoint + "#" + c2.Checkpoint,
Location = new Vector((c1.Location.Latitude + c2.Location.Latitude) / 2, (c1.Location.Longitude + c2.Location.Longitude) / 2),
Type = CheckpointType.Intermediate
};
checkpointLocations.Add(new CheckpointLocation { Name = c.Checkpoint, Location = c.Location });
extendedCheckpoints.Add(c);
c = new CheckpointRegistration
{
Checkpoint = c2.Checkpoint + "#" + c1.Checkpoint,
Location = new Vector((c1.Location.Latitude + c2.Location.Latitude) / 2, (c1.Location.Longitude + c2.Location.Longitude) / 2),
Type = CheckpointType.Intermediate
};
checkpointLocations.Add(new CheckpointLocation { Name = c.Checkpoint, Location = c.Location });
extendedCheckpoints.Add(c);
}
}
}
}
checkpoints.Clear();
checkpoints.AddRange(extendedCheckpoints);
foreach (CheckpointRegistration reg in checkpoints)
{
data.CheckpointRegistration[reg.Checkpoint] = reg;
}
foreach (CheckpointTimeRegistration reg in checkpointTimes)
{
UpdateCheckpointAndTimeIndex(data.CheckpointAndTimeFrame, reg);
UpdateTimeFrameAndCheckpointIndex(data.TimeFrameAndCheckpoint, reg);
UpdateTeamAndTimeIndex(data.TeamAndTimeFrame, reg);
UpdateTeamAndTimeIntervalIndex(data.TeamAndTimeInterval, reg);
}
foreach (TeamScoreRegistration reg in teamScores)
{
UpdateTeamAndCheckpointTeamScoreIndex(data.TeamTeamScore, reg);
}
CalculateSummarizedScores(data);
return data;
}
private static void CalculateCheckpointLocations(IList<CheckpointRegistration> checkpoints, IList<CheckpointLocation> checkpointLocations, RaceData data)
{
int i = 0;
foreach (CheckpointRegistration reg in checkpoints)
{
reg.Position = i++;
data.CheckpointRegistration[reg.Checkpoint] = reg;
}
foreach (CheckpointLocation l in checkpointLocations)
{
if (data.CheckpointRegistration.ContainsKey(l.Name))
data.CheckpointRegistration[l.Name].Location = l.Location;
}
}
/*
============================================================================
Init functions
============================================================================
*/
public void Init()
{
// first init languages
languages = new LanguageData();
statusValues = new StatusValueData();
elements = new ElementData();
races = new RaceData();
sizes = new SizeData();
areaNames = new AreaNameData();
armors = new ArmorData();
cameraPositions = new CameraPositionData();
attacks = new BaseAttackData();
characters = new CharacterData();
classes = new ClassData();
colors = new ColorData();
dialoguePositions = new DialoguePositionData();
battleAIs = new BattleAIData();
enemies = new EnemyData();
equipParts = new EquipmentPartData();
formulas = new FormulaData();
gameSettings = new GameSettingsData();
items = new ItemData();
itemTypes = new ItemTypeData();
loadSaveHUD = new LoadSaveHUDData();
mainMenu = new MainMenuData();
skillTypes = new SkillTypeData();
effects = new StatusEffectData();
skills = new SkillData();
weapons = new WeaponData();
music = new MusicData();
huds = new HUDData();
recipes = new ItemRecipeData();
fonts = new FontData();
globalEvents = new GlobalEventData();
teleports = new TeleportData();
difficulties = new DifficultyData();
// battle system
battleAnimations = new BattleAnimationData();
battleSystem = new BattleSystemData();
}
private void WriteTeamData(RaceData data, HashSet<string> checkpointNames, Dictionary<string, decimal> maxTeamsOnCheckpoint, StreamWriter w)
{
List<string> teams = data.TeamAndTimeInterval.Keys.OrderBy(x => x.PadLeft(4)).ToList();
string lastTeam = teams.Last();
w.WriteLine("TeamTracks = {");
foreach (string teamName in teams)
{
TeamRegistration team = data.Teams.FirstOrDefault(t => t.Name == teamName);
string extendedTeamName = CreatedExtendedTeamName(teamName, team);
w.WriteLine(" \"{0}\": {{", teamName);
w.WriteLine(" name: \"{0}\",", teamName);
w.WriteLine(" extendedName: \"{0}\",", extendedTeamName);
w.WriteLine(" times: [");
CheckpointTimeRegistration prevReg = null;
foreach (CheckpointTimeRegistration reg in data.TeamAndTimeInterval[teamName].OrderBy(r => r.StartTimeFrame))
{
if (prevReg != null)
{
w.WriteLine(" {{ start: {0}, end: {1}, location: \"{2}\" }},",
Configuration.ConvertInputTimeFrameToOutput(prevReg.EndTimeFrame.Value + 1),
Configuration.ConvertInputTimeFrameToOutput(reg.StartTimeFrame.Value - 1),
prevReg.Checkpoint + "#" + reg.Checkpoint);
}
w.WriteLine(" {{ start: {0}, end: {1}, location: \"{2}\" }},",
Configuration.ConvertInputTimeFrameToOutput(reg.StartTimeFrame.Value),
Configuration.ConvertInputTimeFrameToOutput(reg.EndTimeFrame.Value),
reg.Checkpoint);
prevReg = reg;
}
w.WriteLine(" ],");
w.WriteLine(" scores: {");
if (data.TeamTeamScore.ContainsKey(teamName))
{
var scoresByCheckpoint = data.TeamTeamScore[teamName].OrderBy(s => data.CheckpointRegistration[s.Checkpoint].Position);
foreach (TeamScoreRegistration reg in scoresByCheckpoint)
{
w.WriteLine(" \"{0}\": {{ start:{1}, end:{2} }},",
reg.Checkpoint,
reg.Start,
reg.End);
}
}
w.WriteLine(" }");
w.Write(" }");
if (teamName != lastTeam)
w.WriteLine(",");
else
w.WriteLine("");
}
w.WriteLine("}");
}
