private List <StateJson> CalculateStates(List <ForecastJson> forecasts, decimal initialBank, decimal bet, int threadNumbers, bool allowIncreaseBets)
{
var lastState = new StateJson
{
Bank = initialBank,
InitialBet = bet,
Bets = Enumerable.Repeat(0M, threadNumbers).ToList(),
LoseValues = Enumerable.Repeat(0M, threadNumbers).ToList(),
LoseNumbers = Enumerable.Repeat(0, threadNumbers).ToList()
};
List <ForecastJson> previousForecasts = Enumerable.Repeat((ForecastJson)null, threadNumbers).ToList();
var results = new List <StateJson>();
SettingsJson settings = _dataService.GetSettings();
foreach (ForecastJson forecast in forecasts)
{
StateJson state =
CalculateNextAlgorithmState(forecast, previousForecasts[forecast.ThreadNumber], lastState,
settings: settings, allowIncreaseBet: allowIncreaseBets);
state.Id = forecast.GameAt.ToUnixTimeMilliseconds();
results.Add(state);
lastState = state;
previousForecasts[forecast.ThreadNumber] = forecast;
}
return(results);
}
public static StateJson Copy(this StateJson state)
{
return(new StateJson
{
Id = DateTimeOffset.Now.ToUnixTimeMilliseconds(),
Bank = state.Bank,
InitialBet = state.InitialBet,
Bets = state.Bets.ToList(),
LoseValues = state.LoseValues.ToList(),
LoseNumbers = state.LoseNumbers.ToList()
});
}
public async Task <IActionResult> SaveCurrentStateAsync(StateViewModel model)
{
StateJson state = _mapper.Map <StateViewModel, StateJson>(model);
if (state.LoseNumbers == null)
{
state.LoseNumbers = Enumerable.Repeat(0, model.LoseValues.Count).ToList();
}
await _dataService.SaveStateAsync(state);
return(Json("Ok"));
}
public IActionResult GetSettingsAndInfoPartial()
{
var model = new SettingsAndInfoViewModel();
StateJson lastState = _dataService.GetLastState();
SettingsJson settings = _dataService.GetSettings();
model.Settings = _mapper.Map <SettingsJson, SettingsViewModel>(settings);
model.LastState = _mapper.Map <StateJson, StateViewModel>(lastState);
model.LastState.ThreadNumbers = settings.ThreadNumbers;
InitializeBetAndBankValueLimits(model);
return(PartialView("_SettingsAndInfoPartial", model));
}
private void SetNewInitialBetValue(StateJson state, SettingsJson settings)
{
var options = new CalculateBetValueOptions
{
InitialBet = state.InitialBet,
LowerBound = settings?.LowerBound,
UpperBound = settings?.UpperBound,
ThreadNumbers = settings?.ThreadNumbers ?? 4,
IncreaseBetStep = settings?.BetValueIncreaseStep ?? 0.01M,
CoefficientBankReserve = settings?.CoefficientBankReserve ?? 0,
Bank = state.Bank,
CalculationMethod = settings?.CalculationMethod ?? CalculationMethod.Max
};
state.InitialBet = CalculateBetValue(options);
}
private CalculateBankValueResult CalculateBankValue(List <ForecastJson> forecasts, decimal bet,
double coefficientBankReserve, int threadNumbers)
{
List <StateJson> states = CalculateStates(forecasts, 0, bet, threadNumbers, false);
StateJson maxState = states.OrderByDescending(x => x.Bets.Sum() + x.LoseValues.Sum()).FirstOrDefault();
decimal maxBank = maxState?.Bets.Sum() + maxState?.LoseValues.Sum() ?? 0;
maxBank += maxBank * (decimal)coefficientBankReserve;
return(new CalculateBankValueResult
{
Bank = Math.Ceiling(maxBank),
ForecastId = maxState?.ForecastId
});
}
private async Task InitializeBetValues(List <ForecastViewModel> model)
{
SettingsJson settings = _dataService.GetSettings();
for (int i = 0; i < settings.ThreadNumbers; i++)
{
ForecastViewModel currentForecast = model.LastOrDefault(x =>
x.ThreadNumber == i && x.GameResultType == GameResultType.Expectation);
if (currentForecast == null || currentForecast.BetValue > 0)
{
continue;
}
StateJson state = await _algorithmService.CalculateNextStateAsync(currentForecast.Id,
allowIncreaseBet : settings.AllowIncreaseBetValue);
currentForecast.BetValue = state.Bets[i];
}
}
private async Task SaveForecastBetsAsync(List <ForecastViewModel> forecasts)
{
IEnumerable <ForecastViewModel> query = forecasts
.Where(x => x.SaveBet && x.GameResultType == GameResultType.Expectation && x.AllowModification)
.Reverse();
List <StateJson> states = new List <StateJson>();
StateJson lastState = null;
foreach (var forecast in query)
{
StateJson state = await _algorithmService.CalculateNextStateAsync(forecast.Id, forecast.BetValue, lastState : lastState);
lastState = state;
forecast.AllowModification = false;
states.Add(state);
}
await _dataService.SaveStateAsync(states.ToArray());
}
void ThreadFunc()
{
//listener = new HttpListener();
////listener.Prefixes.Add("http://+:8081/");
//listener.Prefixes.Add("http://localhost:8081/");
//listener.Prefixes.Add("http://127.0.0.1:8081/");
//listener.Start();
//while (working)
//{
// try
// {
// var context = listener.GetContext();
// ThreadPool.QueueUserWorkItem(o => HandleRequest(context));
// }
// catch (Exception)
// {
// // Ignored for this example
// }
//}
//listener.Close();
//TinyWeb.WebServer webServer = new TinyWeb.WebServer();
//webServer.EndPoint = new IPEndPoint(0, 8081);
//webServer.ProcessRequest += new TinyWeb.ProcessRequestEventHandler(this.webServer_ProcessRequest);
//webServer.IsStarted = true;
using (var server = new NHttp.HttpServer())
{
server.RequestReceived += (s, e) =>
{
using (System.IO.BinaryWriter writer = new BinaryWriter(e.Response.OutputStream))
{
string cmd = e.Request.RawUrl;
try
{
// The response must be written to e.Response.OutputStream.
// When writing text, a StreamWriter can be used.
if (cmd == "/ver")
{
UpgradeHelper helper = new UpgradeHelper();
string baseVersion;
string latestVersion;
string[] vers;
string currentVersion;
helper.ShowVersion(out baseVersion, out latestVersion, out vers, out currentVersion);
VersionJson json = new VersionJson();
json.baseVersion = baseVersion;
json.latestVersion = latestVersion;
json.vers = vers;
json.currentVersion = currentVersion;
json.state = "success";
string jsonString;
jsonString = JsonMapper.ToJson(json);
var data = Encoding.UTF8.GetBytes(jsonString);
writer.Write(data, 0, data.Length);
}
else if (cmd == "/upgrade")
{
string progressName = "\nu准备升级";
AsyncServer.Instance.SetProgress(progressName, 0);
StateJson json = new StateJson();
if (upgrading)
{
json.state = "already launched";
}
else
{
Thread thread1 = new Thread(() =>
{
upgrading = true;
UpgradeHelper helper = new UpgradeHelper();
helper.Upgrade("");
upgrading = false;
});
thread1.Start();
json.state = "success";
}
string jsonString;
jsonString = JsonMapper.ToJson(json);
var data = Encoding.UTF8.GetBytes(jsonString);
writer.Write(data, 0, data.Length);
}
else if (cmd == "/progress")
{
string jsonString;
currentProgress.state = "success";
jsonString = JsonMapper.ToJson(currentProgress);
var data = Encoding.UTF8.GetBytes(jsonString);
writer.Write(data, 0, data.Length);
}
}
catch (Exception ex)
{
AsyncServer.Instance.SetProgress("Idle", 0);
string jsonString = "";
if (cmd == "/ver")
{
VersionJson json = new VersionJson();
json.state = "net error";
jsonString = JsonMapper.ToJson(json);
}
else if (cmd == "/upgrade")
{
StateJson json = new StateJson();
json.state = "net error";
jsonString = JsonMapper.ToJson(json);
}
else if (cmd == "/progress")
{
ProgressJson json = new ProgressJson();
json.state = "net error";
jsonString = JsonMapper.ToJson(json);
}
var data = Encoding.UTF8.GetBytes(jsonString);
writer.Write(data, 0, data.Length);
Console.WriteLine("Http Request Exception:" + ex.Message);
}
}
};
server.EndPoint = new IPEndPoint(IPAddress.Any, 8081);
server.Start();
while (true)
{
Thread.Sleep(1000);
}
}
}
private StateJson CalculateNextAlgorithmState(ForecastJson currentForecast, ForecastJson previousForecast,
StateJson lastState = null, SettingsJson settings = null, bool allowIncreaseBet = false, decimal?betValue = null)
{
if (currentForecast == null)
{
return(null);
}
if (lastState == null)
{
lastState = _dataService.GetLastState();
}
StateJson state = lastState.Copy();
state.ForecastId = currentForecast.Id;
if (previousForecast?.GameResultType == GameResultType.Expectation)
{
return(state);
}
int index = currentForecast.ThreadNumber;
if (allowIncreaseBet)
{
SetNewInitialBetValue(state, settings);
}
int numberOfLoses = CalculateNumberOfLoses(settings?.IncreaseBetValueWhenDefeat,
previousForecast?.GameResultType, state.LoseNumbers[index]);
if (previousForecast == null)
{
state.Bets[index] = betValue ?? GetBetValue(state.InitialBet, state.LoseValues[index], currentForecast.Coefficient,
settings?.BetValueRoundDecimals ?? 2, numberOfLoses);
state.Bank -= state.Bets[index];
return(state);
}
decimal result =
CalculateResult(lastState.Bets[index], previousForecast.GameResultType, previousForecast.Coefficient);
if (result < 0)
{
state.LoseValues[index] += lastState.Bets[index];
state.LoseNumbers[index] += 1;
}
else
{
if (previousForecast.GameResultType == GameResultType.Expectation)
{
state.Bank += lastState.Bets[index];
}
else
{
state.Bank += result;
}
if (previousForecast.GameResultType == GameResultType.Win)
{
state.LoseValues[index] = 0;
state.LoseNumbers[index] = 0;
}
}
state.Bets[index] = betValue ?? GetBetValue(state.InitialBet, state.LoseValues[index], currentForecast.Coefficient,
settings?.BetValueRoundDecimals ?? 2, numberOfLoses);
state.Bank -= state.Bets[index];
return(state);
}
public async Task <StateJson> CalculateNextStateAsync(long forecastId, decimal?betValue = null,
bool?allowIncreaseBet = null, StateJson lastState = null)
{
return(await Task.Run(() =>
{
ForecastJson forecast = _dataService.GetForecastBy(forecastId);
ForecastJson previousForecast = _dataService.GetLastCalculatedForecastByIndex(forecast.ThreadNumber);
SettingsJson settings = _dataService.GetSettings();
return CalculateNextAlgorithmState(forecast, previousForecast, lastState: lastState, settings: settings,
allowIncreaseBet: allowIncreaseBet ?? settings.AllowIncreaseBetValue, betValue: betValue);
}));
}
