public static void Demonstrate()
{
CheckTask ct = new CheckTask();
ct.Run(15);
DbCheckTask db = new DbCheckTask();
db.Run(5);
}
public void CheckBreakSingleAllowed()
{
var ct = new CheckTask(GetStorage());
var usages = new[]
{
new UsageLog(new TimeSpan(9, 0, 0), TimeSpan.FromMinutes(100)),
};
var res = ct.CheckKind(new CheckParameter(200, 30, usages));
Assert.AreEqual(UsageResultKind.NoRestriction, res);
}
public void CheckBreakSingleViolation()
{
var ct = new CheckTask(GetStorage());
var usages = new[]
{
new UsageLog(new TimeSpan(9, 0, 0), TimeSpan.FromMinutes(101)),
};
var res = ct.CheckKind(new CheckParameter(TimeSpan.FromMinutes(200), TimeSpan.FromMinutes(30), usages));
Assert.AreEqual(UsageResultKind.BreakRequired, res);
}
public void CheckCurfewNoData()
{
var user = GetUser();
var usageLog = GetUsageLog(user, TimeSpan.Zero);
var curfews = GetCurfews(0, user, null);
var st = GetStorage(user, usageLog, curfews);
var c = new CheckTask(st);
var res = c.Check(user.Login, usageLog.Date);
Assert.AreEqual(UsageResultKind.NoRestriction, res.Kind);
}
public void CheckBreakPassedViolated()
{
var ct = new CheckTask(GetStorage());
var usages = new List <UsageLog>
{
new UsageLog(new TimeSpan(9, 0, 0), TimeSpan.FromMinutes(50)),
new UsageLog(new TimeSpan(10, 0, 0), TimeSpan.FromMinutes(40)),
new UsageLog(new TimeSpan(16, 0, 0), TimeSpan.FromMinutes(50)),
};
var res = ct.CheckKind(new CheckParameter(200, 30, usages));
Assert.AreEqual(UsageResultKind.NoRestriction, res);
}
public void CheckCurfewWeekDaySeveralMatchUsedMoreThanAllowed()
{
var user = GetUser();
var usageLog = GetUsageLog(user, TimeSpan.FromHours(2));
var weekDay = (int)usageLog.Date.DayOfWeek;
var curfews = GetCurfews(3, user, (count, u) => new Curfew {
Id = count, User = u, Time = TimeSpan.FromHours(count > 0 ? count : 1), WeekDay = weekDay.ToString()
});
var st = GetStorage(user, usageLog, curfews);
var c = new CheckTask(st);
var res = c.Check(user.Login, usageLog.Date);
Assert.AreEqual(UsageResultKind.Blocked, res.Kind);
}
public void CheckCurfewWeekDayMatchUsedLessThanAllowed()
{
var user = GetUser();
var usageLog = GetUsageLog(user, TimeSpan.FromMinutes(15));
var weekDay = (int)usageLog.Date.DayOfWeek;
var curfews = GetCurfews(1, user, (count, u) => new Curfew {
Id = count, User = u, Time = TimeSpan.FromHours(1), WeekDay = weekDay.ToString()
});
var st = GetStorage(user, usageLog, curfews);
var c = new CheckTask(st);
var res = c.Check(user.Login, usageLog.Date);
Assert.AreEqual(UsageResultKind.NoRestriction, res.Kind);
}
public void CheckBreakSeveral()
{
var ct = new CheckTask(GetStorage());
var usages = new List <UsageLog>
{
new UsageLog(new TimeSpan(9, 0, 0), TimeSpan.FromMinutes(50)),
new UsageLog(new TimeSpan(10, 0, 0), TimeSpan.FromMinutes(50)),
};
var res = ct.CheckKind(new CheckParameter(200, 30, usages));
Assert.AreEqual(UsageResultKind.NoRestriction, res);
usages.Add(new UsageLog(new TimeSpan(11, 0, 0), TimeSpan.FromMinutes(1)));
res = ct.CheckKind(new CheckParameter(200, 30, usages));
Assert.AreEqual(UsageResultKind.BreakRequired, res);
}
private IEnumerator generate(bool generateWithGeometry = true, bool asynchronous = true, float maxTime = 0.1f)
{
generationProgress = 0;
generateStartPoint();
generateFinishPoint();
QVector2Int startGenerationPoint = new QVector2Int(QMath.getRandom(0, mazeWidth), QMath.getRandom(0, mazeHeight));
while (QListUtil.has(startPointList, startGenerationPoint) ||
QListUtil.has(finishPointList, startGenerationPoint) ||
QListUtil.has(obstaclePointList, startGenerationPoint))
{
startGenerationPoint.x = QMath.getRandom(0, mazeWidth);
startGenerationPoint.y = QMath.getRandom(0, mazeHeight);
}
path = new List <QVector2Int>();
mazeArray = new List <QMazeOutput> [mazeWidth][];
for (int px = 0; px < mazeWidth; px++)
{
mazeArray[px] = new List <QMazeOutput> [mazeHeight];
}
lastDirection = QMazeOutputDirection.None;
QVector2Int currentPosition = new QVector2Int(startGenerationPoint.x, startGenerationPoint.y);
QMazeOutput output = new QMazeOutput();
mazeArray[currentPosition.x][currentPosition.y] = new List <QMazeOutput>();
mazeArray[currentPosition.x][currentPosition.y].Add(output);
path.Add(new QVector2Int(currentPosition.x, currentPosition.y));
checkTaskList.Clear();
if (startPointList.Count > 0 || finishPointList.Count > 0)
{
checkTaskList.Add(checkStartFinishPoint);
}
checkTaskList.Add(checkStandard);
if (piecePack.getPiece(QMazePieceType.Intersection).use)
{
checkTaskList.Add(checkUnder);
}
if (piecePack.getPiece(QMazePieceType.Crossing).use&& !onlyWay)
{
checkTaskList.Add(checkCrossing);
}
if (piecePack.getPiece(QMazePieceType.Triple).use&& !onlyWay)
{
checkTaskList.Add(checkTripple);
}
if (piecePack.getPiece(QMazePieceType.DoubleCorner).use)
{
checkTaskList.Add(checkDoubleCorner);
}
if (piecePack.getPiece(QMazePieceType.DeadlockCorner).use)
{
checkTaskList.Add(checkDeadlockCorner);
}
if (piecePack.getPiece(QMazePieceType.DeadlockLine).use)
{
checkTaskList.Add(checkDeadlockLine);
}
if (piecePack.getPiece(QMazePieceType.DeadlockTriple).use)
{
checkTaskList.Add(checkDeadlockTriple);
}
if (piecePack.getPiece(QMazePieceType.DeadlockCrossing).use)
{
checkTaskList.Add(checkDeadlockCrossing);
}
if (piecePack.getPiece(QMazePieceType.TripleDeadlock).use)
{
checkTaskList.Add(checkTripleDeadlock);
}
if (piecePack.getPiece(QMazePieceType.LineDeadlock).use)
{
checkTaskList.Add(checkLineDeadlock);
}
if (piecePack.getPiece(QMazePieceType.LineDeadlockLine).use)
{
checkTaskList.Add(checkLineDeadlockLine);
}
if (piecePack.getPiece(QMazePieceType.CornerDeadlock1).use)
{
checkTaskList.Add(checkCornerDeadlock1);
}
if (piecePack.getPiece(QMazePieceType.CornerDeadlock2).use)
{
checkTaskList.Add(checkCornerDeadlock2);
}
if (piecePack.getPiece(QMazePieceType.CornerDeadlockCorner).use)
{
checkTaskList.Add(checkCornerDeadlockCorner);
}
if (piecePack.getPiece(QMazePieceType.Empty).use)
{
checkTaskList.Add(checkEmpty);
}
float time = Time.realtimeSinceStartup;
do
{
int lastPathIndex = path.Count - 1;
currentPosition.set(path[lastPathIndex].x, path[lastPathIndex].y);
lastDirection = QMazeOutputDirection.None;
QMazeOutput outputArray = QMazeOutput.getShuffleOutput();
foreach (QMazeOutputDirection dir in outputArray.outputDirList)
{
QVector2Int newPosition = new QVector2Int(currentPosition.x + QMazeOutput.dx[dir], currentPosition.y + QMazeOutput.dy[dir]);
if (pointInMaze(newPosition))
{
if (mazeArray[currentPosition.x][currentPosition.y].Count == 1)
{
List <QMazeOutput> newPositionOutputs = mazeArray[newPosition.x][newPosition.y];
int checkResult = 0;
for (int i = 0; i < checkTaskList.Count; i++)
{
CheckTask checkTask = checkTaskList[i];
checkResult = checkTask(currentPosition, newPosition, newPositionOutputs, dir);
if (checkResult != CHECK_FAILED)
{
break;
}
}
if (checkResult == CHECK_CONTINUE)
{
continue;
}
if (checkResult == CHECK_BREAK)
{
generationProgress++;
break;
}
}
}
else if (QListUtil.has(exitPointList, newPosition))
{
if (!mazeArray[currentPosition.x][currentPosition.y][0].outputDirList.Contains(dir))
{
mazeArray[currentPosition.x][currentPosition.y][0].outputDirList.Add(dir);
}
}
}
if (lastDirection == QMazeOutputDirection.None)
{
path.RemoveAt(path.Count - 1);
}
if (asynchronous && Time.realtimeSinceStartup - time > maxTime)
{
time = Time.realtimeSinceStartup;
yield return(null);
}
}while (path.Count > 0);
if (generateWithGeometry && mazeGeometryGenerator != null)
{
if (asynchronous)
{
yield return(StartCoroutine(mazeGeometryGenerator.generateGeometry(this, mazeArray, maxTime)));
}
else
{
IEnumerator geometryCreatorEnumerator = mazeGeometryGenerator.generateGeometry(this, mazeArray, maxTime);
while (geometryCreatorEnumerator.MoveNext())
{
;
}
}
}
}
