/// <summary>
/// Renvoie le voisinage du gagnant
/// </summary>
/// <param name="gagnant"></param>
/// <param name="totalIteration"></param>
/// <param name="iterationCourante"></param>
/// <returns></returns>
private List <KohonenNeurone> Voisinage(KohonenNeurone gagnant, int totalIteration, int iterationCourante)
{
// on commence par calculer le rayon
double rayon = FonctionsAttenuation.Sigma(RayonCarte, totalIteration, iterationCourante);
// on recherche les neurones présents dans le rayon
// leurs poids seront ajustés
List <KohonenNeurone> voisinage = new List <KohonenNeurone>();
for (int x = 0; x < Grille.GetLength(0); x++)
{
for (int y = 0; y < Grille.GetLength(1); y++)
{
KohonenNeurone neurone = Grille[x, y];
neurone.Distance = Distance(neurone, gagnant);
if (neurone.Distance <= rayon)
{
voisinage.Add(neurone);
}
}
}
Debug.WriteLine("Voisinage: " + voisinage.Count.ToString());
return(voisinage);
}
public void Fertiliser(int buff)
{
if (buff > 1)
{
int x = Position.Key;
int y = Position.Value;
Cellule cell = Grille.GetInstance().GetCellule(x + 1, y);
if (cell)
{
cell.Fertiliser(buff - 1);
}
cell = Grille.GetInstance().GetCellule(x - 1, y);
if (cell)
{
cell.Fertiliser(buff - 1);
}
cell = Grille.GetInstance().GetCellule(x, y + 1);
if (cell)
{
cell.Fertiliser(buff - 1);
}
cell = Grille.GetInstance().GetCellule(x, y - 1);
if (cell)
{
cell.Fertiliser(buff - 1);
}
}
}
/// <summary>
/// Retire de la grille tous les transversaux d'un mot spécifié
/// </summary>
/// <param name="grille"></param>
/// <param name="motCourant"></param>
/// <param name="bd"></param>
/// <param name="afficher"></param>
public void RetirerMotsTransversaux(Grille grille, Mot motCourant, Bd bd, bool afficher)
{
foreach (Lettre lettre in motCourant.ListeLettres)
{
RetirerMot(lettre.ObtenirMotDansDirection(!motCourant.Horizontal), grille, bd, afficher);
}
}
private Neurone RechercherGagnant(double[] entree)
{
double distanceMin = double.MaxValue;
Neurone gagnant = null;
for (int n = 0; n < Grille.Length; n++)
{
Neurone neurone = Grille.GetValue(n) as Neurone;
// pour chaque neurone on calcule sa distance euclidienne avec l'entrée
double somme = 0.0;
for (int i = 0; i < NbEntrees; i++)
{
double ecart = entree[i] - neurone.Poids[i];
somme += ecart * ecart;
}
double distance = Math.Sqrt(somme);
if (distance < distanceMin)
{
distanceMin = distance;
gagnant = neurone;
}
}
return gagnant;
}
internal Grille columnResolution(Grille grille, int i, int j)
{
for (int valueI = 1; valueI <= 9; valueI++)
{
if (possibleValues.Contains(valueI))
{
bool notTheAnswer = false;
for (int k = 0; k <= 8; k++)
{
if (k != j)
{
notTheAnswer = (grille.casesDeSudoku[i, k].possibleValues.Contains(valueI));
if (notTheAnswer)
{
break;
}
}
}
if (!notTheAnswer)
{
valueFound(valueI);
grille.modification = true;
break;
}
}
}
return(grille);
}
public void LinkObject(Coordonnees coor, SujetObserveAbstrait obj, Grille grille)
{
if (coor == null)
{
return;
}
if (!coor.EstValide())
{
return;
}
if (grille == null)
{
return;
}
if (TestNullObject(obj))
{
return;
}
var node = GetNode(coor, grille);
if (node == null)
{
Console.WriteLine("LinkCaseToZone: Impossible de récupérer une node viable en " + coor);
return;
}
AttachObjectToCase(node, obj);
AttachCaseToObject(node, obj);
}
/// <summary>
/// Retourne une grille à partir de son nom
/// </summary>
/// <param name="grilleName">Le nom de la grille</param>
/// <returns>La grille renvoyée</returns>
public Grille getGrilleByName(string grilleName)
{
if (grilleName == null)
{
return(null);
}
Grille grille = new Grille();
foreach (object obj in this.liste)
{
if (obj is Grille)
{
grille.name = ((Grille)obj).name;
grille.oid = ((Grille)obj).oid;
}
else if (obj is BrowserData)
{
grille.name = ((BrowserData)obj).name;
grille.oid = ((BrowserData)obj).oid;
}
if (grille.name.ToUpper() == grilleName.ToUpper())
{
return(grille);
}
}
return(null);
}
public Grille getGrilleByName(string grilleName, ObservableCollection <BrowserData> listeCurrent)
{
if (listeCurrent != null && listeCurrent.Count > 0)
{
listeCurrent.ToList().AddRange(this.liste);
}
else
{
listeCurrent = this.liste;
}
Grille grille = new Grille();
foreach (object obj in listeCurrent)
{
if (obj is Grille)
{
grille.name = ((Grille)obj).name;
grille.oid = ((Grille)obj).oid;
}
else if (obj is BrowserData)
{
grille.name = ((BrowserData)obj).name;
grille.oid = ((BrowserData)obj).oid;
}
if (grille.name.ToUpper() == grilleName.ToUpper())
{
return(grille);
}
}
return(null);
}
internal Grille Detection(Grille grille, int i, int j)
{
rowDetection(grille, i, j);
columnDetection(grille, i, j);
houseDetection(grille, i, j);
return(grille);
}
public void FillGrid(Grille grid)
{
if (grid == null)
{
return;
}
}
public void ConstruireGrilleVide(string gridAsString)
{
grille = new Grille(gridAsString);
for (int y = 0; y < grille.nbLignes; y++)
{
for (int x = 0; x < grille.nbLignes; x++)
{
if (grille.listeLettres[x, y].valeur != null)
{
grille.listeLettres[x, y].Go = Object.Instantiate(whiteSpace, new Vector3((float)x, (float)-y, 0.0f), Quaternion.identity);
grille.listeLettres[x, y].GoText = grille.listeLettres[x, y].Go.GetComponentInChildren <TextMesh>();
grille.listeLettres[x, y].GoRenderer = grille.listeLettres[x, y].Go.GetComponent <SpriteRenderer>();
}
else
{
grille.listeLettres[x, y].Go = Object.Instantiate(blackSpace, new Vector3((float)x, (float)-y, 0.0f), Quaternion.identity);
}
}
}
for (int y = 0; y < grille.nbLignes; y++)
{
GameObject numero = Object.Instantiate(greySpace, new Vector3(-1.0f, (float)-y, 0.0f), Quaternion.identity);
numero.GetComponentInChildren <TextMesh>().text = (y + 1).ToString();
listeNumeros.Add(numero);
}
for (int x = 0; x < grille.nbColonnes; x++)
{
GameObject numero = Object.Instantiate(greySpace, new Vector3((float)x, 1.0f, 0.0f), Quaternion.identity);
numero.GetComponentInChildren <TextMesh>().text = (x + 1).ToString();
listeNumeros.Add(numero);
}
bd = new Bd(fichiersDicos, tailleGrille);
Selecteur.Instance.Initialiser();
}
/// <summary>
/// Sauvegarde la grille dans un fichier
/// </summary>
/// <param name="grille"></param>
/// <param name="nom"></param>
public void SauvegarderGrille(Grille grille, bool avecSolution)
{
string destination = "";
if (avecSolution)
{
destination = Application.persistentDataPath + "/GrillesPleines/";
}
else
{
destination = Application.persistentDataPath + "/GrillesVides/";
}
int idNumber = Directory.GetFiles(destination, "*", SearchOption.TopDirectoryOnly).Length + 1;
string nomFichier = "Grille" + idNumber + ".dat";
FileStream file;
if (File.Exists(destination))
{
Debug.Log("ERREUR: Une grille portant le ID généré existe déjà.");
return;
}
else
{
file = File.Create(destination + nomFichier);
}
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(file, new GrilleSerializable(grille, avecSolution));
file.Close();
Debug.Log("Grille sauvegardée sous " + nomFichier);
}
public void AddGrilleIfNatExist(Grille grille)
{
if (getGrilleByName(grille.name) != null)
{
return;
}
AddGrille(grille);
}
private void Start()
{
m_Grille = FindObjectOfType <Grille>();
m_AudioSource = GetComponent <AudioSource>();
m_perso = FindObjectOfType <PersoController>().gameObject;
GunPos = m_perso.transform.GetChild(0).gameObject;
m_Shooting = m_perso.GetComponent <Shooting>();
}
public GridManagerBingo(Grille <int> grille, int ind)
{
tileReference = GameObject.Find("TilePrefab");
this.grille = grille;
this.colonne = grille.getCols();
this.ligne = grille.getRows();
this.ind = ind;
}
protected override Grille GetNewGrid()
{
Grille grid = new Grille();
grid.report = true;
grid.name = getNewPageName("Report Grid");
grid.group = GetInputGridService().GroupService.getDefaultGroup();
grid.visibleInShortcut = true;
return(grid);
}
public MainWindow()
{
InitializeComponent();
circuit = new CircuitPersonnalise();
Wires = new List <Wire>();
Grille.AddHandler(Gate.DeletingGateEvent, new RoutedEventHandler(Supprimer));
Grille.AddHandler(Wire.SuppwireEvent, new RoutedEventHandler(Supp_Wire));
Grille.AddHandler(InputOutput.SupprimerWireEvent, new RoutedEventHandler(SupprimerWire));
}
void Start()
{
positionCible = transform.position;
grille = GameObject.Find("A*").GetComponent <Grille>();
enMouvement = false;
pathfinder = GameObject.Find("A*").GetComponent <PathFinding> ();
StartCoroutine(sonMouvement());
}
private void CreerTableauDeJeu()
{
if (Grille.HasInstance())
{
return;
}
TableauDeJeu = (Grille)Grille.Instance(Longueur, Largeur);
this.Fenetre = new Window(600, 600, this);
//Attach(Fenetre);
}
/// <summary>
/// Apres que les fantomes aillent ete manger, permet de savoir si un fantome doit etre relachger
/// </summary>
private void VérifierSiFantômeÀRelacher()
{
// On va relacher un fantome chaque 6 secondes - (1 demie secondes par niveau)
if (--m_cptFantômesMorts % (FrameRateValue * 6 - (Niveau / 5 * FrameRateValue / 2)) == 0)
{
Fantôme fantôme = m_listeFantômesMangers.Dequeue();
m_listeFantômesActifs.Add(fantôme);
fantôme.MettreAJourCoordonnée(Grille.TrouverCoordonnéeCase(14, 11));
}
}
internal Grille autoResolution(Grille grille, int i, int j)
{
grille.modification = false;
if (possibleValues.Count == 1)
{
valueFound(possibleValues[0]);
grille.modification = true;
}
return(grille);
}
// Use this for initialization
void Start()
{
if (_instance)
{
Destroy(_instance);
}
_instance = this;
GenerateTerrain();
}
/// <summary>
/// Methode de selection du treeview qui renvoit l'élément selectionné
/// et cet élément une grille est transmise au GrilleTreeview
/// par l'évènement OnClick
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnTreeNodeClick(object sender, MouseButtonEventArgs e)
{
if (GrilleTree.SelectedItem != null && GrilleTree.SelectedItem is BrowserData && SelectionChanged != null)
{
Grille grille = new Grille();
grille.name = ((BrowserData)GrilleTree.SelectedItem).name;
grille.oid = ((BrowserData)GrilleTree.SelectedItem).oid;
SelectionChanged(grille);
e.Handled = true;
}
}
public Window(int width, int height, GameManager manager)
: base(width, height)
{
Gestionnaire = manager;
manager.Attach(this);
tableau = Gestionnaire.TableauDeJeu;
Touches = new Clavier(this);
Graphismes = new Graphisme(this);
//this.
//Run(60.0); // Run the game at 60 updates per second
}
/// <summary>
/// Ramene tout les objets animables a leur position initiales
/// </summary>
private void RéinitialiserPositions()
{
Pacman.MettreAJourCoordonnée(new Coordonnée(CentreX, Grille.TrouverCoordonnéeCase(0, 17).Y));
Pacman.Déplacer(Déplacement.Arrêt);
m_listeFantômes.ForEach(f =>
{
f.RéinitialiserPosition();
f.Déplacer(Déplacement.Arrêt);
});
}
public Window(int width, int height, GameManager manager)
: base(width, height)
{
Gestionnaire = manager;
manager.Attach(this);
tableau = Gestionnaire.TableauDeJeu;
Touches = new Clavier(this);
Graphismes = new Graphisme(this);
//this.
//Run(60.0); // Run the game at 60 updates per second
}
static public Questionnaire Run()
{
Questionnaire questionnaire = new Questionnaire();
OrderedBag<Grille> OPEN = new OrderedBag<Grille>();
OrderedBag<Grille> CLOSE = new OrderedBag<Grille>();
Grille S = new Grille();
OPEN.Add(S);
while (OPEN.Count != 0)
{
Grille n = OPEN.RemoveFirst();
CLOSE.Add(n);
questionnaire.solutionsExplorer.Add(n.getStringEtat());
if (n.getDistanceSolution() == 0)
{
questionnaire.solutionMot = n.getSolutionMot();
questionnaire.solutionVisuelle = n.getSolutionVisuelle();
for (int i = 0; i < questionnaire.solutionVisuelle.Count; i++)
{
Console.Write("\n---Étape" + i + "----\n" + questionnaire.solutionVisuelle[i] + "----------");
}
return questionnaire;
}
foreach (Grille nPrime in n.getListSuccessor())
{
questionnaire.etatExplorer.Add(nPrime.getStringEtat());
if (Contient(OPEN, nPrime) != -1)
{
int position = Contient(OPEN, nPrime);
if (nPrime.getTotalDistance() < OPEN[position].getTotalDistance())
{
OPEN.Remove(OPEN[position]);
OPEN.Add(nPrime);
}
}
else if (Contient(CLOSE, nPrime) != -1)
{
int position = Contient(CLOSE, nPrime);
if (nPrime.getTotalDistance() < CLOSE[position].getTotalDistance())
{
CLOSE.Remove(CLOSE[position]);
OPEN.Add(nPrime);
}
}
else // Ni dans Close , ni dans OPEN
{
OPEN.Add(nPrime);
}
}
}
questionnaire.solutionMot = "Aucun chemin possible";
return questionnaire;
}
/// <summary>
/// Retire un inputTable de la liste
/// </summary>
/// <param name="inputTable">L'inputTable à modifier</param>
public void RemoveGrille(Grille grille)
{
foreach (BrowserData data in this.liste)
{
if (data.name == grille.name)
{
this.liste.Remove(data);
this.cvs.DeferRefresh();
return;
}
}
}
internal Grille columnDetection(Grille grille, int i, int j)
{
for (int k = 0; k <= 8; k++)
{
if (grille.casesDeSudoku[i, k].isSolved && (k != j) && possibleValues.Contains(grille.casesDeSudoku[i, k].value))
{
possibleValues.Remove(grille.casesDeSudoku[i, k].value);
grille.modification = true;
}
}
return(grille);
}
public void creationGrille(int hauteurGr, int largeurGr, bool is_Player)
{
if (is_Player)
{
Grille grille = new Grille(new Coordonnée(hauteurGr, largeurGr));
}
else
{
return(user2Grille = new Grille(hauteurGr, largeurGr));
}
//Grille userGrille = new Grille();
}
static private int Contient(OrderedBag<Grille> set, Grille g)
{
for (int i = 0; i < set.Count; i++)
{
if (set[i].getStringEtat() == g.getStringEtat())
{
return i;
}
}
return -1;
}
/// <summary>
/// Remplir la grille
/// </summary>
/// <param name="bd"></param>
/// <param name="listeMots"></param>
/// <param name="nbEssaisMaxGlobal"></param>
/// <param name="nbEssaisMaxPourMot"></param>
/// <param name="afficher"></param>
public void RemplirGrille(Bd bd, Grille grille, int nbEssaisMaxGlobal, int nbEssaisMaxPourMot, bool afficher)
{
int nbEssaisGlobal = 0;
bool trier = false;
CalculerScoresDesMots(grille.listeMotsARemplir);
Mot motARemplir = ObtenirProchainMotARemplir(grille, true);
while (motARemplir != null && nbEssaisGlobal < nbEssaisMaxGlobal)
{
//Debug.Log((motARemplir.Horizontal ? "Horizontal " : "Vertical ") + motARemplir.PositionPrimaire + ":" + motARemplir.PositionSecondaire);
if (motARemplir.nbTentativesDeRemplissage == 10)
{
RetirerMotAleatoire(grille, motARemplir, bd, afficher);
RetirerMotAleatoire(grille, motARemplir, bd, afficher);
}
else if (motARemplir.nbTentativesDeRemplissage == 20)
{
RetirerMotAleatoire(grille, motARemplir, bd, afficher);
RetirerMotAleatoire(grille, motARemplir, bd, afficher);
}
else if (motARemplir.nbTentativesDeRemplissage == 30)
{
RetirerMotAleatoire(grille, motARemplir, bd, afficher);
RetirerMotAleatoire(grille, motARemplir, bd, afficher);
}
else if (motARemplir.nbTentativesDeRemplissage == 40)
{
RetirerMotsTransversaux(grille, motARemplir, bd, afficher);
motARemplir.nbTentativesDeRemplissage = 0;
}
//RemplirMotSelonScore(motARemplir, bd, nbEssaisMaxPourMot, afficher);
RemplirMot(motARemplir, bd, nbEssaisMaxPourMot, afficher);
motARemplir.nbTentativesDeRemplissage++;
if (!motARemplir.Rempli)
{
RetirerMotAleatoire(grille, motARemplir, bd, afficher);
}
else
{
motARemplir.CalculerScoreDesMotsTransversaux();
grille.listeMotsARemplir.Remove(motARemplir);
trier = true;
}
nbEssaisGlobal++;
motARemplir = ObtenirProchainMotARemplir(grille, trier);
}
if (nbEssaisGlobal == 0)
{
Debug.Log("Grille déjà remplie");
}
}
public static Game CreerJeu(NomJeu nomjeu, GameManager manager, Grille grille)
{
switch (nomjeu)
{
case NomJeu.AgeOfKebab: return(new GameAgeOfKebabFactory().CreerJeu());
case NomJeu.CDGSimulator: return(new GameCDGSimulatorFactory().CreerJeu());
case NomJeu.Honeyland: return(new GameHoneylandFactory().CreerJeu());
}
return(null);
}
private List<ArrayList> RecupererChemins(Grille grille,Coordonnees casedepart, List<ObjetAbstrait> objets)
{
if(grille == null) throw new NullReferenceException("La grille renseignée est nulle !");
var list = new List<ArrayList>();
foreach (var obj in objets)
{
var chemin = grille.Route(casedepart, obj.Case);
grille.ReinitialiserMinDistances();
list.Add(chemin);
}
return list;
//return objets.Select(obj => grille.Route(casedepart, obj.Case)).ToList();
}
public void LinkObject(Coordonnees coor, SujetObserveAbstrait obj, Grille grille)
{
if (coor == null) return;
if (!coor.EstValide()) return;
if(grille == null) return;
if (TestNullObject(obj)) return;
var node = GetNode(coor,grille);
if (node == null)
{
Console.WriteLine("LinkCaseToZone: Impossible de récupérer une node viable en " + coor);
return;
}
AttachObjectToCase(node, obj);
AttachCaseToObject(node, obj);
}
private void CreerTableauDeJeu()
{
if (Grille.HasInstance()) return;
TableauDeJeu = (Grille)Grille.Instance(Longueur, Largeur);
this.Fenetre = new Window(600,600,this);
//Attach(Fenetre);
}
void Start()
{
alarm=AudioManager.getInstance ().loadAudio ("Alarm", Camera.main.transform.position);
alarm.gameobject.GetComponent<AudioSource> ().Play ();
currentTurret = laser;
start = System.DateTime.Now;
aStar=new AStar<Hexagone>();
grille = new Grille ();
for(int i = -9;i<10;i++){
for(int j=-9;j<10;j++){
grille.AddHexa(new Hexagone(grille,i,j,obj));
}
}
startH = grille.GetHexa (startX, startY);
endH = grille.GetHexa (endX, endY);
endCollider.gameObject.transform.position = endH.centre () + new Vector3 (0f, 0.5f, 0.0f);
ennemi.transform.localScale= new Vector3 (0.5f, 0.5f, 0.5f);
ennemies=new Pool<Ennemi>(new Ennemi(ennemi,startH,endH,ennemiLife));
grille.UpdateColor ();
updatePath ();
}
private Node<Case> GetNode(Coordonnees coor, Grille grille)
{
return (Node<Case>)grille[coor.X, coor.Y];
}
/* Génération des meshs 3D */
public void GenerationMesh(int[,] map, float tailleCarre) {
/*O vide les liste lors de la génération d'une autre nouvelle map */
triangleDictionnaire.Clear ();
contours.Clear ();
sommetsVus.Clear ();
objetPosition.Clear();
/* Represente la map avec ses pieces et murs */
grille = new Grille(map, tailleCarre);
/* Listes des sommets et des triangles des meshs */
sommets = new List<Vector3>();
triangles = new List<int>();
/* On va creer des triangles à partir des carrés en liant les nodes actives entre elles
* Cela permet d'avoir une map plus réaliste, moins carré.
*/
for (int x = 0; x < grille.carres.GetLength(0); x ++) {
for (int y = 0; y < grille.carres.GetLength(1); y ++) {
TriangulationCarre(grille.carres[x,y]);
}
}
/* Creation d'une mesh, comprend des sommets, des triangles et des uvs */
Mesh mesh = new Mesh();
cave.mesh = mesh;
mesh.vertices = sommets.ToArray();
mesh.triangles = triangles.ToArray();
mesh.RecalculateNormals();
/* Les uvs servent à placer les textures */
int tileAmount = 10;
Vector2[] uvs = new Vector2[sommets.Count];
for (int i =0; i < sommets.Count; i ++) {
float percentX = Mathf.InverseLerp(-map.GetLength(0)/2*tailleCarre,map.GetLength(0)/2*tailleCarre,sommets[i].x) * tileAmount;
float percentY = Mathf.InverseLerp(-map.GetLength(0)/2*tailleCarre,map.GetLength(0)/2*tailleCarre,sommets[i].z) * tileAmount;
uvs[i] = new Vector2(percentX,percentY);
}
mesh.uv = uvs;
/* Si le jeu est en 2D */
/*if (est2D) {
Generate2DColliders();
} else {
CreateWallMesh ();
}*/
/* On rajoute les meshs 3D des murs */
CreationMeshMur();
/* On ajoute sur la map les élements de jeu */
System.Random pseudoRandom = new System.Random();
Transform player = GameObject.Find("Joueur").transform;
GameObject pickUps = GameObject.Find("Pick Ups");
/* Position aléatoire du joueur */
aleatoireObjetSurMap(pseudoRandom, new List<Transform>() { player }, map, tailleCarre);
foreach (Transform child in pickUps.transform)
{
/* Position aléatoire des pick up */
aleatoireObjetSurMap(pseudoRandom, new List<Transform>() { child }, map, tailleCarre);
}
}
public ConstructionGrilleCDGSimulator(Grille grille)
: base(grille)
{
}
public ConstructionGrilleHoneyland(Grille grille)
: base(grille)
{
}
protected ConstructionGrilleStrategy(Grille tableau)
{
Tableau = tableau;
}
public ConstructionGrilleAOK(Grille tableau)
: base(tableau)
{
}
