public override void OnAuthorization(AuthorizationContext filterContext)
{
if (TR.AuthOn)
{
bool pass = false;
TBController ctrl = filterContext.Controller as TBController;
if (Roles != String.Empty)
{
foreach (var role in Roles.Split(TR.or.ToCharArray()))
{
if (pass = ctrl.User.IsInRole(role)) // deliberate assignment
{
break;
}
}
}
else
{
pass = ctrl.User.IsInRole(TR.All);
}
if (!pass)
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary
{
{ "action", "Unauthorized" },
{ "controller", "Errors" }
});
return;
}
base.OnAuthorization(filterContext);
}
}
public void StartGame()
{
TBController.playMode = (PlayMode)modeDropdown.value;
TBController.botVersion = (BotVersion)botDropdown.value;
EnableBotSettings(false);
EnableWeightFields(TBController.playMode == PlayMode.ShowOff);
OSController.SendValuesToBoard();
TBController.InitializeGame();
playButton.interactable = false;
pauseButton.interactable = true;
stopButton.interactable = true;
}
public void StopButtonClick()
{
TBController.GameOver(true);
UpdateNowPlayingText(true, false, null);
}
/// <summary>
/// Main loop of the bot. It's based on the same method of TetrisBot, but with the add-on that checks if a Tetris can be played
/// </summary>
/// <param name="nextPieceType"></param>
/// <param name="budget"></param>
/// <returns></returns>
public override IEnumerator ActCoroutine(PieceType nextPieceType, float budget)
{
t0 = 0.0f;
PieceModel nextPiece = new PieceModel(nextPieceType);
List <PieceAction> possibleActions = currentTetrisState.GetActions(nextPiece);
bestAction = null;
yield return(null);
t0 += Time.deltaTime;
//If the currentPiece is a I piece, the Tetris is checked since there is no possibility to make a Tetris with another type of piece
if (nextPieceType == PieceType.I)
{
CheckTetris(nextPiece, currentTetrisState, possibleActions, budget);
}
//If there is no possibility of Tetris, the same algorithm than TetrisBot is played
if (bestAction == null)
{
float bestScore = -float.MaxValue;
int i = Random.Range(0, possibleActions.Count);
int initialIndex = i;
while (t0 < budget)
{
if (!TBController.pausedGame)
{
t0 += Time.deltaTime;
TetrisState newState = currentTetrisState.CloneState();
newState.DoAction(nextPiece, possibleActions[i]);
nextPiece.ResetCoordinates();
float score = newState.GetHumanizedScore();
if (score > bestScore)
{
bestScore = score;
bestAction = possibleActions[i];
}
i++;
if (i == possibleActions.Count)
{
i = 0;
}
if (i == initialIndex)
{
break;
}
}
yield return(null);
}
}
else
{
Debug.Log("BOOM! Tetris for bot");
}
//If there is no bestAction at this point, a random action is going to be played
if (bestAction == null)
{
bestAction = currentTetrisState.GetRandomAction(nextPiece);
}
currentTetrisState.DoAction(nextPiece, bestAction);
TBController.DoActionByBot(bestAction);
}
/// <summary>
/// Main method of the bot. While the time budget is not spent, the algorithm makes rollouts over the different nodes of the tree, choosing the best child
/// of the current root node, and finally, chooses the best action for the current piece in the current state
/// </summary>
/// <param name="nextPieceType"></param>
/// <param name="budget"></param>
/// <returns></returns>
public override IEnumerator ActCoroutine(PieceType nextPieceType, float budget)
{
t0 = 0.0f;
rollouts = 0;
PieceModel nextPiece = new PieceModel(nextPieceType);
//Debug
//yield return TetrisBoardController.Instance.StartCoroutine(TetrisBoardController.Instance.ShowPossibleActionsCoroutine(currentNode.state.GetActions(nextPiece)));
MCTSNode currentRollingNode = currentNode;
//if the currentRollingNode doesn't have children at the beginning of the method, that means that its child are the result of playing the nextPiece in
//the state of the currentRollingNode
if (currentRollingNode.children.Count == 0)
{
currentRollingNode.ExtendNode(nextPiece);
}
//While there is still time
while (t0 < budget)
{
if (!TBController.pausedGame)
{
t0 += Time.deltaTime;
//For each child, a rollout is made
foreach (MCTSNode child in currentRollingNode.children)
{
//If the state is not terminal, the rollout is made, and the score stored and backpropagated
if (!child.state.IsTerminal())
{
float score = Rollout(child);
child.score += score;
child.n += 1;
Backpropagation(child.parent, score);
}
//If it's terminal, it store like a rollout was made in order to not choose this child when the best one is searched
else
{
child.n += 1;
}
}
//After the rollouts, the best child is chosen
MCTSNode bestChild = currentRollingNode.GetBestChild();
//If the best child it doesn't have children
if (bestChild.children.Count == 0)
{
//If their children piece is known
if (bestChild.height < pieces.Count)
{
//The node will be extended
bestChild.ExtendNode(new PieceModel(pieces[bestChild.height]));
RolloutOneRandomChild(bestChild);
}
//And then, it goes back to the currentRootNode
currentRollingNode = currentNode;
}
//Otherwise, the algorithm moves to that best child
else
{
currentRollingNode = bestChild;
}
}
yield return(null);
}
//When the loop ends, the recommended child is chosen from the children of the current root node
MCTSNode recommendedChild = GetRecommendedChild(currentNode);
currentNode = recommendedChild; //The current root node is updated
currentTetrisState.DoAction(nextPiece, recommendedChild.action); //Its action is played in the currentState
//Debug.Log("Rollouts: " + rollouts);
TBController.DoActionByBot(recommendedChild.action); //And it is played in the real board
}
/// <summary>
/// The MCTSTetrisBot is created giving it some initialPieces and a budget of time, and it only creates the tree
/// </summary>
/// <param name="initialPieces"></param>
/// <param name="budget"></param>
public MCTSTetrisBot(PieceType[] initialPieces, float budget)
{
TBController.StartCoroutine(BotConstructionCoroutine(initialPieces, budget));
}
