public static bool IsMovePossible(GameObject gameObjChecker, GameObject gameObjField)
{
//Find checker with selected GameObject
Checker checker = CheckerManager.CheckerWithGameobject(gameObjChecker);
//Check if field is free
if (!IsFieldFree(gameObjField))
{
return(false);
}
//Check if move has 1 field length
double distance = Vector3.Distance(gameObjChecker.transform.position, gameObjField.transform.position);
if (distance > 1.65f || distance < 1.4f)
{
return(false);
}
//Check if move isnt backwards && checker isnt a king
if (!checker.IsKing)
{
if (checker.PlayerColor == "Brown" && (gameObjField.transform.position.z - gameObjChecker.transform.position.z) < 0)
{
return(false);
}
if (checker.PlayerColor == "Blue" && (gameObjField.transform.position.z - gameObjChecker.transform.position.z) > 0)
{
return(false);
}
}
return(true);
}
public static void ResetGame()
{
CheckerManager.ResetCheckersPosition();
CheckerManager.ResetCheckersState();
FieldManager.ResetFieldStates();
CameraManager.SetCameraToBoardPosition();
}
public static void Move(GameObject checker, Vector3 endPos)
{
//Set fields state as free
FieldManager.ModifyFieldStateUnder(checker, 1);
//Change field y position to checker y position
endPos.y = 0.3f;
//Move checker
checker.transform.position = Vector3.Lerp(checker.transform.position, endPos, 100);
//Change field state to occupied
if (CheckerManager.CheckerWithGameobject(checker).PlayerColor == "Blue")
{
FieldManager.ModifyFieldStateUnder(checker, 3);
if ((int)checker.transform.position.z == 1)
{
CheckerManager.CheckerWithGameobject(checker).IsKing = true;
}
}
if (CheckerManager.CheckerWithGameobject(checker).PlayerColor == "Brown")
{
FieldManager.ModifyFieldStateUnder(checker, 2);
if ((int)checker.transform.position.z == 10)
{
CheckerManager.CheckerWithGameobject(checker).IsKing = true;
}
}
}
public void CheckerOnPositionTest2()
{
TurnSystem.InitializeData();
Checker testObj = CheckerManager.BrownCheckers[0];
GameMechanics.ResetGame();
Assert.AreEqual(CheckerManager.CheckerOnPosition(testObj.GameObj.transform.position), testObj);
}
public void CheckerOnPositionTest()
{
TurnSystem.InitializeData();
Checker testObj = CheckerManager.BlueCheckers[0];
GameMechanics.ResetGame();
Assert.AreEqual(CheckerManager.CheckerOnPosition(new Vector3(10, 0.3f, 10)), testObj);
}
public void ResetCheckerStateTest()
{
TurnSystem.InitializeData();
CheckerManager.BrownCheckers[0].IsKing = true;
CheckerManager.ResetCheckersState();
GameMechanics.ResetGame();
Assert.AreEqual(false, CheckerManager.BrownCheckers[0].IsKing);
}
public void CheckerWithGameObjectTest()
{
TurnSystem.InitializeData();
Checker testObj = CheckerManager.BlueCheckers[0];
GameObject gameobj = testObj.GameObj;
GameMechanics.ResetGame();
Assert.AreEqual(CheckerManager.CheckerWithGameobject(gameobj), testObj);
}
public void AnyCheckerIsSelectedTest4()
{
TurnSystem.InitializeData();
CheckerManager.SelectChecker(CheckerManager.BlueCheckers[0].GameObj);
bool result = GameMechanics.AnyCheckerIsSelected();
GameMechanics.ResetGame();
Assert.AreEqual(true, result);
}
public void LiftCheckerTest()
{
TurnSystem.InitializeData();
CheckerManager.LiftChecker(CheckerManager.BlueCheckers[0].GameObj);
float yPosition = CheckerManager.BlueCheckers[0].GameObj.transform.position.y;
GameMechanics.ResetGame();
Assert.AreEqual(0.8f, yPosition);
}
public void ResetCheckersPositionTest()
{
TurnSystem.InitializeData();
GameMechanics.Move(CheckerManager.BrownCheckers[0].GameObj, new Vector3(5, 0.3f, 5));
CheckerManager.ResetCheckersPosition();
GameMechanics.ResetGame();
Assert.AreEqual(CheckerManager.BrownCheckers[0].GameObj.transform.position, CheckerManager.BrownDefaultPositions[0]);
}
public void RemoveEnemyBetweenTest2()
{
TurnSystem.InitializeData();
GameMechanics.Move(CheckerManager.BrownCheckers[0].GameObj, new Vector3(3, 0.3f, 7));
CheckerManager.RemoveEnemyBetween(CheckerManager.BlueCheckers[14].GameObj, FieldManager.BlackFieldsBoard[26].GameObject);
int state = FieldManager.BlackFieldsBoard[31].State;
GameMechanics.ResetGame();
Assert.AreEqual(1, state);
}
public void DropCheckerTest()
{
TurnSystem.InitializeData();
Checker testObj = CheckerManager.BlueCheckers[0];
CheckerManager.DropChecker(testObj.GameObj);
GameMechanics.ResetGame();
Assert.AreEqual(0.3f, testObj.GameObj.transform.position.y);
}
public void SelectedCheckerTest()
{
TurnSystem.InitializeData();
Checker testObj = CheckerManager.BlueCheckers[0];
CheckerManager.SelectChecker(testObj.GameObj);
Checker result = CheckerManager.SelectedChecker();
GameMechanics.ResetGame();
Assert.AreEqual(result, testObj);
}
public void RemoveEnemyBetweenTest()
{
TurnSystem.InitializeData();
GameMechanics.Move(CheckerManager.BrownCheckers[0].GameObj, new Vector3(3, 0.3f, 7));
CheckerManager.RemoveEnemyBetween(CheckerManager.BlueCheckers[14].GameObj, FieldManager.BlackFieldsBoard[26].GameObject);
float position = CheckerManager.BrownCheckers[0].GameObj.transform.position.y;
GameMechanics.ResetGame();
Assert.AreEqual(50, position);
}
public void SelectCheckerTest()
{
TurnSystem.InitializeData();
Checker testObj = CheckerManager.BrownCheckers[0];
CheckerManager.SelectChecker(testObj.GameObj);
float yPosition = testObj.GameObj.transform.position.y;
GameMechanics.ResetGame();
Assert.AreEqual(0.8f, yPosition);
}
public void FieldUnderCheckerTest2()
{
TurnSystem.InitializeData();
GameMechanics.Move(CheckerManager.BrownCheckers[10].GameObj, new Vector3(2, 0, 4));
Field field = FieldManager.FieldUnderChecker(CheckerManager.BrownCheckers[10].GameObj);
CheckerManager.ResetCheckersPosition();
FieldManager.ResetFieldStates();
GameMechanics.ResetGame();
Assert.AreEqual(GameObject.Find("Black (16)"), field.GameObject);
}
public void FieldWithGameObjectTest()
{
TurnSystem.InitializeData();
GameMechanics.Move(CheckerManager.BrownCheckers[10].GameObj, new Vector3(2, 0, 4));
Field field = FieldManager.FieldUnderChecker(CheckerManager.BrownCheckers[10].GameObj);
Field field2 = FieldManager.FieldWithGameObject(field.GameObject);
CheckerManager.ResetCheckersPosition();
FieldManager.ResetFieldStates();
GameMechanics.ResetGame();
Assert.AreEqual(FieldManager.BlackFieldsBoard[15], field2);
}
// Update is called once per frame
void Update()
{
var currentPosition = transform.position;
Ray ray = new Ray(currentPosition, transform.forward);
RaycastHit hit;
bool isHit = Physics.Raycast(ray, out hit, Mathf.Infinity);
if (isHit)
{
var point = hit.point;
var distance = Vector3.Distance(currentPosition, point);
mLeftDistance.text = distance.ToString("F4");
mRightDistance.text = distance.ToString("F4");
}
else
{
mLeftDistance.text = "∞";
mRightDistance.text = "∞";
}
if (Input.GetKeyDown(KeyCode.JoystickButton0))
{
GameObject canvas = GameObject.Find("Canvas");
CanvasManager cm = canvas.GetComponent <CanvasManager>();
if (isHit && hit.collider.gameObject.tag.Equals("UI") || cm.mUIIsShow)
{
return;
}
else
{
if (mChecker == null)
{
mChecker = Instantiate(mPerfabChecker, transform.position + transform.forward * mCheckerDistance, Quaternion.identity);
mCheckerManager = mChecker.GetComponent <CheckerManager>();
}
else
{
mChecker.transform.position = transform.position + transform.forward * mCheckerDistance;
}
mCheckerManager.resetLocalRotation();
mCheckerManager.resetLocalPosition();
mChecker.transform.LookAt(transform);
}
}
}
//Update is called once per frame
void Update()
{
//Set checkers color depending on their state
MaterialsManager.SetMaterialsToDefault(this);
//If player cursor points on clickable object
RaycastHit hit;
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit, 100, clickableLayer.value))
{
//Assign pointed object to variable
GameObject selectedObject = hit.collider.gameObject;
//Change cursor texture to "clickable" and change pointed checker color to white
CursorManager.SetCursorToClickablePointer(this);
MaterialsManager.ChangeObjectMaterialTo(this, selectedObject, 4);
//If left mouse button was clicked
if (Input.GetMouseButtonDown(0))
{
if (selectedObject.tag == "Exit")
{
GameMechanics.Exit();
}
if (selectedObject.tag == "Restart")
{
TurnSystem.StartGame();
}
//If player tries to move or jump
if (selectedObject.tag == "Field" && GameMechanics.AnyCheckerIsSelected())
{
//Distance variable measures distance between selected checker, and field on which player wants to move
//Basing on that distance, you can check if player tries to move or jump
double distance = Vector3.Distance(CheckerManager.SelectedChecker().GameObj.transform.position, selectedObject.transform.position);
//If player tries to move
if (distance < 1.65f)
{
//If its players first move allow to move, otherwise if player already jumped, allow only next jumps(if they are possible)
if (TurnSystem.FirstMove)
{
//Player have to always jump if its possible
if (GameMechanics.IsAnyJumpPossible(CheckerManager.SelectedChecker().PlayerColor))
{
Debug.Log("You have to jump.");
}
//If its first move and move is allowed, move player
else
if (GameMechanics.IsMovePossible(CheckerManager.SelectedChecker().GameObj, selectedObject))
{
GameMechanics.Move(CheckerManager.SelectedChecker().GameObj, selectedObject.transform.position);
TurnSystem.EndTurn();
}
}
//If player already jumped and tries to move instead of jumping
else
{
Debug.Log("You have to jump.");
}
}
//If player tries to jump
if (distance > 1.65f && distance < 2.95f)
{
if (GameMechanics.IsJumpPossible(CheckerManager.SelectedChecker().GameObj, selectedObject))
{
CheckerManager.RemoveEnemyBetween(CheckerManager.SelectedChecker().GameObj, selectedObject);
GameMechanics.Move(CheckerManager.SelectedChecker().GameObj, selectedObject.transform.position);
TurnSystem.FirstMove = false;
//If selected checker after previous jump can do another jump, dont end turn and let user know that next move is possible
if (GameMechanics.CanCheckerJump(CheckerManager.SelectedChecker()))
{
Debug.Log("Next move is possible");
}
else
{
TurnSystem.EndTurn();
}
}
}
}
//If player didn't click on selected checker, deselect previous selected checker
if (GameMechanics.AnyCheckerIsSelected() && CheckerManager.SelectedChecker().GameObj != selectedObject)
{
CheckerManager.DeselectCheckers();
}
CheckerManager.SelectChecker(selectedObject);
}
}
//If cursor doesn't point on anything clickable
else
{
CursorManager.SetCursorToNormalPointer(this);
if (Input.GetMouseButtonDown(0))
{
CheckerManager.DeselectCheckers();
}
}
}
static void Main(string[] args)
{
//Dependency Injection Setup
var serviceProvider = new ServiceCollection()
.AddLogging(logging =>
{
logging.AddConsole();
logging.SetMinimumLevel(LogLevel.Trace);
})
.AddSingleton <IConfigManager, ConfigManager>()
.AddSingleton <ICachetObserverService, CachetObserverService>()
.AddSingleton <IPluginManager, PluginManager>()
.BuildServiceProvider();
var logger = serviceProvider.GetService <ILoggerFactory>()
.CreateLogger <Program>();
logger.LogDebug("Starting application");
//Plugin Manager
var pluginManager = serviceProvider.GetService <IPluginManager>();
//Configuaration
var configManager = serviceProvider.GetService <IConfigManager>();
if (configManager.Configuration == null)
{
logger.LogCritical("Your config file is invalid");
Thread.Sleep(1000);
return;
}
if (string.IsNullOrEmpty(Convert.ToString(configManager.Configuration.CachetAddress)) || string.IsNullOrEmpty(configManager.Configuration.API_key))
{
logger.LogWarning("You must provide your Cachet site address and API key in config file");
Thread.Sleep(1000);
return;
}
var checkerManager = new CheckerManager(pluginManager, serviceProvider.GetService <ILoggerFactory>());
checkerManager.RegisterChecker(configManager.Configuration.ObservedServices[0].Checks[0]);
//Observer Service
var observer = serviceProvider.GetService <ICachetObserverService>();
//Program
if (observer.Online)
{
logger.LogInformation("Successfully connected to provided Cachet API");
if (observer.KeyVerifed)
{
logger.LogInformation("Cachet API Key verified");
while (true)
{
if (observer.Online)
{
//observer.ReportIncidents();
}
else
{
logger.LogError("Couldn't connect to provided Cachet API. Trying next time...");
}
Thread.Sleep(new TimeSpan(0, 0, 5));
}
}
else
{
logger.LogCritical("Provided Cachet API key is invalid. Shutting down...");
}
}
else
{
logger.LogCritical("Couldn't connect to provided Cachet API. Shutting down...");
}
Thread.Sleep(1000);
}
public static void InitializeData()
{
CheckerManager.MakeCheckersArray();
CheckerManager.GetDefaultCheckersPosition();
FieldManager.MakeFieldsArray();
}
public static bool IsJumpPossible(GameObject gameObjChecker, GameObject gameObjField)
{
//Search checker and fields array for variable with same GameObject as given as argument
Checker checker = CheckerManager.CheckerWithGameobject(gameObjChecker);
Field field = FieldManager.FieldWithGameObject(gameObjField);
//Check if field is free
if (!IsFieldFree(field.GameObject))
{
return(false);
}
//Check if jumping distance is correct
double distance = Vector3.Distance(checker.GameObj.transform.position, field.GameObject.transform.position);
if (distance > 2.95f || distance < 2.8f)
{
return(false);
}
//Check if move isnt backwards && checker isnt a king
if (!checker.IsKing)
{
if (checker.PlayerColor == "Brown" && (checker.GameObj.gameObject.transform.position.z - field.GameObject.transform.position.z) > 0)
{
return(false);
}
if (checker.PlayerColor == "Blue" && (checker.GameObj.transform.position.z - field.GameObject.transform.position.z) < 0)
{
return(false);
}
}
//Check if enemy is between checker and field
Vector3 enemyPos = checker.GameObj.transform.position;
enemyPos.x = (checker.GameObj.transform.position.x + field.GameObject.transform.position.x) / 2;
enemyPos.z = (checker.GameObj.transform.position.z + field.GameObject.transform.position.z) / 2;
enemyPos.y = 0.3f;
//Check if player wants to jump over enemy or over free field
if (!IsAnyCheckerOnPosition(enemyPos))
{
return(false);
}
//If player wants to jump over another checker, check if that checker is an enemy
else
{
if (CheckerManager.CheckerOnPosition(enemyPos).PlayerColor == "Blue" && checker.PlayerColor == "Blue")
{
return(false);
}
if (CheckerManager.CheckerOnPosition(enemyPos).PlayerColor == "Brown" && checker.PlayerColor == "Brown")
{
return(false);
}
}
return(true);
}
