public static ICollection <TXpObj> GetCollectionXpObj <TXpObj>(int top = 100) where TXpObj : XPLiteObject, IPersistentBase
{
List <TXpObj> objects;
try
{
var classInfoTxpObj = Session.GetClassInfo(typeof(TXpObj));
objects = GetListObjects <TXpObj>(top, classInfoTxpObj);
if (!objects.Any())
{
var method = typeof(TXpObj).GetMethod("InitializeNewDb");
object[] param = { Session };
if (method != null)
{
method.Invoke(null, param);
}
objects = GetListObjects <TXpObj>(top, classInfoTxpObj);
}
}
catch (Exception e)
{
LogHolder.LogError(e);
throw;
}
return(objects);
}
public PseudonymizationProviderFactory()
{
var logHolder = new LogHolder();
logHolder.AddLogger(new Tracer());
_logger = logHolder;
}
public override void Write(LogHolder log)
{
if (OnLogWrite != null)
{
OnLogWrite(this, new LogEventArgs(log.Time, log.Type, log.Name, log.Message));
}
}
internal List <Balance> TrySaveBalance()
{
List <Balance> balance = null;
try
{
balance = SaveBalance();
var averageHashrate = _nanopoolXmr.GetAverageHashrate(XmrAccount);
if (averageHashrate.Status && Equals(averageHashrate.Data.H1, 0f))
{
RestastMiner();
}
//if (balance.All(b => b.Status))
//{
// LogHolder.MainLogWarning(_tbBalance.Text);
//}
var volumeUsd = balance.Aggregate("",
(current, b) => current + $"{b.Currency.Short}:{b.Volume:F5}{Environment.NewLine}");
//LogHolder.MainLogWarning(!string.IsNullOrEmpty(volumeUsd) ? volumeUsd : "Подключенья нет");
}
catch (Exception ex)
{
LogHolder.LogError(ex);
}
return(balance);
}
void Start()
{
Time.timeScale = GameSpeed;
gameTimeCounter = GameTime;
logHolder = new LogHolder();
menu.SetActive(false);
play.gameObject.SetActive(false);
whiteScreen.canvasRenderer.SetAlpha(0.0f);
}
private static void ConfigureLogging(WebHostBuilderContext hostingContext, ILoggingBuilder loggingBuilder)
{
loggingBuilder.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
loggingBuilder.AddConsole();
loggingBuilder.AddDebug();
LayoutRenderer.Register("basedir", (logEvent) => hostingContext.HostingEnvironment.ContentRootPath);
LayoutRenderer.Register <AspNetBuildDateLayoutRenderer>("custom-build-date");
LogHolder.Init(new NLogFactory());
}
public override void Write(LogHolder log)
{
string filePath = Path.Combine(Environment.CurrentDirectory, "Log", SafeName(log.Name), dateString + ".txt");
string dirPath = Path.GetDirectoryName(filePath);
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
File.AppendAllText(filePath, $"{log.Time} - {log.Type.ToString().ToUpperInvariant()} - {log.Name}: {log.Message}" + Environment.NewLine);
}
private static TXpObj GetLastBalance <TXpObj>(Currency currency) where TXpObj : XPLiteObject, IPersistentBase
{
List <TXpObj> objects;
try
{
var classInfoTxpObj = Session.GetClassInfo(typeof(TXpObj));
objects = Session.GetObjects(classInfoTxpObj, CriteriaOperator.Parse("[Currency] = ?", currency.Id), new SortingCollection(new SortProperty("Id", SortingDirection.Descending)), 1, false, false).Cast <TXpObj>().ToList();
}
catch (Exception e)
{
LogHolder.LogError(e);
throw;
}
return(objects.FirstOrDefault());
}
private List <Balance> SaveBalance()
{
var balanceEth = _nanopoolEth.GetAccountBalance(EthAccount);
var result = new List <Balance>();
string infoArray = "";
result.Add(Domain.SaveBalance(balanceEth, Delay, CurrencyTypeEnum.ethereum, ref infoArray));
var balanceXmr = _nanopoolXmr.GetAccountBalance(XmrAccount);
result.Add(Domain.SaveBalance(balanceXmr, Delay, CurrencyTypeEnum.monero, ref infoArray));
if (!string.IsNullOrEmpty(infoArray))
{
LogHolder.MainLogInfo(infoArray);
}
return(result);
}
public override void OnEvent(ItemHolderAddItem evnt)
{
if (evnt.Target)
{
rockThrowerItemHolder componentInChildren = evnt.Target.GetComponentInChildren <rockThrowerItemHolder>();
if (componentInChildren)
{
componentInChildren.AddItemMP(evnt.ContentType);
return;
}
MultiThrowerItemHolder componentInChildren2 = evnt.Target.GetComponentInChildren <MultiThrowerItemHolder>();
if (componentInChildren2)
{
componentInChildren2.AddItemMP(evnt.ContentType);
return;
}
LogHolder componentInChildren3 = evnt.Target.GetComponentInChildren <LogHolder>();
if (componentInChildren3)
{
componentInChildren3.AddItemMP(evnt.RaisedBy);
}
else
{
ItemHolder componentInChildren4 = evnt.Target.GetComponentInChildren <ItemHolder>();
if (componentInChildren4)
{
componentInChildren4.AddItemMP();
}
else
{
MultiHolder[] componentsInChildren = evnt.Target.GetComponentsInChildren <MultiHolder>(true);
if (componentsInChildren.Length > 0)
{
componentsInChildren[0].AddItemMP((MultiHolder.ContentTypes)evnt.ContentType, evnt.RaisedBy);
}
}
}
}
}
public override void Write(LogHolder log)
{
Console.ResetColor();
Console.Write("{0} - ", log.Time);
switch (log.Type)
{
case LogType.Debug:
Console.ForegroundColor = ConsoleColor.Gray;
break;
case LogType.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LogType.Fatal:
Console.ForegroundColor = ConsoleColor.DarkRed;
break;
case LogType.Info:
Console.ForegroundColor = ConsoleColor.Cyan;
break;
case LogType.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case LogType.Success:
Console.ForegroundColor = ConsoleColor.Green;
break;
}
Console.Write(log.Type.ToString().ToUpperInvariant());
Console.ResetColor();
Console.WriteLine(" - {0}: {1}", log.Name, log.Message);
}
public override void OnEvent(ItemHolderTakeItem evnt)
{
if (evnt.Target)
{
rockThrowerItemHolder componentInChildren = evnt.Target.GetComponentInChildren <rockThrowerItemHolder>();
if (componentInChildren)
{
componentInChildren.TakeItemMP(evnt.Player, evnt.ContentType);
return;
}
MultiThrowerItemHolder componentInChildren2 = evnt.Target.GetComponentInChildren <MultiThrowerItemHolder>();
if (componentInChildren2)
{
componentInChildren2.TakeItemMP(evnt.Player, evnt.ContentType);
return;
}
LogHolder componentInChildren3 = evnt.Target.GetComponentInChildren <LogHolder>();
if (componentInChildren3)
{
componentInChildren3.TakeItemMP(evnt.Player);
return;
}
ItemHolder componentInChildren4 = evnt.Target.GetComponentInChildren <ItemHolder>();
if (componentInChildren4)
{
componentInChildren4.TakeItemMP(evnt.Player);
return;
}
MultiHolder[] componentsInChildren = evnt.Target.GetComponentsInChildren <MultiHolder>(true);
if (componentsInChildren.Length > 0)
{
componentsInChildren[0].TakeItemMP(evnt.Player, (MultiHolder.ContentTypes)evnt.ContentType);
return;
}
}
}
protected void Page_PreRender(object sender, EventArgs e)
{
var pageNumber = GetPageNumber();
var pageSize = GetPageSize();
using (var connection = new DataConnection())
{
Expression <Func <ITask, bool> > taskFilter = t => true;
Expression <Func <ITaskTarget, bool> > targetFilter = t => true;
if (!string.IsNullOrWhiteSpace(Username.Text))
{
taskFilter = taskFilter.And(d => d.Username.Contains(Username.Text));
}
if (LogType.SelectedValue != "All" && !string.IsNullOrWhiteSpace(LogType.SelectedValue))
{
taskFilter = taskFilter.And(d => d.TaskType == LogType.SelectedValue);
}
if (DataType.SelectedValue != "All" && !string.IsNullOrWhiteSpace(DataType.SelectedValue))
{
targetFilter = targetFilter.And(d => d.TargetDataSourceId.Contains(string.Format(@"_interfaceType_='{0}'", DataType.SelectedValue.Replace(".", @"\."))));
}
var activities = from t in connection.Get <ITask>().Where(taskFilter)
join tt in connection.Get <ITaskTarget>().Where(targetFilter) on t.TaskTargetId equals tt.Id
join a in connection.Get <IActivity>() on t.Id equals a.TaskId into ats
from at in ats.DefaultIfEmpty()
select new
{
Time = at == null ? t.StartTime : at.ActivityTime,
t.Username,
t.TaskType,
ActivityType = at == null ? null : at.ActivityType,
t.CultureName,
TaskTarget = tt,
Activity = at
};
var from = FromDateWidget.SelectedDate;
var to = ToDateWidget.SelectedDate;
activities = activities.Where(d => d.Time >= from && d.Time < to.AddDays(1));
activities = activities.Where(item => !(item.ActivityType == null &&
new[] { "edit", "add", "rollback", "delete" }.Contains(item.TaskType.ToLower())))
.OrderByDescending(d => d.Time);
switch (SortColumn)
{
case Column.Time:
activities = SortDirection == SortDirection.Ascending
? activities.OrderBy(d => d.Time)
: activities.OrderByDescending(d => d.Time);
break;
case Column.User:
activities = SortDirection == SortDirection.Ascending
? activities.OrderBy(d => d.Username)
: activities.OrderByDescending(d => d.Username);
break;
case Column.Task:
activities = SortDirection == SortDirection.Ascending
? activities.OrderBy(d => d.TaskType)
: activities.OrderByDescending(d => d.TaskType);
break;
}
string eventTarget = Request.Form["__EVENTTARGET"];
if (eventTarget == "export")
{
var workbook = new Workbook();
var worksheet = new Worksheet("Sheet1")
{
GenerateXmlMap = true
};
workbook.Worksheets.Add(worksheet);
Func <string, Type, XlsColumn> column = (label, type) =>
new XlsColumn(SR.GetString(LocalizationFileName, label), type);
var columns = new List <XlsColumn>
{
column("Table.HeadingTime", typeof(DateTime)),
column("Table.HeadingUser", typeof(string)),
column("Table.HeadingTask", typeof(string)),
column("Table.HeadingActivity", typeof(string)),
column("Table.HeadingTitle", typeof(string)),
column("Table.HeadingType", typeof(string))
};
if (IsMultiLocale)
{
columns.Add(new XlsColumn(SR.GetString("Composite.Plugins.XsltBasedFunction", "EditXsltFunction.LabelActiveLocales"), typeof(string)));
}
worksheet.Columns.AddRange(columns);
foreach (var item in activities)
{
var parameters = new object[]
{
item.Time,
item.Username ?? string.Empty,
item.TaskType != null?GetTaskLabel(item.TaskType) : string.Empty,
item.ActivityType != null?GetActivityLabel(item.ActivityType) : string.Empty,
GetTitle(item.TaskTarget),
GetTargetType(item.TaskTarget)
};
if (IsMultiLocale)
{
parameters = parameters.Concat(new object[] { GetCulture(item.CultureName) }).ToArray();
}
worksheet.AddRow(parameters);
}
workbook.WriteToResponse(Context, string.Format("ContentModificationLog-{0:yyyy-MM-dd-HH-mm}.xls", DateTime.Now));
return;
}
activities = activities.Skip(pageSize * (pageNumber - 1)).Take(pageSize + 1);
PrevPage.Attributes["client_isdisabled"] = (pageNumber == 1).ToString().ToLower();
NextPage.Attributes["client_isdisabled"] = (activities.Count() <= pageSize).ToString().ToLower();
var result = activities.Take(pageSize).ToList();
LogHolder.DataSource = result.Select(d =>
new
{
d.Time,
d.Username,
d.ActivityType,
ActivityLabel = string.IsNullOrEmpty(d.ActivityType) ? "" : GetActivityLabel(d.ActivityType),
d.TaskType,
TaskLabel = GetTaskLabel(d.TaskType),
Title = GetTitle(d.TaskTarget),
EntityToken = GetEntityToken(d.TaskTarget),
TargetType = GetTargetType(d.TaskTarget),
d.CultureName,
RestoreAction = GetRestoreAction(d.Activity)
}).ToList();
LogHolder.DataBind();
}
SetPageNumber(pageNumber);
}
private static void AdaptOffRules(LogHolder log, Strategy strategy)
{
int goalIndex = -1;
int row = log.positions.Count - 1;
PositionsHolder p = log.positions[row];
int rule = p.lRule;
string score = p.score;
int ballX = Convert.ToInt16(p.ballPosition.X);
int ballY = Convert.ToInt16(p.ballPosition.Y);
if (row <= 1)
{
return;
}
//ball is before the opponents gate
if (ballX == 6 && (ballY == 2 || ballY == 3))
{
ballWasInGate = true;
}
//somewhere else
else
{
//failed goal atempt
if (ballWasInGate && score == log.positions[row - 1].score)
{
goalIndex = row - 1;
}
ballWasInGate = false;
}
if (goalIndex != -1)
{
//extract lookupLines
int from = -1;
int to = goalIndex;
if ((to - lookBackLines) < 0)
{
from = 0;
}
else
{
from = to - lookBackLines;
}
//extract rules
for (int off = from; off < to; off += ruleOffset)
{
int[] sumValues = new int[18];
double[] avgValues = new double[18];
for (int i = 0 + off; i < ruleOffset + off; i++)
{
int j = 0;
sumValues[j++] += Convert.ToInt16(log.positions[i].ballPosition.X);
sumValues[j++] += Convert.ToInt16(log.positions[i].ballPosition.Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[0].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[0].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[1].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[1].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[2].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[2].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[3].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[3].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[0].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[0].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[1].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[1].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[2].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[2].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[3].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[3].Y);
}
//avg from ruleOffset lines
for (int i = 0; i < 18; i++)
{
avgValues[i] = sumValues[i] / Convert.ToDouble(ruleOffset);
avgValues[i] = Math.Round(avgValues[i]);
}
//transform to rule
Rule rl = new Rule();
int ii = 0;
rl.ballX = Convert.ToInt16(avgValues[ii++]);
rl.ballY = Convert.ToInt16(avgValues[ii++]);
rl.lr0x = Convert.ToInt16(avgValues[ii++]);
rl.lr0y = Convert.ToInt16(avgValues[ii++]);
rl.lr1x = Convert.ToInt16(avgValues[ii++]);
rl.lr1y = Convert.ToInt16(avgValues[ii++]);
rl.lr2x = Convert.ToInt16(avgValues[ii++]);
rl.lr2y = Convert.ToInt16(avgValues[ii++]);
rl.lr3x = Convert.ToInt16(avgValues[ii++]);
rl.lr3y = Convert.ToInt16(avgValues[ii++]);
rl.rr0x = Convert.ToInt16(avgValues[ii++]);
rl.rr0y = Convert.ToInt16(avgValues[ii++]);
rl.rr1x = Convert.ToInt16(avgValues[ii++]);
rl.rr1y = Convert.ToInt16(avgValues[ii++]);
rl.rr2x = Convert.ToInt16(avgValues[ii++]);
rl.rr2y = Convert.ToInt16(avgValues[ii++]);
rl.rr3x = Convert.ToInt16(avgValues[ii++]);
rl.rr3y = Convert.ToInt16(avgValues[ii++]);
//set default moveto
rl.lr0mx = rl.lr0x;
rl.lr0my = rl.lr0y;
rl.lr1mx = rl.lr1x;
rl.lr1my = rl.lr1y;
rl.lr2mx = rl.lr2x;
rl.lr2my = rl.lr2y;
rl.lr3mx = rl.lr3x;
rl.lr3my = rl.lr3y;
//send two closest robots to oponnents gate
int selRobot = -1;
int selRobot2 = -1;
int minX = Int16.MaxValue;
int minY = Int16.MaxValue;
int[] robotsL = new int[] { rl.lr0x, rl.lr0y, rl.lr1x, rl.lr1y, rl.lr2x, rl.lr2y, rl.lr3x, rl.lr3y };
for (int i = 0; i < robotsL.Length; i = i + 2)
{
int distX = 6 - robotsL[i];
int distY = 3 - robotsL[i + 1];
if (distX <= minX && distY <= minY)
{
minX = distX;
minY = distY;
selRobot = i / 2;
}
}
//find second robot
robotsL[selRobot * 2] = 0;
robotsL[(selRobot * 2) + 1] = 0;
minX = Int16.MaxValue;
minY = Int16.MaxValue;
for (int i = 0; i < robotsL.Length; i = i + 2)
{
int distX = 6 - robotsL[i];
int distY = 2 - robotsL[i + 1];
if (distX <= minX && distY <= minY)
{
minX = distX;
minY = distY;
selRobot2 = i / 2;
}
}
//change moveto for selected robot
switch (selRobot)
{
case 0:
{
rl.lr0mx = 6;
rl.lr0my = 3;
break;
}
case 1:
{
rl.lr1mx = 6;
rl.lr1my = 3;
break;
}
case 2:
{
rl.lr2mx = 6;
rl.lr2my = 3;
break;
}
case 3:
{
rl.lr3mx = 6;
rl.lr3my = 3;
break;
}
}
//change moveto for selected robot
switch (selRobot2)
{
case 0:
{
rl.lr0mx = 6;
rl.lr0my = 2;
break;
}
case 1:
{
rl.lr1mx = 6;
rl.lr1my = 2;
break;
}
case 2:
{
rl.lr2mx = 6;
rl.lr2my = 2;
break;
}
case 3:
{
rl.lr3mx = 6;
rl.lr3my = 2;
break;
}
}
//check if the rule is not already created
int il = adaptationOffRules.FindIndex(f =>
f.ballX == rl.ballX && f.ballY == rl.ballY &&
f.lr0x == rl.lr0x && f.lr0y == rl.lr0y &&
f.lr1x == rl.lr1x && f.lr1y == rl.lr1y &&
f.lr2x == rl.lr2x && f.lr2y == rl.lr2y &&
f.lr3x == rl.lr3x && f.lr3y == rl.lr3y &&
f.rr0x == rl.rr0x && f.rr0y == rl.rr0y &&
f.rr1x == rl.rr1x && f.rr1y == rl.rr1y &&
f.rr2x == rl.rr2x && f.rr2y == rl.rr2y &&
f.rr3x == rl.rr3x && f.rr3y == rl.rr3y
);
if (il == -1)
{
//rule strategy check
int istr = strategy.GStrategy.Rules.FindIndex(f =>
f.Ball.X == rl.ballX && f.Ball.Y == rl.ballY &&
f.Mine[0].X == rl.lr0x && f.Mine[0].Y == rl.lr0y &&
f.Mine[1].X == rl.lr1x && f.Mine[1].Y == rl.lr1y &&
f.Mine[2].X == rl.lr2x && f.Mine[2].Y == rl.lr2y &&
f.Mine[3].X == rl.lr3x && f.Mine[3].Y == rl.lr3y &&
f.Oppnt[0].X == rl.rr0x && f.Oppnt[0].Y == rl.rr0y &&
f.Oppnt[1].X == rl.rr1x && f.Oppnt[1].Y == rl.rr1y &&
f.Oppnt[2].X == rl.rr2x && f.Oppnt[2].Y == rl.rr2y &&
f.Oppnt[3].X == rl.rr3x && f.Oppnt[3].Y == rl.rr3y
);
if (istr == -1)
{
rl.ruleNum = ++ruleNum;
adaptationOffRules.Add(rl);
}
else
{
++discardedOffrules;
}
}
else
{
++discardedOffrules;
}
}
}
}
private static void AdaptDefRules(LogHolder log, Strategy strategy)
{
int goalIndex = -1;
int row = log.positions.Count - 1;
PositionsHolder p = log.positions[row];
int rule = p.lRule;
string score = p.score;
if (row <= 1)
{
return;
}
if (score != log.positions[row - 1].score)
{
//goal
string[] lastScoreSplit = log.positions[row - 1].score.Split(':');
int lastGoalsL = Convert.ToInt16(lastScoreSplit[0]);
int lastGoalsR = Convert.ToInt16(lastScoreSplit[1]);
string[] scoreSplit = score.Split(':');
int goalsL = Convert.ToInt16(scoreSplit[0]);
int goalsR = Convert.ToInt16(scoreSplit[1]);
//right team scored goal
if (lastGoalsL == goalsL && lastGoalsR < goalsR)
{
goalIndex = row;
}
}
if (goalIndex != -1)
{
//extract lookupLines
int from = -1;
int to = goalIndex;
if ((to - lookBackLines) < 0)
{
from = 0;
}
else
{
from = to - lookBackLines;
}
//extract rules
for (int off = from; off < to; off += ruleOffset)
{
int[] sumValues = new int[18];
double[] avgValues = new double[18];
for (int i = 0 + off; i < ruleOffset + off; i++)
{
int j = 0;
sumValues[j++] += Convert.ToInt16(log.positions[i].ballPosition.X);
sumValues[j++] += Convert.ToInt16(log.positions[i].ballPosition.Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[0].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[0].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[1].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[1].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[2].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[2].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[3].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].leftPlayerRobots[3].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[0].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[0].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[1].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[1].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[2].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[2].Y);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[3].X);
sumValues[j++] += Convert.ToInt16(log.positions[i].rightPlayerRobots[3].Y);
}
//avg from ruleOffset lines
for (int i = 0; i < 18; i++)
{
avgValues[i] = sumValues[i] / Convert.ToDouble(ruleOffset);
avgValues[i] = Math.Round(avgValues[i]);
}
//transform to rule
Rule rl = new Rule();
int ii = 0;
rl.ballX = Convert.ToInt16(avgValues[ii++]);
rl.ballY = Convert.ToInt16(avgValues[ii++]);
rl.lr0x = Convert.ToInt16(avgValues[ii++]);
rl.lr0y = Convert.ToInt16(avgValues[ii++]);
rl.lr1x = Convert.ToInt16(avgValues[ii++]);
rl.lr1y = Convert.ToInt16(avgValues[ii++]);
rl.lr2x = Convert.ToInt16(avgValues[ii++]);
rl.lr2y = Convert.ToInt16(avgValues[ii++]);
rl.lr3x = Convert.ToInt16(avgValues[ii++]);
rl.lr3y = Convert.ToInt16(avgValues[ii++]);
rl.rr0x = Convert.ToInt16(avgValues[ii++]);
rl.rr0y = Convert.ToInt16(avgValues[ii++]);
rl.rr1x = Convert.ToInt16(avgValues[ii++]);
rl.rr1y = Convert.ToInt16(avgValues[ii++]);
rl.rr2x = Convert.ToInt16(avgValues[ii++]);
rl.rr2y = Convert.ToInt16(avgValues[ii++]);
rl.rr3x = Convert.ToInt16(avgValues[ii++]);
rl.rr3y = Convert.ToInt16(avgValues[ii++]);
int il = adaptationDefRules.FindIndex(f =>
f.ballX == rl.ballX && f.ballY == rl.ballY &&
f.lr0x == rl.lr0x && f.lr0y == rl.lr0y &&
f.lr1x == rl.lr1x && f.lr1y == rl.lr1y &&
f.lr2x == rl.lr2x && f.lr2y == rl.lr2y &&
f.lr3x == rl.lr3x && f.lr3y == rl.lr3y &&
f.rr0x == rl.rr0x && f.rr0y == rl.rr0y &&
f.rr1x == rl.rr1x && f.rr1y == rl.rr1y &&
f.rr2x == rl.rr2x && f.rr2y == rl.rr2y &&
f.rr3x == rl.rr3x && f.rr3y == rl.rr3y
);
if (il == -1)
{
//rule strategy check
int istr = strategy.GStrategy.Rules.FindIndex(f =>
f.Ball.X == rl.ballX && f.Ball.Y == rl.ballY &&
f.Mine[0].X == rl.lr0x && f.Mine[0].Y == rl.lr0y &&
f.Mine[1].X == rl.lr1x && f.Mine[1].Y == rl.lr1y &&
f.Mine[2].X == rl.lr2x && f.Mine[2].Y == rl.lr2y &&
f.Mine[3].X == rl.lr3x && f.Mine[3].Y == rl.lr3y &&
f.Oppnt[0].X == rl.rr0x && f.Oppnt[0].Y == rl.rr0y &&
f.Oppnt[1].X == rl.rr1x && f.Oppnt[1].Y == rl.rr1y &&
f.Oppnt[2].X == rl.rr2x && f.Oppnt[2].Y == rl.rr2y &&
f.Oppnt[3].X == rl.rr3x && f.Oppnt[3].Y == rl.rr3y
);
if (istr == -1)
{
rl.ruleNum = ++ruleNum;
//set moveto
rl.lr0mx = rl.lr0x;
rl.lr0my = rl.lr0y;
rl.lr1mx = rl.lr1x;
rl.lr1my = rl.lr1y;
rl.lr2mx = rl.ballX;
rl.lr2my = rl.ballY;
rl.lr3mx = rl.ballX;
rl.lr3my = rl.ballY;
adaptationDefRules.Add(rl);
}
else
{
++discardedDefrules;
}
}
else
{
++discardedDefrules;
}
}
}
}
public abstract void Write(LogHolder log);
public List <object> AdaptStrategy(LogHolder log, object strategy)
{
discardedDefrules = 0;
discardedOffrules = 0;
adaptationDefRules.Clear();
adaptationOffRules.Clear();
ruleNum = (int)strategy.GetType().GetMethod("CurrentRuleNumberCount").Invoke(strategy, null);
//def adapt
try
{
AdaptDefRules(log, (Strategy)strategy);
}
catch (Exception e)
{
Debug.Log(e.Message);
}
//off adapt
try
{
AdaptOffRules(log, (Strategy)strategy);
}
catch (Exception e)
{
Debug.Log(e.Message);
}
//complete list
List <object> adaptedRules = new List <object>();
//convert def rules
foreach (Rule r in adaptationDefRules)
{
GridRule gr = new GridRule();
gr.Number = r.ruleNum;
gr.Type = GridRule.RuleType.Deffense;
gr.Name = "AdaptedDef";
Vector2D[] vmine = new Vector2D[] {
new Vector2D(Convert.ToDouble(r.lr0x), Convert.ToDouble(r.lr0y)),
new Vector2D(Convert.ToDouble(r.lr1x), Convert.ToDouble(r.lr1y)),
new Vector2D(Convert.ToDouble(r.lr2x), Convert.ToDouble(r.lr2y)),
new Vector2D(Convert.ToDouble(r.lr3x), Convert.ToDouble(r.lr3y))
};
gr.Mine = vmine;
Vector2D[] voppnt = new Vector2D[] {
new Vector2D(Convert.ToDouble(r.rr0x), Convert.ToDouble(r.rr0y)),
new Vector2D(Convert.ToDouble(r.rr1x), Convert.ToDouble(r.rr1y)),
new Vector2D(Convert.ToDouble(r.rr2x), Convert.ToDouble(r.rr2y)),
new Vector2D(Convert.ToDouble(r.rr3x), Convert.ToDouble(r.rr3y))
};
gr.Oppnt = voppnt;
gr.Ball = new Vector2D(Convert.ToDouble(r.ballX), Convert.ToDouble(r.ballY));
Vector2D[] vmove = new Vector2D[] {
new Vector2D(Convert.ToDouble(r.lr0mx), Convert.ToDouble(r.lr0my)),
new Vector2D(Convert.ToDouble(r.lr1mx), Convert.ToDouble(r.lr1my)),
new Vector2D(Convert.ToDouble(r.lr2mx), Convert.ToDouble(r.lr2my)),
new Vector2D(Convert.ToDouble(r.lr3mx), Convert.ToDouble(r.lr3my))
};
gr.Move = vmove;
Debug.Log(gr.ToString());
gr.fillZOrder();
if (!RuleCheck(gr, (Strategy)strategy))
{
adaptedRules.Add(gr);
}
else
{
discardedDefrules++;
}
Debug.Log("Discarded def rules: " + discardedDefrules);
}
//convert off rules
foreach (Rule r in adaptationOffRules)
{
GridRule gr = new GridRule();
gr.Number = r.ruleNum;
gr.Type = GridRule.RuleType.Offense;
gr.Name = "AdaptedOff";
Vector2D[] vmine = new Vector2D[] {
new Vector2D(Convert.ToDouble(r.lr0x), Convert.ToDouble(r.lr0y)),
new Vector2D(Convert.ToDouble(r.lr1x), Convert.ToDouble(r.lr1y)),
new Vector2D(Convert.ToDouble(r.lr2x), Convert.ToDouble(r.lr2y)),
new Vector2D(Convert.ToDouble(r.lr3x), Convert.ToDouble(r.lr3y))
};
gr.Mine = vmine;
Vector2D[] voppnt = new Vector2D[] {
new Vector2D(Convert.ToDouble(r.rr0x), Convert.ToDouble(r.rr0y)),
new Vector2D(Convert.ToDouble(r.rr1x), Convert.ToDouble(r.rr1y)),
new Vector2D(Convert.ToDouble(r.rr2x), Convert.ToDouble(r.rr2y)),
new Vector2D(Convert.ToDouble(r.rr3x), Convert.ToDouble(r.rr3y))
};
gr.Oppnt = voppnt;
gr.Ball = new Vector2D(Convert.ToDouble(r.ballX), Convert.ToDouble(r.ballY));
Vector2D[] vmove = new Vector2D[] {
new Vector2D(Convert.ToDouble(r.lr0mx), Convert.ToDouble(r.lr0my)),
new Vector2D(Convert.ToDouble(r.lr1mx), Convert.ToDouble(r.lr1my)),
new Vector2D(Convert.ToDouble(r.lr2mx), Convert.ToDouble(r.lr2my)),
new Vector2D(Convert.ToDouble(r.lr3mx), Convert.ToDouble(r.lr3my))
};
gr.Move = vmove;
Debug.Log(gr.ToString());
gr.fillZOrder();
if (!RuleCheck(gr, (Strategy)strategy))
{
adaptedRules.Add(gr);
}
else
{
discardedOffrules++;
}
Debug.Log("Discarded off rules: " + discardedOffrules);
}
return(adaptedRules);
}
private void RestastMiner()
{
Process.Start("RestartXmr.bat");
LogHolder.MainLogInfo("Restart Xmr Miner");
}
