/// <summary>
        /// Initialisateur appelé par le constructeur et la fenêtre lors de l'actualisation du menu.
        /// Permet notamment de recréer le menu des sauvegardes, au cas où elles ont changé, et d'actualiser le
        /// highscore.
        /// </summary>
        public void Update()
        {
            // Charge les sorts et les sauvegardes
            GameSave.Load();

            _highScore = new Text("High Score : " + GameSave.HighScore, 18);

            var savesMenu = new ChooseSaveState(Form, this);

            var b1 = new Button(new Point(300, 700), "Nouvelle partie", () =>
            {
                Form.SetState(new NewGameState(Form, this));
            });
            var b2 = new Button(new Point(600, 700), "Charger partie", () =>
            {
                Form.SetState(savesMenu);
            });
            var b3 = new Button(new Point(900, 700), "Quitter", () =>
            {
                Form.Close();
            });

            b1.RightButton = b2;
            b2.RightButton = b3;
            b3.LeftButton  = b2;
            b2.LeftButton  = b1;

            ButtonsHandler = new ButtonsHandler(b1);
            ButtonsHandler.Add(b2);
            ButtonsHandler.Add(b3);
            ButtonsHandler.LinkToEchap(b3);
        }
Example #2
0
    // Update is called once per frame
    void Update()
    {
        if (m_gs == GameState.EStart)
        {
            if (timeToStartGame > 0)
            {
                timeToStartGame -= Time.deltaTime;
            }
            else
            {
                m_gs            = GameState.EBlinking;
                timeToStartGame = 3f;
                blinkButton     = Random.Range(0, buttons.Count);
                GameObject     but = (GameObject)buttons [blinkButton];
                ButtonsHandler bt  = but.GetComponent <ButtonsHandler> ();
                bt.Blink();
                Debug.Log("BO COUNT" + buttonsOrderGenerated.Count);
                buttonsOrderGenerated.Add(bt.name);
                m_uiText.text = "Follow blinks";
            }
        }
        else if (m_gs == GameState.EBlinking)
        {
            if (blinkTime > 0)
            {
                blinkTime -= Time.deltaTime;
            }
            else if (coolDownTime > 0)
            {
                coolDownTime -= Time.deltaTime;
                GameObject     but = (GameObject)buttons [blinkButton];
                ButtonsHandler bt  = but.GetComponent <ButtonsHandler> ();
                bt.Regular();
            }
            else
            {
                blinkTime    = 1f;
                coolDownTime = 0.5f;
                blinkTimes++;

                if (blinkTimes < buttons.Count * 2)
                {
                    m_uiText.text = "Follow blinks" + blinkTimes;
                    blinkButton   = Random.Range(0, buttons.Count);
                    GameObject     butNew = (GameObject)buttons [blinkButton];
                    ButtonsHandler btNew  = butNew.GetComponent <ButtonsHandler> ();
                    btNew.Blink();

                    buttonsOrderGenerated.Add(btNew.name);
                }
                else
                {
                    m_uiText.text = "Now you. Take your time" + blinkTimes;

                    m_gs       = GameState.EUserTurn;
                    blinkTimes = 0;
                }
            }
        }
    }
