Farkle

Overview

Farkle is a dice game traditionally played with 6 physical dice, and a paper and pencil for keeping score. In this version, it’s transformed into a multiplayer game!

Genre: Tabletop

Platforms: Mobile, PC

Engine: Unreal Engine 5

Core Mechanics & Design

Gameplay Loop

The main menu appears. Pressing “Start” leads to the player selection screen.

After selecting the number of players, the game begins and the first player is prompted to start their initial roll.

After the dice have stopped moving, the dice are rearranged and displayed to the player. By clicking on a die, the player adds it to their scoring dice, on the right.

If no valid combinations are rolled, that is called a Farkle. All scoring dice from this turn are removed, and your turn score is set to 0. Your turn ends immediately and the next player is up!

The first player to 10,000 points wins!

Technical Notes

Dice

Each dice has 6 arrow components attached to it to indicate which direction each face is facing. After being rolled, each dice waits until it’s no longer moving (or the velocity is 0), and then it checks which arrow component has the forward vector closest to (0.0, 0.0, 1.0). This arrow component corresponds with a dice face value. That value is then passed to the game manager.

Dice C++ code

void ADice::RollDice()
{
	DiceImpulseForRoll();
	StartWaitForVelTimer();
}

void ADice::StartWaitForVelTimer()
{
	// Checks the velocity of the die every 0.5 seconds
	GetWorld()->GetTimerManager().SetTimer(TimerHandle, this, &ADice::WaitForNoVelocity, 0.5f, true);
}


void ADice::WaitForNoVelocity()
{
	FVector velCheck = CheckVelocity();
	FString velocityString = velCheck.ToString();
	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::White, velocityString);
	if (velCheck.Size() == 0)
	{
		// Loops
		// Check if vel isn't 0
		// If not 0 -> keep checking
		// If 0 exit and clear timer
		
		isVel0 = true;
		GetWorld()->GetTimerManager().ClearTimer(TimerHandle);
		
		rollResult = FindRollResult();
		if (GetRollResult() == 99)
		{
			AddValidDiceRoll(false);
		}
		else if (GetRollResult() > 0 || GetRollResult() < 7)
		{
			AddValidDiceRoll(true);
		}
		else
		{
			UE_LOG(LogTemp, Error, TEXT("DiceRoll is out of range"));
		}
		
	}
}

void ADice::DiceImpulseForRoll()
{
	rollImpulse = FVector(0.f, -1000.f, 400.f);
	diceCollision->SetSimulatePhysics(true);
	diceCollision->AddImpulse(rollImpulse,NAME_None, true);
}

void ADice::DBGSetDicePosRot()
// For debugging the position of the dice after they're rolled
{
	diceCollision->SetRelativeRotation(FRotator(45, 0, 0));
	diceCollision->BodyInstance.bLockRotation = true;
}


FVector ADice::CheckVelocity()
{
	velocity = GetVelocity();
	FString message = FString::Printf(TEXT("Velocity: %f"), velocity.Size());
	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, message);

	return velocity;
}

Game Manager

Most of the game logic happens in the Game Manager. This class handles interaction between unrelated classes by passing data to/from specific functions. The gameplay mechanics in this class can be broken down into three basic categories:

Turn Management

Calculating Score

Spawning & Rolling Dice

The C++ class works hand-in-hand with the blueprint class, and thus has many intricate blueprint graphs. This means it’s crucial to keep them organized and neat with comment blocks, which can be seen below in the Event Graph.

Game Manager C++ Code (Entire file, this is long)

#include "GameManager.h"

#include "BasicAIPlayer.h"
#include "DiceSpawner.h"
#include "PlayerCharacter.h"
#include "Kismet/GameplayStatics.h"
#include "Camera/CameraActor.h"
#include "FarkleCameraController.h"
#include "PlayerData.h"
#include "Dice.h"

// Sets default values
AGameManager::AGameManager()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootComponent"));

}

