// Decompiled with JetBrains decompiler
// Type: Piste
// Assembly: Assembly-CSharp, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: FABEABAD-DE18-438F-AE7D-0BB4BBA5B6CD
// Assembly location: C:\Users\La Machine\Desktop\Démo AS-3D-2017\Démo AS-3D-2017_Data\Managed\Assembly-CSharp.dll

using System.Collections.Generic;
using UnityEngine;

public class Piste : MonoBehaviour
{
  private const int NB_TRIANGLES_PAR_TUILE = 2;
  private const int NB_SOMMETS_PAR_TRIANGLE = 3;
  private const float AJUSTEMENT_HAUTEUR = 0.7f;
  private const float SCALING_PISTE = 0.85f;
  [SerializeField]
  private GameObject PaysageDeLaPiste;
  [SerializeField]
  private GameObject SphèreÀAnimer;
  [SerializeField]
  private GameObject CubeÀRamasser;
  private Vector3 Origine;

  private CarteDeHauteur CarteContrôleur { get; set; }

  private Mesh Maillage { get; set; }

  private Vector3[] Sommets { get; set; }

  private Vector2[] CoordonnéesTexture { get; set; }

  private DataPiste DonnéesPiste { get; set; }

  private List<Vector3> BordureExtérieure { get; set; }

  private List<Vector3> BordureIntérieure { get; set; }

  private List<Vector3> PointsCube { get; set; }

  private List<Vector3> PointsPatrouille { get; set; }

  private Vector3 PositionSphère { get; set; }

  private int NbColonnes { get; set; }

  private int NbRangées { get; set; }

  private int NbSommets { get; set; }

  private int NbTriangles { get; set; }

  private List<GameObject> listeCubes { get; set; }

  private GameObject SphèreAutomate { get; set; }

  private SphèreTexturée SphèreContrôleur { get; set; }

  private void Start()
  {
    this.CarteContrôleur = this.PaysageDeLaPiste.GetComponent<CarteDeHauteur>();
    this.CréerPiste();
    this.CréerCubes();
    this.CréerSphèreAutomate();
  }

  private void CréerPiste()
  {
    this.Origine = new Vector3(this.CarteContrôleur.Origine.x, 0.0f, this.CarteContrôleur.Origine.z);
    this.ChargerDonnéesPiste();
    this.CalculerDonnéesDeBase();
    this.GénérerTriangles();
  }

  private void ChargerDonnéesPiste()
  {
    this.DonnéesPiste = new DataPiste(this.CarteContrôleur.DimensionCarte, "SplineX.txt", "SplineY.txt");
    this.BordureIntérieure = this.AjusterPoints(this.DonnéesPiste.GetBordureExtérieure(), 0.85f);
    this.BordureExtérieure = this.AjusterPoints(this.DonnéesPiste.GetBordureIntérieure(), 0.85f);
    this.PointsCube = this.AjusterPoints(this.DonnéesPiste.GetPointsCube(), 0.85f);
    this.PointsPatrouille = this.AjusterPoints(this.DonnéesPiste.GetPointsDePatrouille(), 0.85f);
    this.PositionSphère = this.PointsCube[0];
  }

  private List<Vector3> AjusterPoints(List<Vector2> listePts2D, float valeurScaling)
  {
    List<Vector3> vector3List = new List<Vector3>();
    Vector2 scale = new Vector2(valeurScaling, valeurScaling);
    float num = (float) ((double) this.CarteContrôleur.NbColonnes * (1.0 - (double) valeurScaling) / 2.0);
    Vector2 vector2_1 = new Vector2(num, num);
    for (int index = 0; index < listePts2D.Count; ++index)
    {
      Vector2 vector2_2 = listePts2D[index];
      vector2_2.Scale(scale);
      Vector2 vecteurTemporaire = vector2_2 + vector2_1;
      vector3List.Add(this.CréerPt3D(vecteurTemporaire));
    }
    return vector3List;
  }

  private Vector3 CréerPt3D(Vector2 vecteurTemporaire)
  {
    Vector3 vector3_1 = new Vector3(vecteurTemporaire.x, 0.0f, vecteurTemporaire.y);
    Vector3 pointSpatial = this.CarteContrôleur.GetPointSpatial((int) Mathf.Round(vector3_1.x), (int) Mathf.Round(vector3_1.z));
    Vector3 vector3_2 = pointSpatial - this.Origine - vector3_1;
    vector3_2.y = 0.0f;
    Vector3 vector3_3 = pointSpatial - vector3_2;
    vector3_3.y += 0.7f;
    return vector3_3;
  }

  private void CalculerDonnéesDeBase()
  {
    this.NbColonnes = this.BordureExtérieure.Count;
    this.NbRangées = 1;
    this.NbSommets = this.NbColonnes * (this.NbRangées + 1);
    this.NbTriangles = (this.NbColonnes - 1) * 2;
  }