Example #3
0
        /// <summary>
        /// Crée le menu en jeu avec la possibilité de créer une nouvelle sauvegarde, de revenir en jeu ou de retourner
        /// au menu principal.
        /// </summary>
        /// <param name="form"> La fenêtre de l'application </param>
        /// <param name="state"> L'état de la partie </param>
        public GameMenuState(MainForm form, WindowsState state) : base(form, Screen)
        {
            var tooMuchSave = new TooMuchSaveState(Form, this);

            var bSave = new Button(new Point(600, 250), "Sauvegarder", () =>
            {
                if (GameSave.Saves.Count >= GameSave.NbMax)
                {
                    Form.SetState(tooMuchSave);
                }
                else
                {
                    Form.SetState(new CreateSaveState(Form, this));
                }
            });
            var bRetour = new Button(new Point(600, 400), "Retour", () =>
            {
                Form.SetState(state);
                ButtonsHandler.Reset();
            });
            var bMenu = new Button(new Point(600, 550), "Menu principal", () =>
            {
                Form.SetMainMenuState();
            });

            bSave.BottomButton   = bRetour;
            bRetour.TopButton    = bSave;
            bRetour.BottomButton = bMenu;
            bMenu.TopButton      = bRetour;

            ButtonsHandler = new ButtonsHandler(bSave);
            ButtonsHandler.Add(bRetour);
            ButtonsHandler.Add(bMenu);
            ButtonsHandler.LinkToEchap(bRetour);
        }
 /// <summary>
 /// Crée l'état avec un unique bouton menant vers l'état précédent.
 /// </summary>
 /// <param name="form"> La fenêtre de l'application </param>
 /// <param name="state"> L'état précédent </param>
 public TooMuchSaveState(MainForm form, WindowsState state) : base(form, Screen)
 {
     ButtonsHandler = new ButtonsHandler(new Button(new Point(450, 400), "Nombre maximal de sauvegardes atteint",
                                                    () =>
     {
         Form.SetState(state);
     }));
 }
Example #5
0
    // Use this for initialization
    void Awake()
    {
        GameManager.Notifications.AddListener(this, GAME_EVENTS.ShowResult);
        GameManager.Notifications.AddListener(this, GAME_EVENTS.BuildTask);
        GameManager.Notifications.AddListener(this, GAME_EVENTS.LoadedVocabulary);

        contextPanel   = contextText.transform.parent.gameObject;
        buttonsHandler = FindObjectOfType <ButtonsHandler>();
    }
Example #6
0
        /// <summary>
        /// Crée l'état avec une paire de boutons par map pour créer la nouvelle partie avec la map et le nombre de
        /// joueurs souhaité.
        /// </summary>
        /// <param name="form"> La fenêtre de l'application </param>
        /// <param name="state"> L'état précédent de l'application </param>
        public NewGameState(MainForm form, WindowsState state) : base(form, Screen)
        {
            var maps = Map.MapNames();
            var b    = new Button[2, maps.Count];

            // Création des boutons
            var bRetour = new Button(new Point(600, 700), "Retour", () =>
            {
                Form.SetState(state);
            });

            for (var j = 0; j < maps.Count; ++j)
            {
                var numMap = j;
                b[0, j] = new Button(new Point(450, 200 + 150 * j), maps[j] + "\n(Duo)", () =>
                {
                    Form.SetState(new GameState(Form, numMap, 2));
                });
                b[1, j] = new Button(new Point(750, 200 + 150 * j), maps[j] + "\n(Solo)", () =>
                {
                    Form.SetState(new GameState(Form, numMap, 1));
                });
            }

            // Liaison des boutons entre eux
            for (var j = 0; j < maps.Count; ++j)
            {
                if (j < maps.Count - 1)
                {
                    b[0, j].BottomButton = b[0, j + 1];
                    b[1, j].BottomButton = b[1, j + 1];
                }
                else
                {
                    b[0, j].BottomButton = bRetour;
                    b[1, j].BottomButton = bRetour;
                }
                if (j > 0)
                {
                    b[0, j].TopButton = b[0, j - 1];
                    b[1, j].TopButton = b[1, j - 1];
                }
                b[0, j].RightButton = b[1, j];
                b[1, j].LeftButton  = b[0, j];
            }
            bRetour.TopButton = b[0, 0];

            // Création du ButtonHandler
            ButtonsHandler = new ButtonsHandler(bRetour);
            foreach (var button in b)
            {
                ButtonsHandler.Add(button);
            }
            ButtonsHandler.LinkToEchap(bRetour);
        }
Example #7
0
 // Use this for initialization
 void Start()
 {
     buttonsDatabase = buttonsDatabase.GetComponent<ButtonsDatabase>();
     buttonsHandler = GetComponent<ButtonsHandler>();
     endGameText = endGameText.GetComponent<Text>();
     buttonAgain = buttonAgain.GetComponent<Button>();
     imageAtEnd = imageAtEnd.GetComponent<Image>();
     buttonBackToMenu = buttonBackToMenu.GetComponent<Button>();
     scoreScript = scoreScript.GetComponent<ScoreScript>();
     buttonResetScore = buttonResetScore.GetComponent<Button>();
     textResetScore = buttonResetScore.GetComponentInChildren<Text>();
     textBackToMenu = buttonBackToMenu.GetComponentInChildren<Text>();
     textPlayAgain = buttonAgain.GetComponentInChildren<Text>();
     isRunning = true;
 }