// Called when the game starts or when spawned
void AGameManager::BeginPlay()
{
	Super::BeginPlay();
	numDiceToRoll = 6;
	areDiceSpawned = false;

	playerController = Cast<APlayerController>(UGameplayStatics::GetPlayerController(GetWorld(), 0));
	UGameplayStatics::GetAllActorsOfClass(GetWorld(), ACameraActor::StaticClass(), sceneCameras);
	player = Cast<APlayerCharacter>(playerController->GetPawnOrSpectator());

	// Make this -1 so that player 1 goes first
	inOfCurrPlayer = -1;
	turnActive = false;
	turnsCompleted = 0;

}

void AGameManager::InitPlayers()
{
	for (int i = 0; i < totalNumPlayers; i++)
	{
		// Spawns a character
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: Initing a player"));
		
		if (AllPlayers[i])
		{
			// If it's an AI, sets the Array element to be type BasicAIPlayer, which is a child of APlayerData
			ABasicAIPlayer* newplayer = GetWorld()->SpawnActor<ABasicAIPlayer>(ABasicAIPlayer::StaticClass());
			newplayer->SetTotalScore(0);
			newplayer->SetNumDiceCanRoll(6);
			playersList.Add(newplayer);
			playersList[i]->SetIsCPU(true);
		}
		else
		{
			// Otherwise sets it as a normal player data object
			APlayerData* newplayer = GetWorld()->SpawnActor<APlayerData>(APlayerData::StaticClass());
			newplayer->SetTotalScore(0);
			newplayer->SetNumDiceCanRoll(6);
			playersList.Add(newplayer);
			playersList[i]->SetIsCPU(false);
		}
	}
	//UGameplayStatics::GetAllActorsOfClass(GetWorld(), APlayerData::StaticClass(), actorsList);
	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: Setting camera"));
	SetPlayerCamera();
	turnActive = true;
}

// Called every frame
void AGameManager::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

}

void AGameManager::SpawnDice(int num)
{
	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: Spawning Dice"));
	float z = 0.f;
	if (!areDiceSpawned)
	{
		diceBeingRolled.Empty();
		// Prepare the number of dice that will be rolled
		for (int i = 0; i < num; i++)
		{
			ADice* newDice = diceSpawner->SpawnOneDice(z);
			z = z + 20.f;
			if (newDice != nullptr)
			{
				diceBeingRolled.Add(newDice);
				areDiceSpawned = true;
			}
			else
			{
				GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: Dice not spawned"));
			}
		}
	}
	else
	{
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: Dice already spawned"));
	}
	if (isCurrPlayerAI)
	{
		currentPlayer->AIStartRollDice();
	}
}

void AGameManager::RollDice()
{
	validDiceRolls.Empty();
	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: Starting to Roll Dice"));

	if (diceBeingRolled.Num() > 0)
	{
		for (int i = 0; i < diceBeingRolled.Num(); i++)
		{
			if (diceBeingRolled[i] != nullptr)
			{
				diceBeingRolled[i]->RollDice();
				//GetWorld()->GetTimerManager().SetTimer(TimerHandle, this, &AGameManager::StoreRollResults, 8.f, false);
			}
			else
			{
				GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: Dice to roll is nullptr!"));
			}
		}
	}
}

void AGameManager::AddValidDiceResult(bool isValid)
{
	validDiceRolls.Add(isValid);
}

void AGameManager::StoreRollResults()
{
	rollResults.Empty();
	for (int i = 0; i < diceBeingRolled.Num(); i++)
	{
		// If valid result was returned
		if (diceBeingRolled[i]->GetRollResult() != 99)
		{
			rollResults.Add(diceBeingRolled[i]->GetRollResult());
			FString message = FString::Printf(TEXT("GM: Roll of %d found."), rollResults[i]);
			GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, message);
			GetRollResult(rollResults[i]);
		}
		else
		{
			GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: Roll of 99 found."));
		}
	}
	ShowDiceResults();
}

void AGameManager::ShowDiceResults_Implementation()
{
	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: ShowDiceResults_Implementation"));

}

// Commented out
void AGameManager::SetPlayerCamera()
{
	/*
	// Right now this just does default camera, need to implement a way to change to different cameras
	AFarkleCamera* cam = cameraController->GetDefaultCamera();
	// Sets it on the PLAYER CONTROLLER!
	if (player)
	{
		player->SetCamera(cam);
	}
	*/
}

