public static bool IsRotationPossible(GameObject objectToRotate)
{
PieceMetadatas pieceMetadatasScript = PieceUtils.FetchPieceMetadataScript(objectToRotate);
List <Vector3> nodes = CalculatePoints(pieceMetadatasScript.MaxRotateAmplitude, objectToRotate);
return(!SweepHasHit(nodes));
}
// Use this for initialization
void Start()
{
this.PieceRotationSpeed = 0.4f;
this.IsMoving = true;
this.gameObJectRigidBody = this.gameObject.GetComponent <Rigidbody>();
this.ComputerPlayerBehaviour = PieceUtils.FetchCorrespondingPlayerBehaviourScript(this.gameObject, this.OwnerId);
this.ComputerPlayerBehaviour.enabled = true;
}
private void FreezePiece(bool isPieceMoving, bool pieceKinematicState, int playerId)
{
GameObject playerPiece = this.playersCurrentGamePiece[playerId];
if (playerPiece != null)
{
PieceController genericParentPieceMovementScript = PieceUtils.FetchCurrentlyActivatedPieceControllerScript(playerPiece);
genericParentPieceMovementScript.IsMoving = isPieceMoving == false ? true : false;
Rigidbody currentPieceRigidBody = playerPiece.GetComponent <Rigidbody>();
currentPieceRigidBody.isKinematic = pieceKinematicState;
}
}
private void ManageGameFieldObject(GameObject piece, int playerId, Quaternion randomInstanciationRotation, List <Material> randomPieceColor)
{
PieceMetadatas pieceMetadatas = PieceUtils.FetchPieceMetadataScript(piece);
float positionCorrection = 0f;
if (pieceMetadatas.IsExcentered)
{
positionCorrection = 0.5f;
}
GameObject field = this.PlayersField[playerId];
Vector3 fieldsize = ElementType.CalculateGameObjectMaxRange(field.transform.transform.GetChild(0).gameObject);
Vector3 instantiatePosition = new Vector3(
fieldsize.x / 2 + field.transform.position.x - 0.5f + positionCorrection
, 0.5f
, fieldsize.z + field.transform.position.z - 1.5f);
GameObject instanciatedPiece = Instantiate(piece, instantiatePosition, randomInstanciationRotation);
PieceController genericController = null;
if (ApplicationUtils.IsTypeComputer(playerId))
{
genericController = PieceUtils.FetchPieceComputerPieceControllerScript(instanciatedPiece);
}
else
{
genericController = PieceUtils.FetchPiecePlayerPieceControllerScript(instanciatedPiece);
}
genericController.enabled = true;
genericController.OwnerId = playerId;
genericController.Field = field;
for (int i = 0; i < randomPieceColor.Count; i++)
{
instanciatedPiece.transform.GetChild(i).GetComponent <MeshRenderer>().material = randomPieceColor[i];
}
PieceMetadatas instanciatedPieceMetadataScript = PieceUtils.FetchPieceMetadataScript(instanciatedPiece);
instanciatedPieceMetadataScript.IsPieceReady = true;
//Update parent piece name and the children too thank to the pieceId
this.UpdatePiecesName(instanciatedPiece);
this.UpdatePieceChildrenTagName(playerId, instanciatedPiece);
this.playersCurrentGamePiece[playerId] = instanciatedPiece;
}
public override IaData CalculateAction(GameObject currentSimulatedObject, int sideId)
{
GameObject simulatedObjectClone = PieceUtils.ClonePieceObject(currentSimulatedObject);
IaData iaInformations = new IaData();
Vector3 finalCalculatedPosition;
Quaternion finalCalculatedRotation;
this.SimulateMovement(Vector3.right, simulatedObjectClone, sideId);
simulatedObjectClone.transform.SetPositionAndRotation(currentSimulatedObject.transform.position, currentSimulatedObject.transform.rotation);
bool isMovePossible = MovementUtils.IsMovementPossible(Vector3.left, simulatedObjectClone);
if (isMovePossible)
{
MovementGeneratorUtils.SimulateNextTranslation(simulatedObjectClone, Vector3.left);
}
this.SimulateMovement(Vector3.left, simulatedObjectClone, sideId);
if (ValidPositionCriteriaList.Count != 0)
{
//Order position criterias by distance descending then take the one with the highest distance property(which mean the one with less peace on ground)
PositionCriteria positionCriteria = ValidPositionCriteriaList.OrderByDescending(criteria => criteria.Distance).First();
finalCalculatedPosition = positionCriteria.ValidPosition;
finalCalculatedRotation = positionCriteria.ValidRotation;
}
else
{
finalCalculatedPosition = currentSimulatedObject.transform.position;
finalCalculatedRotation = currentSimulatedObject.transform.rotation;
}
iaInformations.TargetPosition = finalCalculatedPosition;
iaInformations.TargetRotation = finalCalculatedRotation;
Destroy(simulatedObjectClone);
return(iaInformations);
}
public override IaData CalculateAction(GameObject currentSimulatedObject, int sideId)
{
GameObject simulatedObjectClone = PieceUtils.ClonePieceObject(currentSimulatedObject);
IaData iaInformations = new IaData();
Transform transform;
//position map elements => [lines, collumns]
transform = SimulateMovement(Vector3.right, simulatedObjectClone, sideId);
if (transform != null)
{
iaInformations.TargetPosition = transform.position;
iaInformations.TargetRotation = transform.rotation;
Destroy(simulatedObjectClone);
return(iaInformations);
}
simulatedObjectClone.transform.SetPositionAndRotation(currentSimulatedObject.transform.position, currentSimulatedObject.transform.rotation);
transform = SimulateMovement(Vector3.left, simulatedObjectClone, sideId);
if (transform == null)
{
iaInformations.TargetPosition = currentSimulatedObject.transform.position;
iaInformations.TargetRotation = currentSimulatedObject.transform.rotation;
}
else
{
iaInformations.TargetPosition = transform.position;
iaInformations.TargetRotation = transform.rotation;
}
Destroy(simulatedObjectClone);
return(iaInformations);
}
private void ManageForeseeObject(int playerId)
{
Quaternion randomInstanciationRotation;
GameObject foreseePiece = null;
GameObject foreseeWindow = this.PlayersForeSeeWindow[playerId];
List <Material> randomPieceColor = null;
//Randomly select the foreseenObject
this.playersNextObjectIndex[playerId] = UnityEngine.Random.Range(0, gamePiecesPool.Length);
foreseePiece = gamePiecesPool[(int)this.playersNextObjectIndex[playerId]];
//Randomly calculate rotation for the next forsee object
//TODO manage the rotation for the Y and Z axis
this.PlayersNextIntantiateRotation[playerId] = Quaternion.Euler(
Vector3.zero.x,
this.AuthorizedRotations[UnityEngine.Random.Range(0, AuthorizedRotations.Count)],
Vector3.zero.z);
randomInstanciationRotation = (Quaternion)this.PlayersNextIntantiateRotation[playerId];
//Randomly calculate colors for the next forsee object
this.PlayersPieceNextColorsList[playerId].Clear();
Transform[] pieceTransformElements = foreseePiece.GetComponentsInChildren <Transform>();
foreach (Transform element in pieceTransformElements)
{
if (element.gameObject != foreseePiece)
{
this.PlayersPieceNextColorsList[playerId].Add(elementalColorList[UnityEngine.Random.Range(0, elementalColorList.Length)]);
}
}
randomPieceColor = this.PlayersPieceNextColorsList[playerId];
Vector3 foreseePiecePosition = new Vector3(
foreseeWindow.transform.position.x,
0.5f,
foreseeWindow.transform.position.z);
//Instanciate the foresee piece
GameObject instantiateForeseeObject = Instantiate(foreseePiece, foreseePiecePosition, randomInstanciationRotation);
//Update instanciated foresee piece
Transform[] childrensTransform = instantiateForeseeObject.GetComponentsInChildren <Transform>();
foreach (Transform childTransform in childrensTransform)
{
if (playerId == (int)PlayerEnum.PlayerId.PLAYER_1)
{
childTransform.gameObject.tag = TagConstants.TAG_NAME_PLAYER_1_FORESEE_PIECE;
}
else if (playerId == (int)PlayerEnum.PlayerId.PLAYER_2)
{
childTransform.gameObject.tag = TagConstants.TAG_NAME_PLAYER_2_FORESEE_PIECE;
}
}
for (int i = 0; i < randomPieceColor.Count; i++)
{
instantiateForeseeObject.transform.GetChild(i).GetComponent <MeshRenderer>().material = randomPieceColor[i];
}
Rigidbody instantiatedForeseePieceRigidBody = instantiateForeseeObject.GetComponent <Rigidbody>();
instantiatedForeseePieceRigidBody.isKinematic = true;
instantiatedForeseePieceRigidBody.detectCollisions = false;
List <PieceController> pieceControllerList = new List <PieceController>
{
PieceUtils.FetchPiecePlayerPieceControllerScript(instantiateForeseeObject),
PieceUtils.FetchPieceComputerPieceControllerScript(instantiateForeseeObject)
};
foreach (PieceController pieceController in pieceControllerList)
{
if (pieceController != null)
{
pieceController.enabled = false;
pieceController.IsMoving = false;
}
}
}
private void OnTriggerEnter(Collider other)
{
bool isOtherColliderHasPieceChildTag = other.CompareTag(TagConstants.TAG_NAME_PLAYER_1_PIECE_CHILD) || other.CompareTag(TagConstants.TAG_NAME_PLAYER_2_PIECE_CHILD);
//if a piece child collide with something other than the background
if (isOtherColliderHasPieceChildTag && this.IsCollisionAccepted())
{
bool isThisColliderHasPieceChildTag = this.CompareTag(TagConstants.TAG_NAME_PLAYER_1_PIECE_CHILD) || this.CompareTag(TagConstants.TAG_NAME_PLAYER_2_PIECE_CHILD);
PieceController genericParentPieceMovementScript = null;
if (other.transform.parent == null && isOtherColliderHasPieceChildTag && this.transform.parent != null && isThisColliderHasPieceChildTag)
{
genericParentPieceMovementScript = PieceUtils.FetchCurrentlyActivatedPieceControllerScript(this.transform.parent.gameObject);
}
else
{
GameObject otherParent = other.transform.parent != null ? other.transform.parent.gameObject : other.transform.gameObject;
genericParentPieceMovementScript = PieceUtils.FetchCurrentlyActivatedPieceControllerScript(otherParent);
}
if (genericParentPieceMovementScript == null)
{
return;
}
//If the piece are moving
if (genericParentPieceMovementScript.IsMoving)
{
if (this.IsContactFromBelow(other))
{
Rigidbody objectColidingParentRigidBody = other.GetComponentInParent <Rigidbody>();
if (objectColidingParentRigidBody == null)
{
return;
}
GameObject gameManagerObject = GameObject.FindGameObjectWithTag(TagConstants.TAG_NAME_GAME_MANAGER);
GameManager gameManagerScript = gameManagerObject.GetComponent <GameManager>();
genericParentPieceMovementScript.IsMoving = false;
objectColidingParentRigidBody.velocity = Vector3.zero;
objectColidingParentRigidBody.isKinematic = true;
PieceMetadatas parentPieceMetadatasScript = objectColidingParentRigidBody.gameObject.GetComponent <PieceMetadatas>();
if (parentPieceMetadatasScript.IsSparkling)
{
GameObject[] effectList = GameObject.FindGameObjectsWithTag(TagConstants.TAG_NAME_SPARKLE_EFFECT);
foreach (GameObject effect in effectList)
{
effect.transform.parent = null;
Destroy(effect);
}
PieceMetadatas[] metadataScripts = objectColidingParentRigidBody.gameObject.GetComponentsInChildren <PieceMetadatas>();
foreach (PieceMetadatas metadataScript in metadataScripts)
{
if (metadataScript.gameObject != objectColidingParentRigidBody.gameObject)
{
metadataScript.IsSparkling = false;
}
}
parentPieceMetadatasScript.IsSparkling = false;
}
Instantiate(pieceFallSoundEffect, other.transform.position, Quaternion.identity);
this.CorrectPiecePosition(objectColidingParentRigidBody.gameObject);
this.UpdateMapDatasForObject(objectColidingParentRigidBody.gameObject, gameManagerScript, genericParentPieceMovementScript.OwnerId);
gameManagerScript.CleanUpPieceObject(objectColidingParentRigidBody.gameObject, genericParentPieceMovementScript.OwnerId);
gameManagerScript.DestroyObjectLines(genericParentPieceMovementScript.OwnerId);
//test for the game over requirements
if (gameManagerScript.IsGameOver(genericParentPieceMovementScript.OwnerId))
{
gameManagerScript.GameOver(genericParentPieceMovementScript.OwnerId);
int winnerId = genericParentPieceMovementScript.OwnerId == (int)PlayerEnum.PlayerId.PLAYER_1 ? (int)PlayerEnum.PlayerId.PLAYER_2 : (int)PlayerEnum.PlayerId.PLAYER_1;
if (ApplicationUtils.IsInMultiPlayerMode())
{
gameManagerScript.DeclareWinner(winnerId);
}
return;
}
if (!gameManagerScript.Restart)
{
gameManagerScript.PlayersSpawnAuthorisation[genericParentPieceMovementScript.OwnerId] = true;
}
}
}
}
}