Example #8
0
    private void Awake()
    {
        xMaxValue = 500f;
        xMinValue = 0f;

        yMaxValue = 500f;
        yMinValue = 0f;

        distanceMaxValue = 100f;
        distanceMinValue = 0f;

        originXValue = (xMaxValue - xMinValue) / 2f;
        originYValue = (yMaxValue - yMinValue) / 2f;

        reversedistanceFactor = distanceMaxValue / 5f;
        reversexFactor        = xMaxValue / 3f;
        reverseyFactor        = yMaxValue / 3f;

        drawGraph      = GraphObject.GetComponent <Sim_DrawGraph>();
        ballTransform  = ballObject.GetComponent <Transform>();
        ballRigid      = ballObject.GetComponent <Rigidbody>();
        vibrationTimer = Time.fixedTime;
        rotateTimer    = Time.fixedTime;
        bounced        = false;
        tForm          = GetComponent <Transform>();
        rBody          = GetComponent <Rigidbody>();
        uiHandler      = UIObject.GetComponent <Sim_UIHandler>();
        blHandler      = BallLocationHandlerObject.GetComponent <Sim_BallLocationHandler>();
        bhHandler      = BallHeightObject.GetComponent <Sim_BallHeightHandler>();

        bHandler = ButtonsObject.GetComponent <ButtonsHandler>();

        ready     = true;
        balancing = true;
        bouncing  = false;

        tForm.position    = new Vector3(0, 0, 0);
        rBody.isKinematic = true;

        balanceLocationX = originXValue;
        balanceLocationY = originYValue;
    }
        /// <summary>
        /// Crée l'état corerspondant au game over avec la possibilité de revenir au menu principal ou de quitter
        /// l'application. Affiche le score atteint par les joueurs.
        /// </summary>
        /// <param name="form"> La fenêtre de l'application </param>
        /// <param name="score"> Le score final </param>
        public GameOverState(MainForm form, int score) : base(form, Screen)
        {
            _score = new Text("Score : " + score, 18);
            if (score > GameSave.HighScore)
            {
                GameSave.HighScore = score;
            }

            var bMenu = new Button(new Point(450, 700), "Menu principal", () =>
            {
                Form.SetMainMenuState();
            });
            var bClose = new Button(new Point(750, 700), "Quitter", () =>
            {
                Form.Close();
            });

            bMenu.RightButton = bClose;
            bClose.LeftButton = bMenu;

            ButtonsHandler = new ButtonsHandler(bMenu);
            ButtonsHandler.Add(bClose);
        }