void AGameManager::SetNumPlayers(int numRealPlayers, int numCPUPlayers, TArray<bool> playerList)
{
	AllPlayers.Empty();
	AllPlayers = playerList;
	
	numPlayers = numRealPlayers;
	numCPU = numCPUPlayers;
	totalNumPlayers = numPlayers + numCPU;

	FString message = FString::Printf(TEXT("GM: %d players."), totalNumPlayers);
	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Purple, message);
	DisplayPlayerScores(totalNumPlayers);
}

TArray<int> AGameManager::GetPlayerScores()
{
	TArray<int> scores;
	if (playersList.Num() > 0)
	{
		for (int i = 0; i < playersList.Num(); i++)
		{
			if (playersList[i] != nullptr)
			{
				scores.Add(playersList[i]->GetTotalScore());
			}
		}
	}
	else
	{
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: player list null 187"));
	}

	return scores;
}

/////////////////////////// Turn Management ////////////////////////////////////////////

void AGameManager::Turn()
{
	if (playersList.Num() > 0)
	{
		// Get Data from the current player
		currentPlayer = playersList[inOfCurrPlayer];
		
		// Pretty sure I don't need any of these variables
		int index = currentPlayer->GetPlayerIndex();
		int diceCanRoll = currentPlayer->GetNumDiceCanRoll();
		int diceToRoll = currentPlayer->GetNumDiceToRoll();
		int gameScore = currentPlayer->GetTotalScore();
		int scoreOfKeptDice = 0;
		
		// Sets turn score to 0 at the start of each turn
		turnScore = 0;

		// Determines if the current player is CPU or not. Necessary for checks before certain functions.
		isCurrPlayerAI = currentPlayer->GetIsCPU();

		if (!currentPlayer->hasTakenLastTurn)
		{
			StartTurn(6);
		}
		else
		{
			ChooseAWinner();
		}
		
		// Default to 6 because the player will always roll 6 dice to start their turn
		
		// Display totalScore
		// Display roundScore
		// Display player identifier

		// Roll All 6 Dice!
		// Get results of Dice roll
		if (hasPlayerReachedGoal)
		{
			currentPlayer->hasTakenLastTurn = true;
		}
	}
	else
	{
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: player list null 202"));

	}
}

void AGameManager::NextTurn()
{
	// Sets the index of current player to the next player
	inOfCurrPlayer += 1;
	if (inOfCurrPlayer >= totalNumPlayers)
		// If at the end of current player list then start from the beginning and increment the number of turns completed
	{
		inOfCurrPlayer = 0;
		turnsCompleted += 1;
	}
	// Call Turn function
	areDiceSpawned = false;
	Turn();
}

int AGameManager::Reroll(int numDice, int selectionScore)
{
	// numDice is the number of dice to be rerolled
	// selectionScore is the score acquired from the previous roll

	// We destroy all the dice in the blueprint
	areDiceSpawned = false;
	
	// Add previous roll's score to the current turn score
	turnScore = turnScore + selectionScore;

	SpawnDice(numDice);

	return turnScore;
}

int AGameManager::EndTurn(int additionalScore)
{
	turnScore = turnScore + additionalScore;
	int oldTotalScore = playersList[inOfCurrPlayer]->GetTotalScore();

	int newTotalScore = oldTotalScore + additionalScore;
	
	playersList[inOfCurrPlayer]->SetTotalScore(newTotalScore);
	int total = playersList[inOfCurrPlayer]->GetTotalScore();

	if(total >= 10000)
	{
		playersList[inOfCurrPlayer]->hasTakenLastTurn = true;
		hasPlayerReachedGoal = true;
	}

	return turnScore;
}

/////////////////////////// Check selections for valid choices ////////////////////////////////////////////


bool AGameManager::CheckForStraight(TArray<int> selectedDiceValues)
{
	if (selectedDiceValues.Num() == 6)
	{
		// Sort the array so like values are next to each other
		selectedDiceValues.Sort();
		for (int i = 0; i < selectedDiceValues.Num() - 1; i++)
		{
			// If the value is the same as the one after it return false
			if (selectedDiceValues[i] == selectedDiceValues[i + 1])
			{
				return false;
			}
		}
		// If the for loop completed, return true
		return true;
	}
	// if the array length is less than 6 return false because a straight must be all 6 in a row
	else
	{
		return false;
	}
}

