void Selected_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (e.PropertyName == "IsSelected")
{
_isAnySelected = AllOptions.Any(o => o.IsSelected) && AllCentres.Any(o => o.IsSelected);
}
}
private static int DisassembleAll(AllOptions opts)
{
return(TryDisassemble(opts, (v, p) =>
{
return x => true;
}));
}
public Watcher()
{
ConfigurationLoader configLoader = new ConfigurationLoader();
// Getting all possible options.
AllOptions allOptions = configLoader.GetAllOptions(configurationPath);
// Load all options.
sourceDirectory = allOptions.watcherOptions.sourseDirectoryPath;
targetDirectory = allOptions.watcherOptions.targetDirectoryPath;
archiveDirectory = allOptions.archiveOptions.archiveDirectoryPath;
loggerPath = allOptions.loggerOptions.logFilePath;
enableArhivation = allOptions.archiveOptions.enableArchivation;
enableEncryption = allOptions.encryptionOptions.enableEncryption;
enableLogging = allOptions.loggerOptions.enableLogging;
obj = new object();
logger = new Logger(loggerPath, enableLogging);
// Entry about results of getting options.
logger.AddEntry(configLoader.logMessage);
watcher = new FileSystemWatcher(sourceDirectory);
// Only watch text files.
watcher.Filter = "*.txt";
// Add event handlers.
watcher.Created += WatcherCreated;
}
public Wallet(ILogger <Wallet> logger, IOptions <AllOptions> options)
{
_syncLock = new object();
_logger = logger;
_options = options.Value;
_state = WalletState.Empty;
}
private void ImportSlot(int slotId)
{
System.Console.WriteLine(slotId);
string text;
try
{
var path = Path.Combine(Application.persistentDataPath, $"GameSettings-Slot{slotId}");
text = File.ReadAllText(path);
}
catch
{
Cancel(FlashRed);
return;
}
var splitText = text.Split("\n").ToList();
while (splitText.Count > 0)
{
var name = splitText[0].Trim();
splitText.RemoveAt(0);
var option = AllOptions.FirstOrDefault(o => o.Name.Equals(name, StringComparison.Ordinal));
if (option == null)
{
try
{
splitText.RemoveAt(0);
}
catch
{
}
continue;
}
var value = splitText[0];
splitText.RemoveAt(0);
switch (option.Type)
{
case CustomOptionType.Number:
option.Set(float.Parse(value), false);
break;
case CustomOptionType.Toggle:
option.Set(bool.Parse(value), false);
break;
case CustomOptionType.String:
option.Set(int.Parse(value), false);
break;
}
}
Rpc.SendRpc();
Cancel(FlashGreen);
}
public Spin(ILogger <Spin> logger, IOptions <AllOptions> options, SymbolGenerator symbolGenerator, IOutput output)
{
_logger = logger;
_options = options.Value;
_symbolGenerator = symbolGenerator;
_output = output;
_symbols = new Dictionary <string, Symbol>();
}
public void SetUp()
{
_options = new AllOptions
{
General = new GeneralOptions
{
MaxAmount = 10_000,
AmountPrecision = 2,
CoefficientPrecision = 2
},
private OptionBase FindOption(string name)
{
var option = AllOptions.FirstOrDefault(o => o.Match(name));
if (option == null)
{
throw new OptionParserException("Unknown option: {0}".With(name));
}
return(option);
}
public void SetUp()
{
_target = new AllOptionsValidator();
_data = new AllOptions
{
General = new GeneralOptions
{
MaxAmount = 10_000_000,
AmountPrecision = 2,
CoefficientPrecision = 2
},
public GameEngine(
ILogger <GameEngine> logger,
IOptions <AllOptions> options,
IEnumerable <State> states,
ISpinConfiguration spinConfiguration,
IWalletConfiguration walletConfiguration)
{
_logger = logger;
_options = options.Value;
_states = states;
_spinConfiguration = spinConfiguration;
_walletConfiguration = walletConfiguration;
}
public IActionResult SaveOptions([FromBody] AllOptions options)
{
try
{
var userData = jwtService.ParseData(this.User);
this.optionsService.SaveOptions(options, userData.UserId);
return(Ok());
}
catch (ServiceException e)
{
return(BadRequest(e.Message));
}
}
public void OpenClose(GameObject neededpanel)
{
if (neededpanel == AllOptions && PoseWavePanel.active == true)
{
// gm.mode = null;
PoseWavePanel.SetActive(false);
}
else if (neededpanel == PoseWavePanel && AllOptions.active == true)
{
AllOptions.SetActive(false);
}
neededpanel.SetActive(!neededpanel.activeSelf);
}
public void Parse(string[] args)
{
var expr = new Regex(@"^--(?<name>[a-zA-Z0-9]+[\-a-zA-Z0-9]*)(=(?<value>\w+))?|-(?<short_name>[a-zA-Z0-9]+)$", RegexOptions.ExplicitCapture);
for (var i = 0; i < args.Length; i++)
{
var match = expr.Match(args[i]);
if (match.Success)
{
if (match.Groups["name"].Success)
{
var option = FindOption(match.Groups["name"].Value);
if (match.Groups["value"].Success)
{
option.Receive(match.Groups["value"].Value);
}
else
{
option.ReceiveDefault();
}
}
else
{
var names = match.Groups["short_name"].Value.Select(name => name.ToString());
names.TakeWhile(n => n != names.Last()).Each(n => FindOption(n).ReceiveDefault());
var option = FindOption(names.Last());
if (option.HasArgument && i + 1 < args.Length)
{
option.Receive(args[++i]);
}
else if (!option.HasArgument)
{
option.ReceiveDefault();
}
else
{
throw new OptionParserException("--{0}: Missing argument".With(option.Name));
}
}
}
else
{
// Handle arguments
FindOption(string.Empty).Receive(args[i]);
}
}
AllOptions.Each(o => o.Finally());
}
public override void Initialize(Negotiation.Models.NegotiationDomain domain, Negotiation.Models.SideConfig strategyConfig, string opponentSide, Negotiation.Models.INegotiationClient client)
{
base.Initialize(domain, strategyConfig, opponentSide, client);
m_BestCombinedUtilityOffers = new Dictionary <string, OfferUtility>(BestCombinedUtilityOffers);
m_BestFScoreUtilityOffers = new Dictionary <string, OfferUtility>(BestFScoreUtilityOffers);
var opponentTypes = domain.OwnerVariantDict[opponentSide].Keys;
m_typeProbabilites = opponentTypes.ToDictionary(k => k, x => (1.0 / opponentTypes.Count));
var utilitySums = opponentTypes.ToDictionary(k => k, k => AllOptions.Values.Sum(x => x.UtilityDataDict[k].OpponentUtility));
m_offerProbabilities = AllOptions.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.UtilityDataDict.ToDictionary(kvp2 => kvp2.Key, kvp2 => kvp2.Value.OpponentUtility / utilitySums[kvp2.Key]));
}
public static ProjectDirectories CreateDirectories(AllOptions opts)
{
var dirName = $"{opts.Business}.{opts.Application}.{opts.Module}";
var directories = new ProjectDirectories
{
DomainDirectory = $"{dirName}/Domain",
TestDirectory = $"{dirName}.UnitTest/Domain"
};
CreateDirectory(directories.DomainDirectory);
CreateDirectory(directories.TestDirectory);
return(directories);
void CreateDirectory(string dirName) => System.IO.Directory.CreateDirectory($"{opts.OutputDirectory}/{dirName}");
}
public void SaveOptions(AllOptions incOptions, int userId)
{
var user = context.Users
.Include(x => x.UserOptions)
.SingleOrDefault(x => x.Id == userId);
if (user == null)
{
throw new ServiceException("User Not Foud!");
}
var options = user.UserOptions;
options.Theme = incOptions.Theme;
this.context.SaveChanges();
}
public void WriteUsageOptions(TextWriter output)
{
var anyShortOptions = AllOptions.OfType <Option>().Any(o => o.ShortNameForUsage.Length > 0);
var maxOptionNameLength = AllOptions.OfType <Option>().Max(o => o.NameForUsage.Length);
var formatter = new FixedWidthFormatProvider();
Action <Option> writeOption = o => {
output.Write(" ");
if (anyShortOptions)
{
output.Write(string.Format(formatter, "{0:2}", o.ShortNameForUsage));
if (o.NameForUsage.Length > 0)
{
output.Write(o.ShortNameForUsage.Length > 0 ? "," : " ");
}
}
output.WriteLine(string.Format(formatter, " {0:" + maxOptionNameLength + "} {1}", o.NameForUsage, o.DescriptionForUsage));
};
var describedArguments = AllOptions
.OfType <Argument>()
.Where(a => a.DescriptionForUsage.Length > 0)
.Select(a => a.DescriptionForUsage);
if (describedArguments.Any())
{
output.WriteLine();
describedArguments.Each(output.WriteLine);
}
if (Options.OfType <Option>().Any())
{
output.WriteLine();
Options.OfType <Option>().Each(writeOption);
}
groups
.Each(g => {
output.WriteLine();
output.WriteLine("{0}:", g.Key);
g.Value.Options.OfType <Option>().Each(writeOption);
});
}
public void WriteUsageHeader(TextWriter output)
{
var applicationName = Path.GetFileNameWithoutExtension(AppDomain.CurrentDomain.FriendlyName);
output.Write("Usage: {0} [OPTION]...", applicationName);
output.Write(
AllOptions
.OfType <Argument>()
.OrderByDescending(a => a.Required)
.Select(a => a.Required ? a.Name : string.Format("[{0}]", a.Name) + (a.SupportsMultipleValues ? " ..." : ""))
.Aggregate("", (acc, a) => acc + " " + a)
);
output.WriteLine();
if (string.IsNullOrEmpty(Header))
{
return;
}
output.WriteLine();
output.WriteLine(Header);
}
private Dictionary <RiderOptionTypes, RiderOption> BuildOptions()
{
Dictionary <RiderOptionTypes, RiderOption> retVal = new Dictionary <RiderOptionTypes, RiderOption>();
switch (this.CurrentState)
{
case RiderStates.InHall:
retVal.Add(RiderOptionTypes.PressUpButton, AllOptions.First(k => k.Key == RiderOptionTypes.PressUpButton).Value);
retVal.Add(RiderOptionTypes.PressDownButton, AllOptions.First(k => k.Key == RiderOptionTypes.PressDownButton).Value);
retVal.Add(RiderOptionTypes.Dance, AllOptions.First(k => k.Key == RiderOptionTypes.Dance).Value);
break;
case RiderStates.WaitingForElevator:
retVal.Add(RiderOptionTypes.Dance, AllOptions.First(k => k.Key == RiderOptionTypes.Dance).Value);
retVal.Add(RiderOptionTypes.Sneeze, AllOptions.First(k => k.Key == RiderOptionTypes.Sneeze).Value);
if (curElevator != null && curElevator.CurrentState == ElevatorStates.Inactive)
{
retVal.Add(RiderOptionTypes.GetOnElevator, AllOptions.First(k => k.Key == RiderOptionTypes.GetOnElevator).Value);
}
break;
case RiderStates.OnElevator:
retVal.Add(RiderOptionTypes.PressElevatorButton, AllOptions.First(k => k.Key == RiderOptionTypes.PressElevatorButton).Value);
retVal.Add(RiderOptionTypes.Sneeze, AllOptions.First(k => k.Key == RiderOptionTypes.Sneeze).Value);
retVal.Add(RiderOptionTypes.GetOffElevator, AllOptions.First(k => k.Key == RiderOptionTypes.GetOffElevator).Value);
break;
case RiderStates.RidingElevator:
retVal.Add(RiderOptionTypes.Yell, AllOptions.First(k => k.Key == RiderOptionTypes.Yell).Value);
retVal.Add(RiderOptionTypes.Sneeze, AllOptions.First(k => k.Key == RiderOptionTypes.Sneeze).Value);
break;
default:
break;
}
return(retVal);
}
public SymbolGenerator(ILogger <SymbolGenerator> logger, IOptions <AllOptions> options, IRandomNumberGenerator generator)
{
_logger = logger;
_options = options.Value;
_generator = generator;
}
/// <summary>
/// Adds rest models middleware to the app using already built <see cref="RestModelOptions{TModel, TUser}" />. Not
/// intended for application use.
/// </summary>
/// <typeparam name="TModel">The type of model to use with the API</typeparam>
/// <typeparam name="TUser">The user to authenticate with the API</typeparam>
/// <param name="app">The app to add rest models to</param>
/// <param name="options">The options for rest models, keyed to their route patterns</param>
/// <returns>The same <see cref="IApplicationBuilder" />, for chaining</returns>
public static IApplicationBuilder UseRestModels <TModel, TUser>(
this IApplicationBuilder app,
Dictionary <string, List <RestModelOptions <TModel, TUser> > > options)
where TModel : class where TUser : class
{
app.UseRouting().UseEndpoints(
builder => {
// todo: eventually find a better way to do this, probably drag things out into objects and out of this extension class
// routes are grouped by their route pattern
foreach ((string RoutePattern, List <RestModelOptions <TModel, TUser> > AllOptions) in options)
{
// only build routes with result writers and req methods
// call routes with auth providers first
RestModelOptions <TModel, TUser>[] Valid = AllOptions
.Where(o => o.ResultWriter != null && o.RequestMethods != null)
.OrderByDescending(o => o.AuthProviders?.Count ?? 0).ToArray();
if (Valid.Length == 0)
{
continue;
}
// req methods can't be null b/c of Valid up there ^
HashSet <string> HttpMethods = Valid.Select(o => o.RequestMethods !)
.Aggregate((total, next) => total.Concat(next).ToHashSet());
IEndpointConventionBuilder EndpointBuilder = builder.MapMethods(
RoutePattern,
HttpMethods,
async context => {
Stopwatch Stopwatch = new Stopwatch();
Stopwatch.Start();
RestModelOptions <TModel, TUser>[] RequestOptions = Valid.Where(
o => o.RequestMethods.Any(
m => string.Equals(
context.Request.Method,
m,
StringComparison.OrdinalIgnoreCase))).ToArray();
for (int i = 0; i < RequestOptions.Length; i++)
{
RestModelOptions <TModel, TUser> Options = RequestOptions[i];
RestModelMiddleware <TModel, TUser> Middleware =
new RestModelMiddleware <TModel, TUser>(Options);
bool HasNext = i != RequestOptions.Length - 1;
if (!await Middleware.TryHandleRequest(context, HasNext))
{
break;
}
}
Stopwatch.Stop();
Debug.WriteLine($"total elapsed: {Stopwatch.ElapsedMilliseconds}");
});
foreach (RestModelOptions <TModel, TUser> Options in Valid)
{
Options.RouteOptionsHandler?.Invoke(EndpointBuilder);
}
}
});
return(app);
}
public void checkstate()
{
Text text = InfoModeText.GetComponent <Text>();
if (gm.state == "Options")
{
text.text = "Options";
AllOptions.SetActive(true);
PoseWavePanel.SetActive(false);
modepanel.SetActive(false);
}
else if (gm.state == "Information")
{
text.text = "Information";
AllOptions.SetActive(false);
PoseWavePanel.SetActive(false);
modepanel.SetActive(false);
}
else if (gm.state == "SwitchingPose")
{
text.text = "Here you can choose needed mode or pose";
AllOptions.SetActive(false);
PoseWavePanel.SetActive(true);
for (int i = 0; i < 5; i++)
{
ModeButtons[i].interactable = false;
ModeButtons[i].GetComponent <Image>().color = new Color(1, 1, 1, 0.5f);
ModeButtons[5].interactable = true;
ModeButtons[5].GetComponent <Image>().color = new Color(1, 1, 1, 1);
}
if (Input.touchCount > 0)
{
Touch touch = Input.GetTouch(0);
if (touch.phase == TouchPhase.Began)
{
beginpoint = touch.position;
}
else if (touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Moved)
{
endpoint = touch.position;
touchdirection = (endpoint - beginpoint).normalized;
PoseWavePanel.transform.Translate(new Vector3(touchdirection.x, 0, 0) * 1000 * Time.deltaTime);
}
}
// gm.mode = null;
}
else if (gm.state == "Quit")
{
text.text = "Quitting from app.\n Please wait untill calibration";
text.color = Color.red;
MotionPanel.SetActive(false);
StartStopPanel.SetActive(false);
AllOptions.SetActive(false);
PoseWavePanel.SetActive(false);
anglepanel.SetActive(false);
foreach (Button mode in ModeButtons)
{
mode.interactable = false;
}
gm.mode = null;
foreach (Button option in OptionButtons)
{
option.GetComponent <Button>().interactable = false;
}
}
else if (gm.state == "Chair" || gm.state == "ModifiedChair" || gm.state == "Dinner" || gm.state == "Verticalize" || gm.state == "AntiModifiedChair")
{
text.text = "Calibrating to " + gm.state + " position";
gm.mode = null;
foreach (Button option in OptionButtons)
{
option.GetComponent <Button>().interactable = false;
}
foreach (Button mode in ModeButtons)
{
mode.GetComponent <Button>().interactable = false;
}
StartStopPanel.SetActive(false);
MotionPanel.SetActive(false);
PoseWavePanel.SetActive(false);
}
else
{
if (gm.state != "Calibrating")
{
modepanel.SetActive(true);
AllOptions.SetActive(false);
PoseWavePanel.SetActive(false);
foreach (Button option in OptionButtons)
{
option.GetComponent <Button>().interactable = true;
}
}
}
}
