public static bool SpecialNavigationSystem( this UFEScreen screen, int player, MoveCursorCallback moveCursorCallback = null, ActionCallback confirmCallback = null, ActionCallback cancelCallback = null ) { //------------------------------------------------------------------------------------------------------------- // Retrieve the controller assigned to specified player //------------------------------------------------------------------------------------------------------------- AbstractInputController inputController = UFE.GetController(player); if (inputController != null && UFE.eventSystem != null && UFE.eventSystem.isActiveAndEnabled) { return(UFEScreenExtensions.SpecialNavigationSystem( inputController, inputController.GetAxisRaw(inputController.horizontalAxis), inputController.GetAxisRaw(inputController.verticalAxis), inputController.GetButtonDown(inputController.horizontalAxis), inputController.GetButtonDown(inputController.verticalAxis), inputController.GetButtonDown(UFE.config.inputOptions.confirmButton), inputController.GetButtonDown(UFE.config.inputOptions.cancelButton), moveCursorCallback, confirmCallback, cancelCallback )); } return(false); }
protected virtual void TryConnect() { // First, we check that we aren't already connected to a client or a server... if (!UFE.multiplayerAPI.IsConnected() && !this._connecting) { MultiplayerAPI.MatchInformation match = null; // After that, check if we have found one match with at least one player which isn't already full... while (match == null && this._foundServers.Count > 0) { match = this._foundServers[0]; this._foundServers.RemoveAt(0); } if (match != null) { // In that case, try connecting to that match this._connecting = true; UFE.multiplayerAPI.OnJoined += this.OnJoined; UFE.multiplayerAPI.OnJoinError += this.OnJoinError; UFE.JoinGame(match); } else { // Otherwise, return a net a new match this.OnLanGameNotFound(); } } }
protected override void OnGamePaused(bool isPaused) { base.OnGamePaused(isPaused); if (this.pauseScreen != null) { if (isPaused) { this.pause = (UFEScreen)GameObject.Instantiate(this.pauseScreen); this.pause.transform.SetParent(UFE.canvas != null ? UFE.canvas.transform : null, false); this.pause.OnShow(); } else if (this.pause != null) { if (!this.hiding) { AudioClip clip = this.GetStageMusic(UFE.config.selectedStage); if (clip != null) { UFE.PlayMusic(clip); } } this.pause.OnHide(); GameObject.Destroy(this.pause.gameObject); } } }
protected virtual void TrySelectOption(int option, int player) { // Check if he was playing online or not... if (!UFE.isConnected) { // If it's a local game, go to the selected screen immediately... this.SelectOption(option, player); } else { // If it's an online game, we need to inform the other client about the screen we want to go... int localPlayer = UFE.GetLocalPlayer(); if (localPlayer == player) { UFEController controller = UFE.GetController(localPlayer); // We don't invoke the OnstageSelected() method immediately because we are using the frame-delay // algorithm to keep players synchronized, so we can't invoke the OnstageSelected() method // until the other player has received the message with our choice. controller.GetType().GetMethod( "RequestOptionSelection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy, null, new Type[] { typeof(int) }, null ).Invoke(controller, new object[] { option }); } } }
protected virtual void OnGameBegin(CharacterInfo player1, CharacterInfo player2, StageOptions stage) { this.player1.character = player1; UFE.updatedLifePoints = UFE.config.player1Character.currentLifePoints; // // if (UFE.lifepointsCheck == true) { // this.player1.targetLife = UFE.updatedLifePoints; // this.player1.totalLife = 500.0f; // } else { this.player1.targetLife = PlayerPrefs.GetFloat("HEALTH"); this.player1.totalLife = 500.0f; // } this.player1.wonRounds = 0; this.player2.character = player2; this.player2.targetLife = player2.lifePoints; this.player2.totalLife = player2.lifePoints; this.player2.wonRounds = 0; UFE.PlayMusic(stage.music); this.isRunning = true; // making application pause to show popups for buying weapons if (IntroScreen.characterValue == 2 || IntroScreen.characterValue == 3 || IntroScreen.characterValue == 4 || IntroScreen.characterValue == 5 || IntroScreen.characterValue <= 13 || IntroScreen.characterValue == 18 || IntroScreen.characterValue == 19 || IntroScreen.characterValue == 20 || IntroScreen.characterValue == 21) { Invoke("pauseFn", 5f); } else { } }
protected virtual void MoveCursor(AbstractInputController controller) { if (!UFE.isConnected) { // If it's a local game, update the corresponding character immediately... if (UFE.config.player1Character == null) { this.MoveCursor(controller, 1); } else if (UFE.config.player2Character == null && UFE.gameMode != GameMode.StoryMode) { this.MoveCursor(controller, 2); } } else { // If it's an online game, find out if the local player is Player1 or Player2... // And only update the selection for the local player... int localPlayer = UFE.GetLocalPlayer(); if (localPlayer == 1 && UFE.config.player1Character == null) { this.MoveCursor(controller, 1); } else if (localPlayer == 2 && UFE.config.player2Character == null) { this.MoveCursor(controller, 2); } } }
protected virtual void OnGameEnd(CharacterInfo winner, CharacterInfo loser) { this.isRunning = false; if (UFE.gameMode == GameMode.VersusMode || UFE.gameMode == GameMode.NetworkGame) { UFE.StartVersusModeAfterBattleScreen(); } else if (UFE.gameMode == GameMode.StoryMode) { if (winner == this.player1.character) { UFE.WonStoryModeBattle(); } else { UFE.StartStoryModeContinueScreen(); } } else { UFE.StartMainMenuScreen(); } }
public virtual void SetAIDifficulty(AIDifficultySettings difficulty) { if (difficulty != null) { UFE.SetAIDifficulty(difficulty.difficultyLevel); } }
public override void DoUpdate() { base.DoUpdate(); bool battleGUI = (UFE.battleGUI != null); bool gamePaused = UFE.isPaused(); if (touchInputUI != null) { if (battleGUI != this.prevBattleGUI) { touchInputUI.showTouchControls = battleGUI && !gamePaused; } else if (gamePaused != this.prevGamePaused) { if (battleGUI) { touchInputUI.showTouchControls = !gamePaused; } } } this.prevBattleGUI = battleGUI; this.prevGamePaused = gamePaused; }
IEnumerator levelTwoFirstFight() { yield return(new WaitForSeconds(3f)); UFE.HideScreen(UFE.currentScreen); UFE.StartGame(0f); }
void CheckOver(VideoPlayer vp) { videoPlayer.loopPointReached -= CheckOver; videoPlayer.Stop(); videoPlayer = null; UFE.DelayLocalAction(this.GoToMainMenu, delayAfterSkippingVideo); }
public virtual void MoveCursorLeft() { if (Network.peerType == NetworkPeerType.Disconnected) { // If it's a local game, update the corresponding character immediately... if (UFE.config.player1Character == null) { this.MoveCursorLeft(1); } else if (UFE.config.player2Character == null && UFE.gameMode != GameMode.StoryMode) { this.MoveCursorLeft(2); } } else { // If it's an online game, find out if the local player is Player1 or Player2... // And only update the selection for the local player... int localPlayer = UFE.GetLocalPlayer(); if (localPlayer == 1 && UFE.config.player1Character == null) { this.MoveCursorLeft(1); } else if (localPlayer == 2 && UFE.config.player2Character == null) { this.MoveCursorLeft(2); } } }
public virtual void TrySelectCharacter(int characterIndex, int player) { // Check if he was playing online or not... if (!UFE.isConnected) { // If it's a local game, update the corresponding character immediately... this.OnCharacterSelectionAllowed(characterIndex, player); } else { // If it's an online game, find out if the requesting player is the local player // because we will only accept requests for the local player... int localPlayer = UFE.GetLocalPlayer(); if (player == localPlayer) { UFEController controller = UFE.GetController(localPlayer); // We don't invoke the OnCharacterSelected() method immediately because we are using the frame-delay // algorithm to keep players synchronized, so we can't invoke the OnCharacterSelected() method // until the other player has received the message with our choice. controller.GetType().GetMethod( "RequestOptionSelection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy, null, new Type[] { typeof(int) }, null ).Invoke(controller, new object[] { characterIndex }); } } }
public void TrySelectCharacter() { // If it's a local game, update the corresponding character immediately... if (!UFE.isConnected) { if (UFE.config.player1Character == null) { this.TrySelectCharacter(this.p1HoverIndex, 1); } else if (UFE.config.player2Character == null) { this.TrySelectCharacter(this.p2HoverIndex, 2); } } else { // If it's an online game, find out if the local player is Player1 or Player2 // and update the selection only for the local player... int localPlayer = UFE.GetLocalPlayer(); if (localPlayer == 1) { this.TrySelectCharacter(this.p1HoverIndex, localPlayer); } else if (localPlayer == 2) { this.TrySelectCharacter(this.p2HoverIndex, localPlayer); } } }
public void videoMethod() { AudioListener.volume = 0; btn = GameObject.FindGameObjectWithTag("CoinsTag"); btn.GetComponent <Button>().interactable = false; if (InternetStatus()) { Vungle.playAd(true, "QuantumLeap"); Vungle.onAdFinishedEvent += (adFinishedEventArgs) => { if (adFinishedEventArgs.IsCompletedView) { AudioListener.volume = 1; UFE.videoCheck = true; IntroScreen.characterValue = 100; UFE.StartGame(0); } else { } }; } else { UFE.tryAgainPopUp(0f); } }
protected virtual void ProcessRandomSeedSynchronizedMessage(RandomSeedSynchronizedMessage msg) { if (this.player == 2 || UFE.config.networkOptions.fakeNetwork) { UFE.SetSynchronizedRandomSeed(msg.Data); } }
public void TrySelectStage(int stageIndex) { // Check if he was playing online or not... if (!UFE.isConnected) { // If it's a local game, update the corresponding stage immediately... this.OnStageSelectionAllowed(stageIndex); } else { // If it's an online game, we only select the stage if it has been requested by Player 1... // But if player 2 wants to come back to character selection screen, we also allow that... int localPlayer = UFE.GetLocalPlayer(); if (localPlayer == 1 || stageIndex < 0) { UFEController controller = UFE.GetController(localPlayer); // We don't invoke the OnstageSelected() method immediately because we are using the frame-delay // algorithm to keep players synchronized, so we can't invoke the OnstageSelected() method // until the other player has received the message with our choice. controller.GetType().GetMethod( "RequestOptionSelection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy, null, new Type[] { typeof(int) }, null ).Invoke(controller, new object[] { stageIndex }); } } }
public override void DoFixedUpdate() { //------------------------------------------------------------------------------------------------------------- // First, store the player positions at the current frame (if they aren't already stored) // because we will use them later for synchronization purpose //------------------------------------------------------------------------------------------------------------- if (this.inputReferences != null && UFE.GetPlayer1Controller().isReady&& UFE.GetPlayer2Controller().isReady) { ControlsScript p1 = UFE.GetPlayer1ControlsScript(); ControlsScript p2 = UFE.GetPlayer2ControlsScript(); if ( p1 != null && p2 != null && //UFE.currentNetworkFrame % 100 == 0 && !this.gameState.ContainsKey(UFE.currentNetworkFrame) ) { //----------------------------------------------------------------------------------------------------- // Send a synchronization message every few frames //----------------------------------------------------------------------------------------------------- GameState state = new GameState(p1.transform.position, p2.transform.position); this.gameState[UFE.currentNetworkFrame] = state; UFE.multiplayerAPI.SendNetworkMessage(new SynchronizationMessage(this.player, UFE.currentNetworkFrame, state)); //Debug.LogWarning("Store State: " + state + "\t(Frame = " + UFE.currentNetworkFrame + ")"); } } //------------------------------------------------------------------------------------------------------------- // Execute the parent's method //------------------------------------------------------------------------------------------------------------- base.DoFixedUpdate(); }
public override void OnShow() { base.OnShow(); this.HighlightOption(this.FindFirstSelectable()); if (this.music != null) { UFE.DelayLocalAction(delegate(){ UFE.PlayMusic(this.music); }, this.delayBeforePlayingMusic); } if (this.stopPreviousSoundEffectsOnLoad) { UFE.StopSounds(); } if (this.onLoadSound != null) { UFE.DelayLocalAction(delegate(){ UFE.PlaySound(this.onLoadSound); }, this.delayBeforePlayingMusic); } if (buttonNetwork != null) { buttonNetwork.interactable = UFE.isNetworkAddonInstalled; } if (buttonBluetooth != null) { buttonBluetooth.interactable = UFE.isNetworkAddonInstalled && Application.isMobilePlatform; } }
void Start() { UFE.SetLanguage("English"); Rect newPixelInset = guiTexture.pixelInset; newPixelInset.width *= ((float)Screen.width / 1280); newPixelInset.height *= ((float)Screen.height / 720); guiTexture.pixelInset = newPixelInset; startButtonRect = new Rect(0, 0, startButtonStyle.normal.background.width, startButtonStyle.normal.background.height); optionsButtonRect = new Rect(0, 0, optionsButtonStyle.normal.background.width, optionsButtonStyle.normal.background.height); creditsButtonRect = new Rect(0, 0, creditsButtonStyle.normal.background.width, creditsButtonStyle.normal.background.height); startButtonRect = SetResolution(startButtonRect, 260); optionsButtonRect = SetResolution(optionsButtonRect, 180); creditsButtonRect = SetResolution(creditsButtonRect, 100); /*startButtonRect.width *= ((float)Screen.width/1280); * startButtonRect.height *= ((float)Screen.height/720); * startButtonRect.x = ((float)Screen.width/2) - (startButtonRect.width/2); * startButtonRect.y = Screen.height - (260 * ((float)Screen.height/720)); * * optionsButtonRect.width *= ((float)Screen.width/1280); * optionsButtonRect.height *= ((float)Screen.height/720); * optionsButtonRect.x = ((float)Screen.width/2) - (optionsButtonRect.width/2); * optionsButtonRect.y = Screen.height - (180 * ((float)Screen.height/720)); * * creditsButtonRect.width *= ((float)Screen.width/1280); * creditsButtonRect.height *= ((float)Screen.height/720); * creditsButtonRect.x = ((float)Screen.width/2) - (creditsButtonRect.width/2); * creditsButtonRect.y = Screen.height - (100 * ((float)Screen.height/720));*/ }
protected virtual string ProcessMessage(string msg, ControlsScript controlsScript) { if (msg == UFE.config.selectedLanguage.combo) { if (this.announcer != null && !this.muteAnnouncer) { foreach (ComboAnnouncer comboAnnouncer in this.announcer.combos) { if (controlsScript.opControlsScript.comboHits >= comboAnnouncer.hits) { UFE.PlaySound(comboAnnouncer.audio); break; } } } } else if (msg == UFE.config.selectedLanguage.parry) { if (this.announcer != null && !this.muteAnnouncer) { UFE.PlaySound(this.announcer.parry); } UFE.PlaySound(UFE.config.blockOptions.parrySound); } else if (msg == UFE.config.selectedLanguage.counterHit) { if (this.announcer != null && !this.muteAnnouncer) { UFE.PlaySound(this.announcer.counterHit); } UFE.PlaySound(UFE.config.counterHitOptions.sound); } else if (msg == UFE.config.selectedLanguage.firstHit) { if (this.announcer != null && !this.muteAnnouncer) { UFE.PlaySound(this.announcer.firstHit); } } else if (msg == UFE.config.selectedLanguage.fight) { if (this.announcer != null && !this.muteAnnouncer) { UFE.PlaySound(this.announcer.fight); } } else if (msg == UFE.config.selectedLanguage.ko) { if (this.announcer != null && !this.muteAnnouncer && this.announcer.ko != null) { UFE.PlaySound(this.announcer.ko); } } else { return(this.SetStringValues(msg, null)); } return(this.SetStringValues(msg, controlsScript)); }
void Update() { if (Input.GetAxisRaw(horizontalAxis) == 0) { axisHeld = false; } // Select Stage if (!axisHeld && UFE.config.selectedStage == null) { hoverIndex = StageSelect(hoverIndex); if (Input.GetButtonDown(UFE.GetInputReference(selectButton, UFE.config.player1_Inputs)) || Input.GetKeyDown(KeyCode.Space) || Input.GetKeyDown(KeyCode.Return)) { UFE.config.selectedStage = UFE.config.stages[hoverIndex]; if (UFE.config.soundfx) { Camera.main.audio.PlayOneShot(selectSound); } Invoke("StartGame", 1.2f); startingGame = true; } } if (Input.GetAxisRaw(horizontalAxis) != 0) { axisHeld = true; } }
public static void MoveCursor(this UFEScreen screen, Vector3 direction, AudioClip moveCursorSound = null) { GameObject currentGameObject = UFE.eventSystem.currentSelectedGameObject; GameObject nextGameObject = null; if (currentGameObject != null && currentGameObject.activeInHierarchy) { Selectable currentSelectableObject = currentGameObject.GetComponent <Selectable>(); if (currentSelectableObject != null && currentSelectableObject.IsInteractable()) { Selectable nextSelectableObject = currentSelectableObject.FindSelectable(direction); if (nextSelectableObject != null) { nextGameObject = nextSelectableObject.gameObject; } } } if (nextGameObject == null) { nextGameObject = screen.FindFirstSelectableGameObject(); } if (currentGameObject != nextGameObject) { if (moveCursorSound != null) { UFE.PlaySound(moveCursorSound); } screen.HighlightOption(nextGameObject); } }
protected override void SelectInputType() { // [DGT] // First, look for Control Freak 2 rig with UFE Bridge component... InputTouchControllerBridge bridge = GameObject.FindObjectOfType <InputTouchControllerBridge>(); if (bridge != null) { this.InitializeTouchControllerBridge(bridge); return; } // Then, look for Control Freak 1.x controller... else { Type type = UFE.SearchClass("TouchController"); UnityEngine.Object touchController = null; if ((type != null) && ((touchController = GameObject.FindObjectOfType(type)) != null)) { this.InitializeControlFreakTouchController(touchController); return; } } // If nothing found, use standard Input... base.SelectInputType(); }
void OnGUI() { if (GUI.Button(backButtonRect, "", backButtonStyle)) { UFE.StartIntro(2); } }
public virtual void NextStage() { if (this.moveCursorSound != null) { UFE.PlaySound(this.moveCursorSound); } this.SetHoverIndex((this.stageHoverIndex + 1) % UFE.config.stages.Length); }
public virtual void SelectPlayerVersusCpu() { Debug.Log("Player vs CPU"); NameHolder temp = GameObject.Find("Name").GetComponent <NameHolder>(); temp.setGameMode("playerVsFuzzy"); UFE.StartPlayerVersusCpu(); }
protected virtual void MoveCursor(int characterIndex) { if (this.moveCursorSound != null) { UFE.PlaySound(this.moveCursorSound); } this.stageHoverIndex = characterIndex; }
public virtual void SelectSelfAIvsSelf() { Debug.Log("Decision vs Decision"); NameHolder temp = GameObject.Find("Name").GetComponent <NameHolder>(); temp.setGameMode("decisionVsDecision"); UFE.StartCpuVersusCpu(); }
public void ingnore() { // UFE.StartGame (0); CharacterInfo[] selectableCharacters = UFE.GetVersusModeSelectableCharacters(); CharacterInfo character1 = selectableCharacters [6]; UFE.SetPlayer(1, character1); UFE.StartGame(0); }