bool AGameManager::CheckForOnesAndFives(int selectedDiceValue)
// Call this function inside a for loop iterating through all the selected dice
{
	if (selectedDiceValue == 1)
	{
		return true;
	}
	else if (selectedDiceValue == 5)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool AGameManager::CheckForThreeOfAKind(TArray<int> selectedDiceValues)
{
	if (TOAK1.Num() != 0)
	{
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("GM: TOAK WAS GREATER THAN 0!!!!!"));
		TOAK2 = TOAK1;
		TOAK1.Empty();
	}
	
	if (selectedDiceValues.Num() >= 3)
	{
		GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("GM: Selected values list is greater than 3 or equal"));
		// Sort the array so that like values are next to each other and in order
		selectedDiceValues.Sort();
		for (int i = 0; i < selectedDiceValues.Num(); i++)
		{
			// If there are 3 values to compare
			if (selectedDiceValues.IsValidIndex(i+1) && selectedDiceValues.IsValidIndex(i+2))
			{
				
				if (selectedDiceValues[i] == selectedDiceValues[i + 1] && selectedDiceValues[i] == selectedDiceValues[i + 2])
				{
					GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("GM: Found a 3 of a kind"));

					TOAK1.Add(selectedDiceValues[i]);
					TOAK1.Add(selectedDiceValues[i + 1]);
					TOAK1.Add(selectedDiceValues[i + 2]);
					return true;
				}
				else
				{
					//GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("GM: values are not equal"));
					//return false;
				}
			}
		}
		// If the for loop completes without returning true, then return false
		return false;
	}
	else
	{
		return false;
	}
}

bool AGameManager::CheckForThreePairs(TArray<int> selectedDiceValues)
{
	int numPairs = 0;
	if (selectedDiceValues.Num() == 6)
	{
		selectedDiceValues.Sort();
		for (int i = 0; i < selectedDiceValues.Num(); i = i + 2)
		{
			if (selectedDiceValues[i] == selectedDiceValues[i + 1])
			{
				numPairs = numPairs + 1;
			}
			else
			{
				return false;
			}
		}
		if (numPairs == 3)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	return false;
}

int AGameManager::CalculateScore(TArray<int> selectedDiceValues)
{
	int score = 0;
	int startingLengthSDV = selectedDiceValues.Num();

	// If the array is full, AKA there are 6 values
	if (selectedDiceValues.Num() == 6)
	{
		// Check for straight and 3 pairs first
		bool straight = CheckForStraight(selectedDiceValues);
		bool threePairs = CheckForThreePairs(selectedDiceValues);

		// If there are no straights or three pairs then check for three of a kind
		if (!straight && !threePairs)
		{
			// If there is a three of a kind then sort the array and remove those values from the array
			if (CheckForThreeOfAKind(selectedDiceValues))
			{
				GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: Three of a Kind found"));
				selectedDiceValues.Sort(); // Probably not necessary
				// Set this because the CheckForThreeOfAKind function modifies TOAK1
				TOAK2 = TOAK1;
				TOAK1.Empty();

				// Remove values from selectedDiceValues that are included in the three of a kind array
				// to avoid double counting.
				for (int i = 0; i < TOAK2.Num(); i++) // Outer loop limits the number of removals to three.
				// If there's another toak of the same value, or if it's a toak of either a 1 or a 5, this prevents ALL instances of that value being removed
				{
					for (int j = 0; j < selectedDiceValues.Num(); j++) // Iterate through each value in the selectedDiceValues array to check if it's the same as the val in the three of a kind
					{
						if (selectedDiceValues[j] == TOAK2[i])
						{
							// If so, remove it
							selectedDiceValues.RemoveAt(j);
						}
					}
				}
				
				// If there is a second three of a kind
				if (CheckForThreeOfAKind(selectedDiceValues))
				{
					score = score + CalculateThreeOfAKind();
				}
			}
			// Add the three of a kind score
			score = score + CalculateThreeOfAKind();
			GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("GM: calculatd toak"));
			score = score + CalculateOnesAndFives(selectedDiceValues);
		}
		else if (straight)
		{
			score = 3000;
		}
		else if (threePairs)
		{
			score = 1500;
		}
	}
	else if (selectedDiceValues.Num() > 2 && selectedDiceValues.Num() < 6)
	{
		// If there is a three of a kind then remove those values from the array
		if (CheckForThreeOfAKind(selectedDiceValues))
		{
			// Remove values from selectedDiceValues that are included in the three of a kind array
			// to avoid double counting.
			for (int i = 0; i < TOAK1.Num(); i++)
			{
				for (int j = 0; j < selectedDiceValues.Num(); j++)
				{
					if (selectedDiceValues[j] == TOAK1[i])
					{
						selectedDiceValues.RemoveAt(j);
						// Added this if statement because if there was a roll of 4 1's it would only count the
						// three of a kind.
						if (selectedDiceValues.Num() == startingLengthSDV - 3)
						{
							break;
						}
					}
				}
			}
			// Make sure only one of the toak arrays is filled, since the check happens twice, but it's not possible to have 2 toaks
			TOAK2.Empty();
			score = score + CalculateThreeOfAKind();
			//score = score + CalculateOnesAndFives(selectedDiceValues);
		}
			score = score + CalculateOnesAndFives(selectedDiceValues);
	}

	// If there are less than 3 values in the array, it must only be ones or fives
	else if (selectedDiceValues.Num() > 0 && selectedDiceValues.Num() < 3)
	{
		score = CalculateOnesAndFives(selectedDiceValues);
	}
	
	return score;
}

