private void AjustTileToGrid(GameObject a_ToInstantiate, Vector3 a_TileWorldPosition)
{
Vector2Int t_GrillePos = m_Grille.GetComponent <Grille>().WorldToGrid(a_TileWorldPosition);
Vector3 t_CellCenter = m_Grille.GetComponent <Grille>().GridToWorld(t_GrillePos);
GameObject instance =
Instantiate(a_ToInstantiate, t_CellCenter, Quaternion.identity) as GameObject;
//m_Tuiles[t_GrillePos.x, t_GrillePos.y] = instance.GetComponent<Tuile>();
//m_Tuiles[t_GrillePos.x, t_GrillePos.y].x = (uint)t_GrillePos.x;
//m_Tuiles[t_GrillePos.x, t_GrillePos.y].y = (uint)t_GrillePos.y;
Tuile t_TileScript = instance.GetComponent <Tuile>();
t_TileScript.x = (uint)t_GrillePos.x;
t_TileScript.y = (uint)t_GrillePos.y;
float t_CellSize = m_Grille.GetComponent <Grille>().CellSize;
Sprite t_Sprite = instance.GetComponent <SpriteRenderer>().sprite;
float t_Scale = t_CellSize / (t_Sprite.rect.width / t_Sprite.pixelsPerUnit);
instance.transform.localScale = new Vector3(t_Scale, t_Scale, t_Scale);
instance.transform.SetParent(m_Grille.transform);
}
public void UpdateAllZombiePath(Tuile target)
{
foreach (EnnemyController t_zombie in allZombies)
{
t_zombie.Path = m_Pf.GetPath(t_zombie.transform, target, false);
}
}
public void TestTuileDecrementation()
{
Tuile tuile = new Tuile('c', 'e', @"exemple");
tuile.UtilisationDeTuile();
Assert.AreEqual(2, tuile.GetNb_utilisation());
}
private void TuileStart(int nbrDeJoueur, Tuile TuileCentre)
{
TuileCentre.terrain = Tuile.Terrain.Buisson;
TuileCentre.effet = Tuile.Effet.Normal;
switch (nbrDeJoueur)
{
case 3:
placerTuileJoueur(menu.Joueurs[0], TuileCentre, 0, 5, 5);
placerTuileJoueur(menu.Joueurs[1], TuileCentre, 2, 1, 1);
placerTuileJoueur(menu.Joueurs[2], TuileCentre, 4, 3, 3);
break;
case 4:
placerTuileJoueur(menu.Joueurs[0], TuileCentre, 0, 0, 1);
placerTuileJoueur(menu.Joueurs[1], TuileCentre, 2, 2, 1);
placerTuileJoueur(menu.Joueurs[2], TuileCentre, 3, 3, 4);
placerTuileJoueur(menu.Joueurs[3], TuileCentre, 5, 5, 4);
break;
case 5:
placerTuileJoueur(menu.Joueurs[0], TuileCentre, 0, 0, 0);
placerTuileJoueur(menu.Joueurs[1], TuileCentre, 1, 1, 1);
placerTuileJoueur(menu.Joueurs[2], TuileCentre, 2, 2, 2);
placerTuileJoueur(menu.Joueurs[3], TuileCentre, 3, 3, 3);
placerTuileJoueur(menu.Joueurs[4], TuileCentre, 4, 4, 4);
break;
default:
break;
}
}
public void TestGetCase()
{
Tuile tuile = new Tuile('c', 'e', @"exemple");
Echange.SetSwap(tuile);
Assert.AreEqual(tuile, Echange.GetSwap(0));
}
public void TestConstructeur()
{
Tuile tuile = new Tuile("Rouge", "Carre");
Assert.AreEqual("Carre", tuile.getForme());
Assert.AreEqual("Rouge", tuile.getCouleur());
}
public void TestSetForme()
{
Tuile tuile = new Tuile("Rouge", "Carre");
tuile.setForme("Croix");
Assert.AreEqual("Croix", tuile.getForme());
}
public void TestSetCouleur()
{
Tuile tuile = new Tuile("Rouge", "Carre");
tuile.setCouleur("Jaune");
Assert.AreEqual("Jaune", tuile.getCouleur());
}
public void TestSiMultidirectionnelScore()
{
Plateau.Init();
Tuile tuile1 = new Tuile('c', 'a', @"exemple");
Tuile tuile2 = new Tuile('c', 'e', @"exemple");
Tuile tuile3 = new Tuile('c', 'i', @"exemple");
Tuile tuile4 = new Tuile('c', 'o', @"exemple");
Tuile tuile5 = new Tuile('c', 'u', @"exemple");
Tuile tuile6 = new Tuile('c', 'y', @"exemple");
Tuile tuile7 = new Tuile('c', 'a', @"exemple");
Tuile tuile8 = new Tuile('c', 'e', @"exemple");
Tuile tuile9 = new Tuile('c', 'i', @"exemple");
Tuile tuile10 = new Tuile('c', 'o', @"exemple");
Tuile tuile11 = new Tuile('c', 'u', @"exemple");
//coordY
Plateau.SetCase(10, 9, tuile2);
Plateau.SetCase(10, 10, tuile1); //celle qu'on teste
Plateau.SetCase(10, 11, tuile3);
Plateau.SetCase(10, 12, tuile4);
Plateau.SetCase(10, 13, tuile5);
Plateau.SetCase(10, 14, tuile6);
//coordX
Plateau.SetCase(9, 10, tuile7);
Plateau.SetCase(11, 10, tuile8);
Plateau.SetCase(12, 10, tuile9);
Plateau.SetCase(13, 10, tuile10);
Plateau.SetCase(14, 10, tuile11);
Assert.AreEqual(24, Plateau.CalculScore(10, 10));
}
void Update()
{
//(grille.WorldToGrid(m_cible.transform.position).x,grille.WorldToGrid(m_cible.transform.position).y);
float t_DistanceAFaire = Speed * Time.deltaTime;
Vector3 t_StartPoint = transform.position;
Vector3 T_MoveToNextCheckpoint = m_CurrentTarget.transform.position - t_StartPoint;
while (t_DistanceAFaire * t_DistanceAFaire >= T_MoveToNextCheckpoint.sqrMagnitude && m_CurrentTarget != null)
{
t_DistanceAFaire -= T_MoveToNextCheckpoint.magnitude;
t_StartPoint = m_CurrentTarget.transform.position;
m_CurrentTarget = m_Path.GetNextTuile(m_CurrentTarget);
if (m_CurrentTarget == null)
{
continue;
}
T_MoveToNextCheckpoint = m_CurrentTarget.transform.position - t_StartPoint;
}
//Je suis au bout du Path
if (m_CurrentTarget == null)
{
transform.position = t_StartPoint;
TargetReached();
}
else
{
transform.position = t_StartPoint + (m_CurrentTarget.transform.position - t_StartPoint).normalized * t_DistanceAFaire;
}
}
//ou clic Tuile libre ou ennemi
public void Phase5_clic_DeplacementSurTuile(Tuile destination)
{
Debug.Log("Phase5_clic_DeplacementSurTuile");
destination.Add(PionActif);
DesactiverDeplacement();
ControlConflit();
}
public void TestPoserTuile()
{
Joueur joueur = new Joueur("Serge", 1);
Tuile tuile = new Tuile('c', 'e', @"exemple");
joueur.SetMain(0, tuile);
joueur.PlacerTuile(0, 0, 1);
Assert.AreEqual(tuile, Plateau.GetCase(0, 1));
}
public void TestEnleverTuileMain()
{
Joueur joueur = new Joueur("Serge", 1);
Tuile tuile = new Tuile('c', 'e', @"exemple");
joueur.SetMain(0, tuile);
joueur.EnleverTuileMain(0);
Assert.AreEqual(null, joueur.GetMain(0));
}
public void TestTuileGetters()
{
Tuile tuile = new Tuile('c', 'e', @"exemple");
Assert.AreEqual('c', tuile.GetCouleur());
Assert.AreEqual('e', tuile.GetForme());
Assert.AreEqual(3, tuile.GetNb_utilisation());
Assert.AreEqual(string.Format("{0}exemple", Directory.GetCurrentDirectory()), tuile.GetPath());
}
public void TestGetSetMain()
{
Joueur joueur = new Joueur("Serge", 1);
Tuile tuile = new Tuile('c', 'e', @"exemple");
Tuile tuile2 = new Tuile('y', 'u', @"exemple");
joueur.SetMain(0, tuile);
tuile2 = joueur.GetMain(0);
Assert.AreEqual(tuile, tuile2);
}
public void TestSetPioche()
{
Tuile tuile = new Tuile('c', 'e', @"exemple");
int compteur = Pioche.pioche.Count;
Pioche.SetPioche(tuile);
Assert.AreEqual(compteur + 1, Pioche.pioche.Count);
Pioche.CarteEpuisee(0);
Assert.AreEqual(compteur, Pioche.pioche.Count);
}
public void TestAddRemove()
{
Tuile tuile = new Tuile('c', 'e', @"exemple");
Echange.SetSwap(tuile);
Assert.AreEqual(1, Echange.GetNumeCase());
Echange.ValiderSwap();
Assert.AreEqual(0, Echange.GetNumeCase());
}
public void TestTuilesRestantes()
{
Joueur joueur = new Joueur("Serge", 1);
Tuile tuile = new Tuile('c', 'e', @"exemple");
joueur.SetMain(0, tuile);
Assert.AreEqual(1, joueur.TuilesRestantes());
joueur.EnleverTuileMain(0);
Assert.AreEqual(0, joueur.TuilesRestantes());
}
private void Start()
{
Vector2Int t_currentTile = m_grille.WorldToGrid(new Vector3(transform.position.x, transform.position.y, transform.position.z));
m_playerLastTuile = t_currentTile;
PlayerLastTuile = m_grille.GetTuile(t_currentTile);
m_GH = FindObjectOfType <GameHandler>();
EndPanel.SetActive(false);
Invoke("MyUpdate", 0f);
}
public void TestErreursDiverses()
{
Plateau.Init();
Tuile tuile1 = new Tuile('c', 'e', @"exemple");
Tuile tuile2 = new Tuile('c', 'r', @"exemple");
Tuile tuile3 = new Tuile('r', 'e', @"exemple");
Tuile tuile4 = new Tuile('r', 'r', @"exemple");
Plateau.SetCase(1, 2, tuile2);
Assert.AreEqual(false, Plateau.ValiderPlacement(1, 2, tuile1)); //emplacement deja utilisé
Assert.AreEqual(false, Plateau.ValiderPlacement(19, 19, tuile1)); //case avec aucune tuiles autour
}
public void DoOuvreLaPorte()
{
Tuile t_tuile = GetComponent <Tuile>();
OuvrirPorte(gameObject);
OuvrePorteVoisine(t_tuile);
m_AudioSource.PlayOneShot(m_Sounds[0]);
Destroy(this);
}
void MyUpdate()
{
Vector2Int t_currentTile = m_grille.WorldToGrid(new Vector3(transform.position.x, transform.position.y, transform.position.z));
if (t_currentTile != m_playerLastTuile)
{
m_playerLastTuile = t_currentTile;
PlayerLastTuile = m_grille.GetTuile(t_currentTile);
m_GH.UpdateAllZombiePath(PlayerLastTuile);
}
Invoke("MyUpdate", 0.1f);
}
//Sets up the outer walls and floor (background) of the game board.
void BoardSetup()
{
//Instantiate Board and set boardHolder to its transform.
boardHolder = new GameObject("Board").transform;
//Loop along x axis, starting from -1 (to fill corner) with floor or outerwall edge tiles.
for (int x = m_MinColumns; x < columns + 1; x++)
{
//Loop along y axis, starting from -1 to place floor or outerwall tiles.
for (int y = m_MinRows; y < rows + 1; y++)
{
//Choose a random tile from our array of floor tile prefabs and prepare to instantiate it.
GameObject toInstantiate = floorTiles[Random.Range(0, floorTiles.Length)];
Tuile t_tuile = toInstantiate.GetComponent <Tuile>();
t_tuile.x = (uint)(x + Math.Abs(m_MinColumns));
t_tuile.y = (uint)(y + Math.Abs(m_MinRows));
//Check if we current position is at board edge, if so choose a random outer wall prefab from our array of outer wall tiles.
if (x == m_MinColumns || x == columns && y > m_MinRows || y > rows)
{
toInstantiate = outerWallTiles[0];
}
if (x < m_MinColumns || x < columns && y == m_MinRows || y == rows)
{
toInstantiate = outerWallTiles[1];
}
if (x == m_MinColumns && y == rows)
{
toInstantiate = outerWallTiles[3];
}
if (x == m_MinColumns && y == m_MinRows)
{
toInstantiate = outerWallTiles[5];
}
if (x == columns && y == rows)
{
toInstantiate = outerWallTiles[2];
}
if (x == columns && y == m_MinRows)
{
toInstantiate = outerWallTiles[4];
}
//Instantiate the GameObject instance using the prefab chosen for toInstantiate at the Vector3 corresponding to current grid position in loop, cast it to GameObject.
GameObject instance = Instantiate(toInstantiate, grille.GridToWorld(new Vector2Int((int)t_tuile.x, (int)t_tuile.y)), Quaternion.identity) as GameObject;
//Set the parent of our newly instantiated object instance to boardHolder, this is just organizational to avoid cluttering hierarchy.
instance.transform.SetParent(boardHolder);
}
}
}
private bool PresenceEmbuscade(Tuile T, int dir)
{
Debug.Log("PresenceEmbuscade");
foreach (Pion p in T.pions)
{
if (p.direction == dir)
{
return(true);
}
}
return(false);
}
public void PiocherCarte_Et_TabulaRasa()
{
Joueur joueur = new Joueur("Bill", 1);
Tuile tuile1 = new Tuile('c', 'e', @"exemple");
Tuile tuile2 = new Tuile('e', 'c', @"exemple");
int compteur = 0;
Pioche.SetPioche(tuile1);
Pioche.SetPioche(tuile2);
joueur.AjouterTuileMain();
Pioche.TabulaRasa();
Assert.AreEqual(compteur, Pioche.pioche.Count);
}
private void placerTuileJoueur(Joueur joueur, Tuile tuileCentre, int dir1, int dir2, int dir3)
{
tuileCentre.TuilesVoisine[dir1].terrain = Tuile.Terrain.Herbe;
tuileCentre.TuilesVoisine[dir1].effet = Tuile.Effet.Normal;
tuileCentre.TuilesVoisine[dir1].TuilesVoisine[dir2].terrain = Tuile.Terrain.Plante;
tuileCentre.TuilesVoisine[dir1].TuilesVoisine[dir2].effet = Tuile.Effet.Normal;
var tuileNid = tuileCentre.TuilesVoisine[dir1].TuilesVoisine[dir2].TuilesVoisine[dir3];
joueur.Nids.Add(tuileNid);
tuileNid.couleurNid = joueur.Couleur.ToString("g");
tuileNid.terrain = Tuile.Terrain.Nid;
tuileNid.effet = Tuile.Effet.Normal;
}
public void TestCouleurEtFormeValidation()
{
Plateau.Init();
Tuile tuile1 = new Tuile('c', 'e', @"exemple");
Tuile tuile2 = new Tuile('c', 'r', @"exemple");
Tuile tuile3 = new Tuile('r', 'e', @"exemple");
Tuile tuile4 = new Tuile('r', 'r', @"exemple");
Plateau.SetCase(1, 2, tuile2);
Assert.AreEqual(true, Plateau.ValiderPlacement(1, 1, tuile1)); //bonne couleur
Plateau.SetCase(1, 2, tuile3);
Assert.AreEqual(true, Plateau.ValiderPlacement(1, 1, tuile1)); //bonne forme
Plateau.SetCase(1, 2, tuile4);
Assert.AreEqual(false, Plateau.ValiderPlacement(1, 1, tuile1)); //mauvaise forme et couleur
}
private bool CEstMonNid(Pion P, Tuile T)
{
Debug.Log("CestMonNid");
if (T.terrain == Tuile.Terrain.Nid)
{
foreach (Tuile t in Joueurs[0].Nids)
{
if (t == T)
{
return(true);
}
}
}
return(false);
}
public void FillTuiles()
{
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
Tuile tuile = new Tuile();
tuile.CoordTuile = new Vector2(i * 5, j * 5);
//print(tuile.CoordTuile);
TuilesMap.Add(tuile);
Bloc aubergine = new Bloc();
aubergine.DaysGrow = 0;
aubergine.plante = new Plante();
aubergine.plante.planteName = "Aubergine";
aubergine.plante.SeasonGrow = 0;
aubergine.plante.Stade2Day = 1;
aubergine.plante.Stade3Day = 2;
aubergine.plante.stadesPlante = new List <GameObject>();
aubergine.plante.stadesPlante.Add(auberginePrefab0);
aubergine.plante.stadesPlante.Add(auberginePrefab1);
aubergine.plante.stadesPlante.Add(auberginePrefab2);
for (int k = 0; k < 5; k++)
{
for (int l = 0; l < 5; l++)
{
tuile.CaseArray[k, l] = new Case();
tuile.CaseArray[k, l].isEmpty = true;
}
}
/*
* tuile.CaseArray[2, 2].blockID = 0;
* tuile.CaseArray[2, 2].pivot.Set(2, 2);
* tuile.CaseArray[2, 2].XD = 0;
* tuile.CaseArray[2, 2].YD = 0;
* tuile.CaseArray[2, 2].isEmpty = false;
*/
//aubergine.cases.Add(tuile.CaseArray[2, 2]);
tuile.blockList.Add(aubergine);
}
}
}
void Start()
{
m_CurrentTarget = m_Path?.GetNextTuile(m_CurrentTarget);
if (m_Path == null || m_CurrentTarget == null)
{
Debug.LogWarning("Ennemy has no possible path.");
gameObject.SetActive(false);
return;
}
//Teleporte sur le point de départ
transform.position = m_CurrentTarget.transform.position;
m_AudioSource.pitch = Random.Range(0.9f, 1.1f);
m_AudioSource.PlayOneShot(m_SpawnSounds[Random.Range(0, m_SpawnSounds.Count)]);
}