  private void GénérerTriangles()
  {
    this.Maillage = new Mesh();
    this.Maillage.name = nameof (Piste);
    this.GénérerSommetsEtTexture();
    this.GénérerListeTriangles();
    this.TexturerSurface();
    this.GetComponent<MeshFilter>().mesh = this.Maillage;
    this.GetComponent<MeshCollider>().sharedMesh = this.Maillage;
  }

  private void GénérerSommetsEtTexture()
  {
    int indiceSommet = 0;
    this.Sommets = new Vector3[this.NbSommets];
    this.CoordonnéesTexture = new Vector2[this.NbSommets];
    this.GénérerSommetsBordure(this.BordureIntérieure, 0, ref indiceSommet);
    this.GénérerSommetsBordure(this.BordureExtérieure, 1, ref indiceSommet);
    this.Maillage.vertices = this.Sommets;
    this.Maillage.uv = this.CoordonnéesTexture;
  }

  private void GénérerSommetsBordure(List<Vector3> listeBordure, int noRangée, ref int indiceSommet)
  {
    float x = 0.0f;
    for (int index1 = 0; index1 < this.NbColonnes; ++index1)
    {
      this.Sommets[indiceSommet] = listeBordure[index1];
      Vector2[] coordonnéesTexture = this.CoordonnéesTexture;
      int num;
      indiceSommet = (num = indiceSommet) + 1;
      int index2 = num;
      coordonnéesTexture[index2] = new Vector2(x, (float) noRangée);
      x = (double) x != 0.0 ? 0.0f : 1f;
    }
  }

  private void GénérerListeTriangles()
  {
    int[] triangles = new int[this.NbTriangles * 3];
    int indiceTriangle = 0;
    int num1 = 0;
    for (int index = 0; index < this.NbColonnes - 1; ++index)
    {
      int indiceA = num1;
      int num2 = indiceA + this.NbColonnes;
      this.AjouterTriangle(triangles, indiceA, num2, indiceA + 1, ref indiceTriangle);
      this.AjouterTriangle(triangles, num2, num2 + 1, indiceA + 1, ref indiceTriangle);
      ++num1;
    }
    this.Maillage.triangles = triangles;
    this.Maillage.RecalculateNormals();
  }

  public bool EstDansLeSensDesAiguillesDUneMontre(int indPtA, int indPtB, int indPtC)
  {
    Vector3 sommet1 = this.Sommets[indPtA];
    Vector3 sommet2 = this.Sommets[indPtB];
    Vector3 sommet3 = this.Sommets[indPtC];
    return (double) ((float) (((double) sommet2.x - (double) sommet1.x) * ((double) sommet2.z + (double) sommet1.z)) + (float) (((double) sommet3.x - (double) sommet2.x) * ((double) sommet3.z + (double) sommet2.z)) + (float) (((double) sommet1.x - (double) sommet3.x) * ((double) sommet1.z + (double) sommet3.z))) > 0.0;
  }

  private void AjouterTriangle(int[] triangles, int indiceA, int indiceB, int indiceC, ref int indiceTriangle)
  {
    int[] numArray1 = triangles;
    int num1;
    indiceTriangle = (num1 = indiceTriangle) + 1;
    int index1 = num1;
    int num2 = indiceA;
    numArray1[index1] = num2;
    int[] numArray2 = triangles;
    int num3;
    indiceTriangle = (num3 = indiceTriangle) + 1;
    int index2 = num3;
    int num4 = indiceB;
    numArray2[index2] = num4;
    int[] numArray3 = triangles;
    int num5;
    indiceTriangle = (num5 = indiceTriangle) + 1;
    int index3 = num5;
    int num6 = indiceC;
    numArray3[index3] = num6;
  }

  private void TexturerSurface()
  {
    Vector4[] vector4Array = new Vector4[this.Sommets.Length];
    Vector4 vector4 = new Vector4(1f, 0.0f, 0.0f, -1f);
    for (int index = 0; index < vector4Array.Length; ++index)
      vector4Array[index] = vector4;
    this.Maillage.tangents = vector4Array;
  }

  private void CréerCubes()
  {
    this.listeCubes = new List<GameObject>();
    Quaternion identity = Quaternion.identity;
    for (int index = 1; index < this.PointsCube.Count; ++index)
      this.listeCubes.Add(Object.Instantiate<GameObject>(this.CubeÀRamasser, this.PointsCube[index] + Vector3.up, identity, this.transform));
  }

  private void CréerSphèreAutomate()
  {
    this.SphèreAutomate = Object.Instantiate<GameObject>(this.SphèreÀAnimer, this.PositionSphère, Quaternion.identity, this.transform);
    this.SphèreContrôleur = this.SphèreAutomate.GetComponent<SphèreTexturée>();
    this.SphèreContrôleur.InitialiserPointsDePatrouille(this.PointsPatrouille);
  }
}