Example #10
0
 protected void Page_Load(object sender, EventArgs e)
 {
     ButtonsModel model = null;
     this.ListPageLoad(this.Page, out model, base.Request["code"]);
     this.Buttons1_1.BM = model;
     ButtonsHandler handler = new ButtonsHandler(this.Buttons);
     handler(this.ibtid.Value);
     this.ibtid.Value = "";
     if (!this.Page.IsPostBack)
     {
         DataSet set = new PD_PROJECT_INSPECTION_Bll().HeDuiData(base.Request["code"]);
         if ((set != null) && (set.Tables[0].Columns.Count > 0))
         {
             this.gvResult.DataKeyNames = new string[] { set.Tables[0].Columns[0].ColumnName };
             for (int i = 0; i < set.Tables[0].Columns.Count; i++)
             {
                 BoundField field = new BoundField
                 {
                     DataField = set.Tables[0].Columns[i].ColumnName,
                     HeaderText = set.Tables[0].Columns[i].ColumnName,
                     SortExpression = set.Tables[0].Columns[i].ColumnName
                 };
                 field.ItemStyle.HorizontalAlign = HorizontalAlign.Center;
                 this.gvResult.Columns.Add(field);
             }
             this.gvResult.DataSource = set;
             if (set.Tables[0].Rows.Count == 0)
             {
                 set.Tables[0].Columns[0].DataType = typeof(string);
                 set.Tables[0].Rows.Add(set.Tables[0].NewRow());
                 set.Tables[0].Rows[0][0] = "无数据";
                 this.gvResult.DataSource = set;
                 this.gvResult.DataBind();
                 this.gvResult.Rows[0].Cells[0].ColumnSpan = set.Tables[0].Columns.Count;
                 int num2 = 1;
                 while (num2 < this.gvResult.Rows[0].Cells.Count)
                 {
                     this.gvResult.Rows[0].Cells.Remove(this.gvResult.Rows[0].Cells[num2]);
                 }
             }
             else
             {
                 set.Tables[0].DefaultView.RowFilter = "是否完全符合<>'是'";
                 DataView defaultView = set.Tables[0].DefaultView;
                 string str = "";
                 for (int j = 0; j < defaultView.Count; j++)
                 {
                     for (int k = 0; k < set.Tables[0].Columns.Count; k++)
                     {
                         object obj2 = str;
                         str = string.Concat(new object[] { obj2, "【", set.Tables[0].Columns[k].ColumnName, ":", defaultView[j][set.Tables[0].Columns[k].ToString()], "】" });
                         if (k < (set.Tables[0].Columns.Count - 1))
                         {
                             str = str + "、";
                         }
                     }
                     if (j < (defaultView.Count - 1))
                     {
                         str = str + "\r\n";
                     }
                 }
                 this.jgjlText_H.Value = str;
                 this.gvResult.DataBind();
             }
         }
     }
 }
        /// <summary>
        /// Crée l'état avec le bouton retour permettant de retourner au menu principal.
        /// Une grille de boutons est crée, chaque bouton correpondant à une sauvegarde qui peut être chargée pour
        /// entrer en jeu.
        /// </summary>
        /// <param name="form"> La fenêtre de l'application </param>
        /// <param name="mainMenu"> Le menu principal </param>
        public ChooseSaveState(MainForm form, WindowsState mainMenu) : base(form, Screen)
        {
            var bRetour = new Button(new Point(600, 700), "Retour", () =>
            {
                Form.SetState(mainMenu);
            });

            // Remplit de gauche à droite et de haut en bas la grille de 3x3 sauvegardes
            var bSaves = new Button[3, 3];

            for (var num = 0; num < GameSave.Saves.Count; ++num)
            {
                var i         = num / 3;
                var j         = num % 3;
                var save      = GameSave.Saves[num];
                var playerStr = save.NumberOfPlayers == 1 ? "Solo" : "Duo";
                bSaves[i, j] = new Button(new Point(300 + j * 300, 200 + i * 150),
                                          save.Name + '\n' + playerStr + ", niveau " + save.Level, () =>
                {
                    Form.SetState(new GameState(form, save));
                });
            }

            // Relie les boutons de la grille entre eux
            for (var i = 0; i < 3; ++i)
            {
                for (var j = 0; j < 3; ++j)
                {
                    var save = bSaves[i, j];
                    if (save == null)
                    {
                        continue;
                    }

                    if (i + 1 >= 3 || bSaves[i + 1, j] == null)
                    {
                        save.BottomButton = bRetour;
                    }
                    else
                    {
                        save.BottomButton = bSaves[i + 1, j];
                    }
                    if (i > 0)
                    {
                        save.TopButton = bSaves[i - 1, j];
                    }
                    if (j > 0)
                    {
                        save.LeftButton = bSaves[i, j - 1];
                    }
                    if (j < 2 && bSaves[i, j + 1] != null)
                    {
                        save.RightButton = bSaves[i, j + 1];
                    }
                }
            }
            if (bSaves[0, 1] != null)
            {
                bRetour.TopButton = bSaves[0, 1];
            }
            else if (bSaves[0, 0] != null)
            {
                bRetour.TopButton = bSaves[0, 0];
            }

            ButtonsHandler = new ButtonsHandler(bRetour);
            foreach (var b in bSaves)
            {
                if (b != null)
                {
                    ButtonsHandler.Add(b);
                }
            }
            ButtonsHandler.LinkToEchap(bRetour);
        }