public ScoreNodeView() { InitializeComponent(); nodeImage = this.FindControl <Image>("nodeImage"); nodeImage.Source = new Bitmap("Jeffistance.Client\\Assets\\Skullbisu.png"); State = ScoreState.NoResult; }
private async Task <DialogTurnResult> NameStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) { // Find the matching game to play and set up our state ScoreState ss = stepContext.SetStateAs(new ScoreState(_pdata.GetGameData(stepContext.GetResultAs <FoundChoice>().ToLowerCaseTrimmedString()))); return(await stepContext.BuildTextPrompt($"Great, let's play {ss.CurrentGame.GameName}, Please enter your name to begin.", cancellationToken)); }
public GameMain() { graphics = new GraphicsDeviceManager(this); Content.RootDirectory = "Content"; Window.AllowUserResizing = false; graphics.IsFullScreen = true; Resolution.Init(ref graphics); Resolution.SetVirtualResolution(VIRTUAL_WIDTH, VIRTUAL_HEIGHT); Resolution.SetResolution(GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width, GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height, true); gameStateManager = new GameStateManager(this); Components.Add(gameStateManager); TitleScreenState = new TitleScreenState(this); PlayState = new PlayState(this); ScoreState = new ScoreState(this); CountdownState = new CountdownState(this); gameStateManager.ChangeState((TitleScreenState)TitleScreenState); Components.Add(new InputHandler(this)); Window.ClientSizeChanged += new EventHandler <EventArgs>(Resize); }
/* ****************************************************** *** dropObject *** Zachary Languell ****************************************************** *** Handles when a ScoringObject is dropped. *** Method Inputs: *** forceDrop - A boolean variable that determines if a ScoringObject needs to force dropped. *** Return Values: *** NA ****************************************************** *** 11/17/2015 ****************************************************** */ public void dropObject(bool forceDrop) { // Sets the ScoringObject forceDrop variable to the boolean that was passed to the method. this.forceDrop = forceDrop; // If forceDrop is true, then score is set to 0. if (forceDrop) { this.score = 0; } // The variable scoreState is set to a dropped state. scoreState = ScoreState.Dropped; // If else statement is used to change the Y position of // the ScoringObject if the Y position is less than 600 + frameHeight // otherwise set isVisable to false. if (this.position.Y < 600 + frameHeight) { this.position.Y += 6; } else { isVisable = false; } }
void Awake() { text = this.GetComponent <UnityEngine.UI.Text>(); initTime = Time.time; state = ScoreState.normal; animator = GetComponent <Animator>(); // puts the object to the front (the last element to be drawn) transform.SetAsFirstSibling(); }
void StartFading() { state = ScoreState.fading; if (animator != null) { animator.SetTrigger("fade"); } Destroy(this.gameObject, 1.5f); }
public void Reset() { if (_state == ScoreState.Locked) { return; } _state = ScoreState.Unassigned; _value = 0; }
public void Preview(IEnumerable <int> dices) { if (_state == ScoreState.Locked) { return; } _value = _scorer(dices); _state = ScoreState.Preview; }
//constructor ------------------------------------------------------------------- public ScoreboardManager() { scoreNames = new List <string>(); highScores = new List <int>(); scoreState = ScoreState.loading; prevPressed = new bool[256]; characterLocations = new Vector2[] { new Vector2(198, 448), new Vector2(298, 448), new Vector2(398, 448) }; centerLeft = new Vector2(338, 448); topLeftThird = new Vector2(298, 128); playerName = "--"; }
//methods ----------------------------------------------------------------------- public GameState UpdateGameover() //method for updating the gameover screen { GameState toReturn = GameState.gameOver; currentKB = Keyboard.GetState(); switch (scoreState) { case ScoreState.loading: playerName = "--"; scoreNames.Clear(); highScores.Clear(); LoadScores(); index = TestHighScore(); if (index == 10) { scoreState = ScoreState.viewScore; } else { scoreState = ScoreState.getName; } break; case ScoreState.getName: if (playerName.Length != 3) { GetName(); } else { scoreNames.Insert(index, playerName); highScores.Insert(index, currentScore); scoreNames.RemoveAt(10); highScores.RemoveAt(10); scoreState = ScoreState.saving; } break; case ScoreState.saving: SaveScores(); scoreState = ScoreState.viewScore; break; case ScoreState.viewScore: if (currentKB.IsKeyDown(Keys.Enter)) { toReturn = GameState.start; } break; } previousKB = currentKB; return(toReturn); }
public void Awake() { m_par = 3; RenderSettings.ambientLight = ambientColor; //unpause the game GameConfig.setPaused(false); ScoreState ss = (ScoreState)GameObject.FindObjectOfType(typeof(ScoreState)); if (ss) { m_scoreStateGO = ss.gameObject; } //if its levle 1 reset the scores. int holeIndex = getHoleNomUsingCourse(); // Debug.Log("holeIndex"+holeIndex); if (holeIndex == 1) { setScoreForHole(getHoleNomUsingCourse(), currentNumberOfStrokes); setTotalScore(0); // m_totalScore=0; m_totalPar = 0; } else { // m_totalScore = getTotalScore(); } ParScript ps = (ParScript)GameObject.FindObjectOfType(typeof(ParScript)); if (ps) { m_par = ps.par; setParForHole(getHoleNomUsingCourse(), m_par); m_totalPar += m_par; } else { setParForHole(getHoleNomUsingCourse(), m_par); } //get a ref to the gamescript! GameObject go = GameObject.FindWithTag("Player"); if (go) { m_ballScript = go.GetComponent <BallScript>(); } GameManager.enterState(GameScript.State.INIT.ToString()); }
public DTController(DTenemy e, Orb o, Tree tree, ChaseState cS, GuardState gS, ScoreState sS, Goal pG, Goal eG) { this.e = e; this.tree = tree; this.cS = cS; this.gS = gS; this.sS = sS; this.o = o; currentState = new State(e, o, pG, eG); MakeDtree(); }
private async Task <DialogTurnResult> EndGameStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) { // Find the matching game to play and set up our state ScoreState so = stepContext.GetResultAs <ScoreState>(); await stepContext.Context.SendMultipleTextActivity(new[] { $"{so.PlayerName}, you finished the {so.CurrentGame.GameName} game!, with {so.GetCurrentScore()} points!", "Talk to me to restart" }); return(await stepContext.EndDialogAsync(so, cancellationToken)); }
private void Initialize() { inUseFallDelay = fallDelay; fallTimer = 0F; softDropTimer = 0F; hardDropTimer = 0F; scoreState = new ScoreState(0, 0); UpdateScore(); SpawnRandomShape(true); }
public void BaseAwake() { if (ToolBox.GetData(out sceneData)) { state = Serialyzer.RegisterState <ScoreState>("ScoreState"); targetScore = sceneData.TargetScore; OnAwake(); Subscribes(); } }
private void Disable() { var args = new MonoBehaviourEventArgs(this); _scoreState = ScoreState.SCORING_DISABLED; _renderer.enabled = false; _timedCounter.gameObject.SetActive(false); zenAbsorbEffect.Stop(); _light.enabled = false; Notifier.SendEventNotification(OnDeactivateEvent, args); }
public void SetFinalState(bool isWinner) { Winner = isWinner; if (isWinner) { FinalPicture = Image.FromFile("data/Final.png"); AddScores(500); } else { FinalPicture = Image.FromFile("data/Defeat.png"); } active = ScoreState.Final; }
public void LockIn() { if (_state == ScoreState.Unassigned) { throw new Exception("Cannot lock in score that hasn't been previewed."); } if (_state == ScoreState.Locked) { throw new Exception("State has already been locked."); } _state = ScoreState.Locked; }
public void ChangeState(bool isJeffistanceVictory) { var assets = AvaloniaLocator.Current.GetService <IAssetLoader>(); if (isJeffistanceVictory) { State = ScoreState.JeffistanceVictory; nodeImage.Source = AvaloniaTools.GetImageFromResources("Jeffistance.Client", "RoundStateResistenceVictory.png"); } else { State = ScoreState.SpyVictory; nodeImage.Source = AvaloniaTools.GetImageFromResources("Jeffistance.Client", "RoundStateSpyVictory.png"); } }
void ProcessLineRemoval(int clearedLines) { if (clearedLines <= 0) { scoreState.ResetCombo(); } else { scoreState += LineScoreHandler.GetScore(clearedLines, scoreState); scoreState.IncreaseCombo(); } UpdateScore(); }
private void Start() { if (instance == null) { instance = this; } else { Debug.LogError("More than once instance of the GameManager Singleton. Deleting the old instance."); DestroyImmediate(instance); instance = this; } if (headTransform == null) { Debug.LogError("Missing Head Transform! Game cannot continue correctly"); } // This number converts the look threshold to a dot product-comparable value // Save us from computing it every frame angleThresholdDot = Mathf.Cos(Mathf.Deg2Rad * angleThresholdDegrees); scoreState = ScoreState.CannotScore; levelIndex = 0; introButtonIndex = 0; gameState = GameState.Intro; levelStartTime = 0.0f; levelScoreThresholdTime = 0.0f; // Set up the intro buttons correctly foreach (GameObject gameObject in introButtons) { gameObject.SetActive(false); } initialLeftHandColor = leftHandRenderer.material.color; initialRightHandColor = rightHandRenderer.material.color; // Do this here incase we came from a restart RevertHandColors(); // Initialize API data for this session sessionData = new GameData(UUIDManager.instance.GetUUIDString()); // Start the intro action StartIntro(); }
// public methods public void Enable() { var args = new MonoBehaviourEventArgs(this); _scoreState = ScoreState.SCORING_ENABLED; _timedCounter.Reset(); _timedCounter.gameObject.SetActive(true); _renderer.enabled = true; _timedCounter.StartTimer(); zenAbsorbEffect.Play(); _light.enabled = true; Notifier.SendEventNotification(OnActivateEvent, args); }
void setState(ScoreState newState) { switch (newState) { case ScoreState.Normal: StateUpdate = normalUpdate; break; case ScoreState.Party: partyCountdown = secondsForCurrentParty; StateUpdate = partyUpdate; break; default: throw new System.ArgumentOutOfRangeException(); } currentState = newState; }
private ScoreState CreateScoreState(ScenarioController scenarioController) { var input = new ScoreStateInput(scenarioController); var state = new ScoreState(input, scenarioController); var menuTransition = new EventTransition(MenuState.StateName); input.NextEvent += menuTransition.ChangeState; var questionnaireTransition = new EventTransition(QuestionnaireState.StateName); input.InGameQuestionnaire += scenarioController.NextQuestionnaire; input.InGameQuestionnaire += questionnaireTransition.ChangeState; state.AddTransitions(menuTransition, questionnaireTransition); return(state); }
void Update() { if (gameState == GameState.Intro || gameState == GameState.Levels) { // Get the dot product between the head's forward direction and the world forward direction float lookDeviation = Vector3.Dot(Vector3.forward, headTransform.forward); // Only process a threshold violation if changing states if (Mathf.Abs(lookDeviation) > angleThresholdDot) { if (scoreState == ScoreState.CannotScore) { scoreState = ScoreState.CanScore; // Update visuals here if (gameState == GameState.Levels) { UpdateTransparency(currentConfig.bagConfiguration, 1.0f); } else { UpdateTransparency(introButtons[introButtonIndex], 1.0f); } } } else { if (scoreState == ScoreState.CanScore) { scoreState = ScoreState.CannotScore; // Update visuals again if (gameState == GameState.Levels) { UpdateTransparency(currentConfig.bagConfiguration, 0.2f); } else { UpdateTransparency(introButtons[introButtonIndex], 0.2f); } } } } }
public void EndGame() { gameState = GameState.Endgame; scoreState = ScoreState.CanScore; // Return everything to normal transparency UpdateTransparency(currentConfig.bagConfiguration, 1.0f); // Clean up all punching bags, hands, and buttons currentConfig.bagConfiguration.SetActive(false); // Set hands to universal interaction colors SetMultiHandColors(); // Set final score sessionData.FinalizeSessionData(ScoreManager.instance.GetTotalScore()); Debug.Log("Ending Game"); StartCoroutine(SendAPIData()); }
void LoadGame() { //Goals--------------------------------------------- eGoal = new Goal(new Vector2(1, 450)); pGoal = new Goal(new Vector2(1500, 450)); //-------------------------------------------------- //Player-------------------------------------------- p = new Player(tM.getTexture(1), Constants.GetRandomPos(), hitBoxes, tM, eGoal); p.Init(); //-------------------------------------------------- //Enemy--------------------------------------------- stEnemy1 = new StandardEnemy(tM.getTexture(3), new Vector2(50, 450), hitBoxes, tM, pGoal, Color.Red); stEnemy1.Init(); stEnemy2 = new StandardEnemy(tM.getTexture(3), Constants.GetRandomPos(), hitBoxes, tM, pGoal, Color.Blue); stEnemy2.Init(); //-------------------------------------------------- //DecisionTree Enemy----------------------------------------- dtEnemy = new DTenemy(tM.getTexture(3), new Vector2(50, 450), hitBoxes, tM, pGoal, Color.Purple); //------------------------------------------------------------ //Orb----------------------------------------------- aC = new AimControl(tM.getTexture(5), Vector2.Zero, p); orb = new Orb(tM.getTexture(4), Constants.GetRandomPos(), hitBoxes, Color.Red, 0.1f, p, stEnemy1, stEnemy2, dtEnemy, aC); orb.Init(); //-------------------------------------------------- //FuSM---------------------------------------------- //fuSM = new FuSMachine(p, orb, stEnemy1, stEnemy2, eGoal, pGoal); //-------------------------------------------------- //States--------------------------------------- gS = new GuardState(dtEnemy, orb, pGoal, eGoal); cS = new ChaseState(dtEnemy, orb, pGoal, eGoal); sS = new ScoreState(dtEnemy, orb, pGoal, eGoal); //-------------------------------------------------- dtController = new DTController(dtEnemy, orb, tree, cS, gS, sS, pGoal, eGoal); }
public void Awake() { m_par = 3; RenderSettings.ambientLight = ambientColor; m_courceController = (CourceController)GameObject.FindObjectOfType(typeof(CourceController)); //unpause the game GameConfig.setPaused(false); ScoreState ss = (ScoreState)GameObject.FindObjectOfType(typeof(ScoreState)); if (ss) { m_scoreStateGO = ss.gameObject; } //if its levle 1 reset the scores. int holeIndex = getHoleNomUsingCourse(); if (holeIndex == 1) { setScoreForHole(getHoleNomUsingCourse(), currentNumberOfStrokes); setTotalScore(0); // m_totalScore=0; m_totalPar = 0; } else { // m_totalScore = getTotalScore(); } ParScript ps = (ParScript)GameObject.FindObjectOfType(typeof(ParScript)); if (ps) { m_par = ps.par; setParForHole(getHoleNomUsingCourse(), m_par); m_totalPar += m_par; } else { setParForHole(getHoleNomUsingCourse(), m_par); } GameManager.enterState(GameScript.State.INIT.ToString()); }
private async Task <DialogTurnResult> AskQuestionDialogStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) { // Read in the passed down values from the parent dialog ScoreState ss = stepContext.SetStateAs(stepContext.GetOptionsAs <ScoreState>()); await stepContext.Context.SendTextActivity( $"Question {ss.GetCurrentPositionGame() + 1} coming up"); await Task.Delay(2500); switch (ss.CurrentGame.GameType) { case "Maths": return(await stepContext.BuildNumberPrompt(ss.GetCurrentQuestion(), cancellationToken)); case "Phonics": return(await stepContext.BuildTextPrompt(ss.GetCurrentQuestion(), cancellationToken)); } return(await stepContext.BuildTextPrompt("Something went wrong here, you don't seem to be following one of our standard games", cancellationToken)); }
public void LoadLeaders(bool FromLast = true) { Players = new List <string>(); StreamReader file = new StreamReader(@"" + LeadersFile); string line = ""; while ((line = file.ReadLine()) != null) { Players.Add(line); } Players.Remove(""); Players.Sort(Comparer); Players.Reverse(); for (int i = 0; i < Players.Count && FromLast; i++) { string nowPlayer = Score.ToString() + " " + Winner.ToString() + " " + name + " " + ArrayToString(WasAchievements, '/', 0); if (nowPlayer == Players[i]) { ShowNow = i; break; } } active = ScoreState.Leaders; }
// Update is called once per frame void Update () { float dt = Time.deltaTime; float rt = Time.time; if(!m_isPlaying) { if(Input.GetKeyUp(KeyCode.P)) { m_rt = rt; m_numStars = Random.Range(1, 11); Debug.Log("stars: " + m_numStars); m_timer = 1f; m_isPlaying = true; Debug.Log("LETTER " + (rt - m_rt) ); m_state = ScoreState.Letter; } } switch (m_state) { case ScoreState.Null: { } break; case ScoreState.Letter: { if(m_timer >= 0f) { m_timer -= dt; if(m_timer < 0f) { //m_hasNext = true; Debug.Log("STAR " + (rt - m_rt)); m_numStars--; m_timer = (m_numStars > 0) ? 0.5f : 1f; m_state = ScoreState.Star; } } } break; case ScoreState.Light: { } break; case ScoreState.Star: { if(m_timer >= 0f) { m_timer -= dt; if(m_timer < 0f) { if(m_numStars > 0) { m_numStars--; Debug.Log("STAR " + (rt - m_rt)); m_timer = (m_numStars > 0) ? 0.5f : 1f; } else { Debug.Log("TOTAL " + (rt - m_rt) ); m_timer = 1f; m_state = ScoreState.Total; } } } } break; case ScoreState.Total: { } break; } }
public override void Initialize() { toAdd = 0; Power = 100; state = ScoreState.Balance; float xScale = HalfSize.X * 2 / TextureSize; float yScale = HalfSize.Y * 2 / TextureSize; scale = new Vector2(xScale, yScale); base.Initialize(); }
public override void Initialize() { Score = 5f; toAdd = 0; scoreDropTimer = 0; ResetMultiplier(); State = ScoreState.Balance; float xScale = HalfSize.X * 2 / TextureSize; float yScale = HalfSize.Y * 2 / TextureSize; scale = new Vector2(xScale, yScale); base.Initialize(); }
public override void Update(GameTime gameTime) { //Delta Time. float dt = (float)gameTime.ElapsedGameTime.TotalSeconds; if (toAdd != 0) { //First calculate how many points max can be add or subtracted this frame. float pointsThisFrame = (PercentPerSecond * dt); //Are we gaining or loosing points? bool isDone; if (toAdd < 0) { //Reset the multiplier. ResetMultiplier(); //Check if these are the last points to subtract. pointsThisFrame *= -1; isDone = toAdd > pointsThisFrame; //Change to the appropriate state. State = ScoreState.Loss; //Don't drop score for to long. scoreDropTimer += dt; if (scoreDropTimer >= ScoreDropTimeLimit) { ClearStacks(); } } else { //Add the multiplier. pointsThisFrame *= multiplier; //Check if thes are the last points to add. isDone = toAdd < pointsThisFrame; //Change to the appropiate state. State = ScoreState.Gain; //Reset the scoreDropTimer. scoreDropTimer = 0; } //Check the value which we add to or subtract from the score. float diffValue = isDone ? toAdd : pointsThisFrame; //Change toAdd and the score with score to be added or subtracted this frame. toAdd -= diffValue; Score += diffValue; } else { //Reset the scoreDropTimer. scoreDropTimer = 0; //Change to the appropiate state. State = ScoreState.Balance; } //Check if reached any score border. if (Score <= 0) { (GDGame.GetActiveScreen() as GameplayScreen).GameOver(); } else if (Score >= Goal) { (GDGame.GetActiveScreen() as GameplayScreen).Won(); } //Multiplier logic. if (forcedTimer == 0) { multiplierTimer += dt; if (multiplierTimer >= MultiplierTimeBorder) { ResetMultiplier(); } //Lastly the time. timeCounter += dt; if (timeCounter >= SecondsPerPointDrop) { timeCounter -= SecondsPerPointDrop; SubtractScore(PercentDropByTimeBorder, false); } } else { forcedTimer -= dt; if (forcedTimer <= 0) { ResetMultiplier(); } } if (isTimeLimited) { timeLeft -= dt; if (timeLeft <= 0) { (GDGame.GetActiveScreen() as GameplayScreen).GameOver(); } } base.Update(gameTime); }
public void ChangeColor(string param) { if (state == RatingsState.Static) { if (param == "criticality") { if (criticality == 0) { scoreState = ScoreState.None; return; } if (criticality < ConfigurationSettings.Instance.BOMlowThreshold1) scoreState = ScoreState.High; if (criticality >= ConfigurationSettings.Instance.BOMlowThreshold1 && criticality <= averageAmount) scoreState = ScoreState.Medium; if (criticality > averageAmount) scoreState = ScoreState.Low; } if (param == "differentiation") { if (differentiation == 0) { scoreState = ScoreState.None; return; } if (differentiation < ConfigurationSettings.Instance.BOMlowThreshold1) scoreState = ScoreState.High; if (differentiation >= ConfigurationSettings.Instance.BOMlowThreshold1 && differentiation <= ConfigurationSettings.Instance.BOMhighThreshold1) scoreState = ScoreState.Medium; if (differentiation > ConfigurationSettings.Instance.BOMhighThreshold1) scoreState = ScoreState.Low; } if (param == "effectiveness") { if (effectiveness == 0) { scoreState = ScoreState.None; return; } if (effectiveness < ConfigurationSettings.Instance.BOMlowThreshold1) scoreState = ScoreState.High; if (effectiveness >= ConfigurationSettings.Instance.BOMlowThreshold1 && effectiveness <= ConfigurationSettings.Instance.BOMhighThreshold1) scoreState = ScoreState.Medium; if (effectiveness > ConfigurationSettings.Instance.BOMhighThreshold1) scoreState = ScoreState.Low; } if (param == "bomscore") { if (totalBOMScore == 0) { scoreState = ScoreState.None; return; } if (totalBOMScore < ConfigurationSettings.Instance.BOMlowThreshold1) scoreState = ScoreState.High; if (totalBOMScore >= ConfigurationSettings.Instance.BOMlowThreshold1 && totalBOMScore <= ConfigurationSettings.Instance.BOMhighThreshold1) scoreState = ScoreState.Medium; if (totalBOMScore > ConfigurationSettings.Instance.BOMhighThreshold1) scoreState = ScoreState.Low; } } }
/// <summary> /// Uses the power and starts dropping it. /// The power gain cooldown automaticly starts. /// </summary> /// <param name="playerPos">The player's position for the power.</param> public void UsePower(Vector2 playerPos) { if (state != ScoreState.Gain) { //Don't activate a power if you can't use it. return; } //Drop the power over time. toAdd = -100; state = ScoreState.Loss; //Create the PowerBall. PowerBall temp = new PowerBall(GDGame, playerPos); GDGame.GetActiveScreen().Components.Add(temp); temp.Initialize(); }
public override void Update(GameTime gameTime) { //Power addition logic. if (toAdd != 0) { float dt = (float)gameTime.ElapsedGameTime.TotalSeconds; float powerThisFrame = dt * PercentPerSecond; //How much do we add? bool isDone; if (toAdd < 0) { powerThisFrame *= -1; isDone = toAdd > powerThisFrame; } else { isDone = toAdd < powerThisFrame; } float diffValue = isDone ? toAdd : powerThisFrame; toAdd -= diffValue; //And now add the Power. Power += diffValue; } //Power state logic. switch (state) { case ScoreState.Loss: if (Power == 0) { state = ScoreState.Balance; } break; case ScoreState.Balance: if (Power == 100) { state = ScoreState.Gain; } break; } base.Update(gameTime); }