int AGameManager::CalculateOnesAndFives(TArray<int> selectedDiceValues)
{
	int score = 0;

	for (int i = 0; i < selectedDiceValues.Num(); i++)
	{
		if (selectedDiceValues[i] == 1)
		{
			score = score + 100;
		}
		else if (selectedDiceValues[i] == 5)
		{
			score = score + 50;
		}
	}

	return score;
}

int AGameManager::CalculateThreeOfAKind()
{
	int score = 0;
	int toak2Val = 0;
	int toak1Val = 0;
	if (TOAK2.Num() != 0)
	{
		toak2Val = TOAK2[0];
	}
	if (TOAK1.Num() != 0)
	{
		toak1Val = TOAK1[0];
	}
	
	if (toak1Val == 1)
	{
		toak1Val = 1000;
		toak2Val = toak2Val * 100;
		score = score + toak1Val + toak2Val;
	}
	else if (toak2Val == 1)
	{
		toak2Val = 1000;
		toak1Val = toak1Val * 100;
		score = score + toak1Val + toak2Val;
	}
	else
	{
		toak2Val = toak2Val * 100;
		toak1Val = toak1Val * 100;
		score = score + toak1Val + toak2Val;
	}

	return score;
}

What’s Next?

Farkle is currently still in development. What you see on this page is the initial prototype that was completed in November of 2024. Here are the plans I have for the game!

This game is intended to be played either with friends or with up to 3 AI players. Knowing this, I’ve developed and designed the game to eventually accommodate for AI players, which has been both a challenge and a valuable learning experience. Farkle, at its basics, is really quite a simple game of probability. This makes creating a very basic AI a rather easy task. For example, if I wanted to create an AI whose only goal is to beat the player, I could write code that dominates every single time, but who wants to play a game like that? A simple way to list the probabilities is as follows:

# of Dice Rolled	% Chance of Farkle	% Chance of any score
1	66.7	33.3
2	44.5	55.6
3	27.8	72.2
4	15.7	85.3
5	7.7	92.3
6	2.5	97.5

I could simply write code that states if the chance of a Farkle is greater than the chance of any score, then do not reroll dice. But what makes Farkle fun is the game of RISK! So I need to allow the AI to take risks just like the players would. This means I need to consider…

Is there another player whose score is higher than its own?

How close is the player in first place to winning?

Is the score earned from this dice roll worth not risking a reroll?

