protected virtual void LoadConditions(IniFile ini)
{
var conditions = LinqExtension.RangeFrom()
.Select(x => $@"CONDITION_{x}")
.TakeWhile(ini.ContainsKey)
.Select(x => new {
Type = ini[x].GetEnumNullable <PlaceConditionsType>("TYPE"),
Value = ini[x].GetIntNullable("OBJECTIVE")
})
.ToList();
if (conditions.Count != 3 || conditions[0].Type == null ||
conditions.Any(x => x.Value == null || x.Type != null && x.Type != conditions[0].Type))
{
AddError(AcErrorType.Data_KunosCareerConditions, ini["CONDITION_0"].GetNonEmpty("TYPE") ?? @"?");
}
else
{
RemoveError(AcErrorType.Data_KunosCareerConditions);
ConditionType = conditions[0].Type.Value;
FirstPlaceTarget = conditions[2].Value.Value;
SecondPlaceTarget = conditions[1].Value.Value;
ThirdPlaceTarget = conditions[0].Value.Value;
}
}
public object GetPreview(string serializedData)
{
var ini = IniFile.Parse(serializedData);
var result = new StringBuilder();
// input method
result.AppendFormat(ControlsStrings.Controls_Preview_InputMethod, ini["HEADER"].GetEntry("INPUT_METHOD", Controls.InputMethods).DisplayName);
// device
var section = ini["CONTROLLERS"];
var devices = LinqExtension.RangeFrom().Select(x => section.GetNonEmpty("CON" + x.ToInvariantString())).TakeWhile(x => x != null).Distinct().ToList();
if (devices.Count > 1)
{
result.Append('\n');
result.AppendFormat(ControlsStrings.Controls_Preview_Devices, devices.JoinToString(@", "));
}
else if (devices.Count == 1)
{
result.Append('\n');
result.AppendFormat(ControlsStrings.Controls_Preview_Device, devices[0]);
}
return(new BbCodeBlock {
BbCode = result.ToString()
});
}
public Expression <Func <InfoLog, bool> > CreatCondition(LogQuery logQuery)
{
var condition = LinqExtension.True <InfoLog>();
if (!string.IsNullOrEmpty(logQuery.Content))
{
condition.And(a => a.Content.Contains(logQuery.Content));
}
if (logQuery.CreatTimeFrom.HasValue)
{
condition.And(a => a.CreationTime >= logQuery.CreatTimeFrom);
}
if (logQuery.CreatTmeTo.HasValue)
{
condition.And(a => a.CreationTime >= logQuery.CreatTmeTo);
}
if (!string.IsNullOrEmpty(logQuery.PlatformId))
{
condition.And(a => a.PlatformId == new ObjectId(logQuery.PlatformId));
}
if (!string.IsNullOrEmpty(logQuery.BusinessPosition))
{
condition.And(a => $".{a.BusinessPosition}.".Contains($".{logQuery.BusinessPosition}."));
}
if (!string.IsNullOrEmpty(logQuery.TraceInfo))
{
condition.And(a => a.TraceInfo.Contains(logQuery.TraceInfo));
}
return(condition);
}
public static long Evaluate(Dictionary <string, bool> coordinates)
{
for (var i = 0; i < 6; i++)
{
coordinates.Keys.ToList().ForEach(c =>
{
LinqExtension.DimensionalNeighbors(c.Split(',').Select(int.Parse))
.Select(t => string.Join(',', t))
.Where(t => !coordinates.ContainsKey(t))
.ToList()
.ForEach(t => coordinates[t] = false);
});
var coordinatesCopy = new Dictionary <string, bool>();
coordinates.Keys.ToList().ForEach(c =>
{
var activeNeighbors = LinqExtension.DimensionalNeighbors(c.Split(',').Select(int.Parse))
.Select(t => string.Join(',', t))
.Where(t => coordinates.ContainsKey(t))
.Select(t => coordinates[t])
.Count(v => v);
coordinatesCopy[c] = coordinates[c] switch
{
true when(activeNeighbors < 2 || activeNeighbors > 3) => false,
false when activeNeighbors == 3 => true,
_ => coordinates[c]
};
});
coordinates = coordinatesCopy;
}
return(coordinates.Values.Count(v => v));
}
public long Calculate(List <string> input)
{
var plane = new TobogganPlane(input);
return(LinqExtension
.TobogganRange(3, 1, input.Count)
.Count((t) => plane.IsTree(t.x, t.y)));
}
/// <summary>Adds the specified t aggregate roots.</summary>
/// <typeparam name="TAggregateRoot">The type of the t aggregate root.</typeparam>
/// <param name="tAggregateRoots">The t aggregate roots.</param>
/// <returns>IEnumerable<System.Int64>.</returns>
public IEnumerable <long> Add <TAggregateRoot>(IEnumerable <TAggregateRoot> tAggregateRoots) where TAggregateRoot : EntityBase
{
List <long> ids = new List <long>();
if (tAggregateRoots.Any <TAggregateRoot>())
{
LinqExtension.Each <TAggregateRoot>(tAggregateRoots, (Action <TAggregateRoot>)(x => ids.Add(this.Add <TAggregateRoot>(x))));
}
return((IEnumerable <long>)ids);
}
public PagedItems <T> ListarPaginado(Expression <Func <T, bool> > predicate, PagedOptions pagedFilter)
{
if (string.IsNullOrEmpty(pagedFilter.Sort) && pagedFilter.SortManny == null)
{
var props = typeof(T)
.GetProperties()
.Where(prop =>
Attribute.IsDefined(prop,
typeof(System.ComponentModel.DataAnnotations.KeyAttribute)));
pagedFilter.Sort = props.First().Name;
}
PagedItems <T> paged = new PagedItems <T>();
var query = Context
.Set <T>()
.AsNoTracking()
.Where(predicate)
.AsQueryable();
paged.Total = query.Count();
if (!string.IsNullOrEmpty(pagedFilter.Sort))
{
query = LinqExtension.OrderBy(query, pagedFilter.Sort, pagedFilter.Reverse);
}
else
{
if (pagedFilter.SortManny != null)
{
var list = pagedFilter.SortManny.ToList();
for (int i = 0; i < list.Count; i++)
{
if (i == 0)
{
query = LinqExtension.OrderBy(query, list[i].Sort, list[i].Reverse);
}
else
{
query = LinqExtension.ThenBy(query, list[i].Sort, list[i].Reverse);
}
}
}
}
var skip = (pagedFilter.Page.Value * pagedFilter.Size.Value) - pagedFilter.Size.Value;
query = query.Skip(skip);
query = query.Take(pagedFilter.Size.Value);
paged.Items = query.ToList();
return(paged);
}
private Expression <Func <Entity.Platform, bool> > CreatCondition(PlatformQuery query)
{
var condition = LinqExtension.True <Entity.Platform>();
if (!string.IsNullOrEmpty(query.AppId))
{
condition.And(a => a.Config.AppId == query.AppId);
}
if (!string.IsNullOrEmpty(query.Name))
{
condition.And(a => a.Name.Contains(query.Name));
}
return(condition);
}
private static void DemoPart2()
{
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("1). WHERE Extension: Onderstaande functie is een aangepaste extension van Where in LINQ.");
WhiteLine();
LinqExtension.DemoWhere();
Breaker();
Console.Write("2). SELECT Extension: Onderstaande functie is een aangepaste extension van Select in LINQ.");
WhiteLine();
LinqExtension.DemoSelect();
Breaker();
Console.Write("3). ANY Extension: Onderstaande functie is een aangepaste extension van Any in LINQ.");
WhiteLine();
LinqExtension.DemoAny();
Breaker();
}
public static IReadOnlyList <ResolutionEntry> GetResolutions()
{
if (InitializeAcVideoModes())
{
try {
return(AcVideoModes.GetResolutionEntries().ToList());
} catch (Exception e) {
NonfatalError.Notify(ToolsStrings.AcSettings_CannotGetResolutions, e);
}
}
var d = new User32.DEVMODE();
return(LinqExtension.RangeFrom()
.Select(i => User32.EnumDisplaySettings(null, i, ref d)
? new ResolutionEntry(i + 1, d.dmPelsWidth, d.dmPelsHeight, d.dmDisplayFrequency) : null)
.TakeWhile(x => x != null).Distinct().ToList());
}
protected override IEnumerable <AcPlaceholderNew> ScanOverride()
{
if (OptionIgnoreSkippedEvents)
{
return(base.ScanOverride());
}
var entries = Directories.GetContentDirectories().Select(x => new {
Name = Path.GetFileName(x)?.ToLowerInvariant(),
Path = x
}).ToList();
return(LinqExtension.RangeFrom(1)
.Select(x => @"event" + x)
.Select(x => entries.FirstOrDefault(y => y.Name == x))
.TakeWhile(x => x != null)
.Select(dir =>
CreateAcPlaceholder(Directories.GetId(dir.Path), Directories.CheckIfEnabled(dir.Path))));
}
public long Calculate(List <string> input)
{
var plane = new TobogganPlane(input);
var slopes = new List <(int x, int y)>
{
(1, 1),
(3, 1),
(5, 1),
(7, 1),
(1, 2),
};
return(slopes
.Select(s => LinqExtension
.TobogganRange(s.x, s.y, input.Count)
.Count((t) => plane.IsTree(t.x, t.y)))
.Select(Convert.ToInt64)
.Aggregate((a, x) => a * x));
}
/// <summary>修改集合</summary>
/// <typeparam name="TAggregateRoot">The type of the t aggregate root.</typeparam>
/// <param name="tAggregateRoots">The t aggregate roots.</param>
public void Update <TAggregateRoot>(IQueryable <TAggregateRoot> tAggregateRoots) where TAggregateRoot : EntityBase, new()
{
LinqExtension.Each <TAggregateRoot>(tAggregateRoots, (Action <TAggregateRoot>)(x => this.Update <TAggregateRoot>(x, new Expression <Func <TAggregateRoot, object> > [0])));
}
/// <summary>根据条件逻辑删除</summary>
/// <typeparam name="TAggregateRoot">The type of the t aggregate root.</typeparam>
/// <param name="tAggregateRoots">The t aggregate roots.</param>
public void Delete <TAggregateRoot>(IQueryable <TAggregateRoot> tAggregateRoots) where TAggregateRoot : EntityBase, new()
{
LinqExtension.Each <TAggregateRoot>(tAggregateRoots, new Action <TAggregateRoot>(this.Delete <TAggregateRoot>));
}
/// <summary>根据条件删除</summary>
/// <typeparam name="TAggregateRoot">The type of the t aggregate root.</typeparam>
/// <param name="tAggregateRoots">The t aggregate roots.</param>
public void Remove <TAggregateRoot>(IQueryable <TAggregateRoot> tAggregateRoots) where TAggregateRoot : EntityBase
{
LinqExtension.Each <TAggregateRoot>(tAggregateRoots, new Action <TAggregateRoot>(this.Remove <TAggregateRoot>));
}
/// <summary>根据条件删除</summary>
/// <typeparam name="TAggregateRoot">The type of the t aggregate root.</typeparam>
/// <param name="filter">The filter.</param>
public void Remove <TAggregateRoot>(ISpecification <TAggregateRoot> filter) where TAggregateRoot : EntityBase
{
LinqExtension.Each <TAggregateRoot>(this.CreateSet <TAggregateRoot>().Where <TAggregateRoot>(filter.SatisfiedBy()), new Action <TAggregateRoot>(this.Remove <TAggregateRoot>));
}
public async Task <IList <Game.AiCar> > GenerateGameEntries(CancellationToken cancellation = default(CancellationToken))
{
if (IsBusy)
{
await RebuildGridAsync();
if (cancellation.IsCancellationRequested)
{
return(null);
}
}
var opponentsNumber = OpponentsNumberLimited;
if (FilteredView.Count == 0 || opponentsNumber == 0)
{
return(new Game.AiCar[0]);
}
var skins = new Dictionary <string, GoodShuffle <CarSkinObject> >();
foreach (var car in FilteredView.OfType <RaceGridEntry>().Where(x => x.CarSkin == null).Select(x => x.Car).Distinct())
{
await car.SkinsManager.EnsureLoadedAsync();
if (cancellation.IsCancellationRequested)
{
return(null);
}
skins[car.Id] = GoodShuffle.Get(car.EnabledOnlySkins);
}
NameNationality[] nameNationalities;
if (opponentsNumber == 7 && OptionNfsPorscheNames)
{
nameNationalities = new[] {
new NameNationality {
Name = "Dylan", Nationality = "Wales"
},
new NameNationality {
Name = "Parise", Nationality = "Italy"
},
new NameNationality {
Name = "Steele", Nationality = "United States"
},
new NameNationality {
Name = "Wingnut", Nationality = "England"
},
new NameNationality {
Name = "Leadfoot", Nationality = "Australia"
},
new NameNationality {
Name = "Amazon", Nationality = "United States"
},
new NameNationality {
Name = "Backlash", Nationality = "United States"
}
};
}
else if (DataProvider.Instance.NationalitiesAndNames.Any())
{
nameNationalities = GoodShuffle.Get(DataProvider.Instance.NationalitiesAndNamesList).Take(opponentsNumber).ToArray();
}
else
{
nameNationalities = null;
}
List <int> aiLevels;
if (AiLevelFixed)
{
aiLevels = null;
}
else
{
var aiLevelsInner = from i in Enumerable.Range(0, opponentsNumber)
select AiLevelMin + ((opponentsNumber < 2 ? 1d : 1d - i / (opponentsNumber - 1d)) * (AiLevel - AiLevelMin)).RoundToInt();
if (AiLevelArrangeReverse)
{
aiLevelsInner = aiLevelsInner.Reverse();
}
if (Equals(AiLevelArrangeRandom, 1d))
{
aiLevelsInner = GoodShuffle.Get(aiLevelsInner);
}
else if (AiLevelArrangeRandom > 0d)
{
aiLevelsInner = LimitedShuffle.Get(aiLevelsInner, AiLevelArrangeRandom);
}
aiLevels = aiLevelsInner.Take(opponentsNumber).ToList();
Logging.Debug("AI levels: " + aiLevels.Select(x => $@"{x}%").JoinToString(@", "));
}
IEnumerable <RaceGridEntry> final;
if (Mode.CandidatesMode)
{
var list = FilteredView.OfType <RaceGridEntry>().SelectMany(x => new[] { x }.Repeat(x.CandidatePriority)).ToList();
if (ShuffleCandidates)
{
var shuffled = GoodShuffle.Get(list);
if (_playerCar != null)
{
var same = list.FirstOrDefault(x => x.Car == _playerCar);
if (same != null)
{
shuffled.IgnoreOnce(same);
}
}
final = shuffled.Take(opponentsNumber);
}
else
{
var skip = _playerCar;
final = LinqExtension.RangeFrom().Select(x => list.RandomElement()).Where(x => {
if (x.Car == skip)
{
skip = null;
return(false);
}
return(true);
}).Take(opponentsNumber);
}
}
else
{
final = NonfilteredList.Where(x => !x.SpecialEntry);
}
if (_playerCar != null)
{
skins.GetValueOrDefault(_playerCar.Id)?.IgnoreOnce(_playerCar.SelectedSkin);
}
var takenNames = new List <string>(opponentsNumber);
return(final.Take(opponentsNumber).Select((entry, i) => {
var level = entry.AiLevel ?? aiLevels?[i] ?? 100;
var skin = entry.CarSkin;
if (skin == null)
{
skin = skins.GetValueOrDefault(entry.Car.Id)?.Next;
}
var name = entry.Name;
if (string.IsNullOrWhiteSpace(name) && SettingsHolder.Drive.QuickDriveUseSkinNames)
{
var skinDriverNames = skin?.DriverName?.Split(',').Select(x => x.Trim()).Where(x => x.Length > 0).ToList();
if (skinDriverNames?.Count > 0)
{
name = GoodShuffle.Get(skinDriverNames).Take(skinDriverNames.Count).FirstOrDefault(x => !takenNames.Contains(x)) ?? name;
takenNames.Add(name);
}
}
if (string.IsNullOrWhiteSpace(name))
{
name = nameNationalities?[i].Name ?? @"AI #" + i;
takenNames.Add(name);
}
var nationality = entry.Nationality ?? nameNationalities?[i].Nationality ?? @"Italy";
var skinId = skin?.Id;
return new Game.AiCar {
AiLevel = level,
CarId = entry.Car.Id,
DriverName = AiLevelInDriverName ? $@"{name} ({level}%)" : name,
Nationality = nationality,
Setup = "",
SkinId = skinId
};
}).ToList());
}
public static IEnumerable <string> GetSectionNames(string prefixName, int startFrom)
{
return(LinqExtension.RangeFrom(startFrom == -1 ? 0 : startFrom)
.Select(x => startFrom == -1 && x == 0 ? prefixName : $"{prefixName}_{x}"));
}
private void LoadOpponents()
{
if (Type != KunosCareerObjectType.Championship)
{
return;
}
InitializeEventsManager();
var firstEvent = GetFirstEventOrNull();
if (firstEvent == null)
{
AddError(AcErrorType.Data_KunosCareerEventsAreMissing, DisplayName);
}
var ini = new IniFile(OpponentsIniFilename);
var drivers = LinqExtension.RangeFrom(1).Select(x => $"AI{x}").TakeWhile(ini.ContainsKey).Select(x => ini[x]).Select((section, id) => {
var model = section.GetNonEmpty("MODEL");
if (model == null)
{
Logging.Error($"Section AI{id + 1}: MODEL is required, fallback to default");
model = CarsManager.Instance.GetDefault()?.Id ?? "";
}
var skin = section.GetNonEmpty("SKIN");
if (skin == null)
{
Logging.Error($"Section AI{id + 1}: SKIN is required, fallback to default");
}
var car = CarsManager.Instance.GetById(model);
CarSkinObject carSkin;
if (car == null)
{
AddError(AcErrorType.Data_KunosCareerCarIsMissing, section.GetNonEmpty("MODEL"));
carSkin = null;
}
else
{
carSkin = skin == null ? car.GetFirstSkinOrNull() : car.GetSkinByIdFromConfig(skin);
if (carSkin == null)
{
if (!KunosEventObjectBase.OptionIgnoreMissingSkins)
{
AddError(AcErrorType.Data_KunosCareerCarSkinIsMissing, car.DisplayName, section.GetNonEmpty("SKIN"));
}
carSkin = (CarSkinObject)car.SkinsManager.WrappersList.RandomElementOrDefault()?.Loaded();
}
}
return(new ChampionshipDriverEntry {
Id = id,
Name = section.GetPossiblyEmpty("DRIVER_NAME"),
Nationality = section.GetPossiblyEmpty("NATIONALITY"),
AiLevel = section.GetInt("AI_LEVEL", 100),
SetupId = section.GetPossiblyEmpty("SETUP"),
Car = car,
CarSkin = carSkin
});
}).Prepend(new ChampionshipDriverEntry {
Id = -1,
Name = SettingsHolder.Drive.PlayerName,
Nationality = SettingsHolder.Drive.PlayerNationality,
Car = firstEvent?.CarObject,
CarSkin = firstEvent?.CarSkin,
IsPlayer = true
});
ChampionshipDrivers.ReplaceEverythingBy(drivers);
}
public void AddPartsByRef(List <BonusRef> bonusRefs, GetBonusDto dto)
{
if (bonusRefs == null || bonusRefs.Count == 0)
{
return;
}
var grps = bonusRefs.GroupBy(x => x.Type);
foreach (var grp in grps)
{
var stacks = LinqExtension.DoesStack(grp.Key);
if (stacks)
{
//value = bonuesValues.Sum();
//var bonuesValues = grp.Select(x => x.GetBonus(dto).GetValueOrDefault()).ToList();
foreach (var bonuesValue in grp)
{
AddIfNotZero(bonuesValue.Parent.Name, bonuesValue.GetCondition(), new DiceRoll
{
FixedAmount = bonuesValue.GetBonus(dto).GetFixedAmount()
});
}
}
else
{
var bonuesValues = grp.Select(x => new
{
Name = x.Parent.Name,
Value = x.GetBonus(dto).GetFixedAmount(),
Condition = x.Bonues.GetCondition()
}).ToList();
var min = bonuesValues.OrderByDescending(x => x.Value).First();
var max = bonuesValues.OrderBy(x => x.Value).First();
if (min.Value < 0 && max.Value > 0)
{
AddIfNotZero(max.Name, max.Condition, new DiceRoll
{
FixedAmount = max.Value
});
AddIfNotZero(min.Name, min.Condition, new DiceRoll
{
FixedAmount = min.Value
});
//value += max + min;
}
else if (min.Value < 0 && max.Value < 0)
{
AddIfNotZero(min.Name, min.Condition, new DiceRoll
{
FixedAmount = min.Value
});
//value += min;
}
//prefer bonus without conditions
else if (string.IsNullOrWhiteSpace(max.Condition))
{
AddIfNotZero(max.Name, max.Condition, new DiceRoll
{
FixedAmount = max.Value
});
//value += max;
}
else
{
AddIfNotZero(min.Name, min.Condition, new DiceRoll
{
FixedAmount = min.Value
});
//value += max;
}
}
}
}