Does leaving out some scoring dice and rerolling more dice reduce the risk enough to make a reroll worth it?

These factors make for a more complex AI decision-making process. I’ve determined a few key terms that will contribute to how the AI decides to play the game:

Potential Loss/Potential Gain – This is the number of points that the AI stands to either gain or lose for the proposed action.

For example, if the AI rolled: [1, 3, 4, 1, 5, 1] it has some choices to make. First, definitely keep [1, 1, 1] for a total of 1,000 points. This leaves [3, 4, 5] and 5 is a scorable die (50 points). If the AI keeps that 50 points and rerolls the 2 remaining dice, it has a potential loss of 1,050 points, since if the next roll was a Farkle, those initial points would be removed. This is compared to the potential gain of at most 200 points (since with rolling 2 dice, you can’t score a 3-of-a-kind, so you can score 2 1’s for a max of 200 points). In this scenario, the potential gain of 200 points is not worth the potential risk of losing 1,050 points, especially since the chances of a Farkle are ~44.5%.

However, if the AI does not keep the 5 and instead rerolls 3 dice, the potential gain is increased to 1,000 points with only a ~27.8% chance of a Farkle. These odds are much more favorable, and the potential gain is 5x higher. These are the kinds of decisions that the AI needs to make.

States – The action taken by the AI is determined by the state of the game. Examples of different states include:

AI is winning or Player is winning

AI is playing safe or AI is playing risky

The AI will adjust its playstyle and strategies depending on the different states in the game.

UI Updates

Initially, Farkle was going to be a PC only game, but as time went on my vision shifted and I decided to make this into a mobile game. This meant the UI would need to change to accommodate for a smaller screen size and the lack of a mouse & keyboard or controller. Additionally, I wanted to stylize the UI and gameplay a bit more, so recently I’ve been working on some stationary themed UI assets.

My first idea was to make one menu that would slide in from the right side of the screen, when needed. I decided to make this in the style of a manilla folder, trying to mimic the imagery of a folder coming in and out of a filing cabinet. I made the UI mockup in Adobe Illustrator before taking it into Unreal:

While my primary focus is on functionality and programming, it’s a strong belief of mine that visuals are crucial to making an engaging video game. So I’m always trying to improve my design skills, whether it be technical skills in Adobe Illustrator, or choosing a color palette. I’ve come to learn that less is more, and I try to incorporate this idea into my most recent projects.

Known Issues/Bugs

In Progress:

Occasionally on Player 2’s turn (or not Player 1), after scoring all dice and then rerolling all 6, instead of being able to save some dice and then end the turn, the game shows “Roll 1 dice”, but attempting to roll does nothing.
Performance issues caused by tabbing out when rolling dice. Leads to simulation lag(?) and the number of dice available will be incorrect.
On PC, when hovering over a die while it’s rolling, the outline will show.
When the result includes 4 1’s or 4 5’s, attempting to score all of those dice results in an incorrect score calculation. It does not accurately count the 4th die (so 4 1’s would result in a score of 1,000 instead of 1,100).

Resolved: (Last updated March 12, 2025)

Selecting one valid dice and one invalid dice, then clicking “Reroll” returns you to the “roll” screen at the start of your turn, but says “Roll 0 dice.” Breaks the game loop.
Dice by default spawn with a blue outline.
Clicking on empty space would score the last hovered die.
Added several quality of life updates.
Rarely, a die stops on an edge and the (0,0,1) vector cannot be successfully found, resulting in an “index 4 in array size of 4” error that crashes Unreal Engine.

Future Improvements

Player customizations

Customizable Dice skins: Change the color of the dice, as well as the pattern and how the numbers are represented.
Trails and VFX on Dice: An optional addon for special effects on the dice as they are roling.
Names: Instead of Player 1, Player 2, etc. Enter your own custom name.

Environmental Rework

Create a brighter environment/room that aligns more closely with the “stationary” themes previously discussed.

Music & Sound Effects

Pause Menu & Options Settings

Additional Game Modes or Rule Modifications

There are several common ways to alter the rules of play for Farkle. Some ways I’m considering are:

Ability to change the target score from 10,000 points.
Dice/Roll stealing.
Point value shuffle.