protected virtual void Start()
{
player = GetComponent<Player>();
input = player.InputPlayer;//GetComponent<InputController>();
controller = GetComponent<Controller2D>();
movementSpecial = GetComponent<OnMovementSpecial>();
}
void Start()
{
//playButton.onClick.AddListener(() => OnPlayButtonClicked(gameObject));
//loadSaveSlotButtons[i].button.onClick.AddListener(() => OnSlotSelection(index));
//sound.Invoke();
//anim.SetInteger("Transition", 0);
buttons = gameObject.GetComponentsInChildren<Button>().ToList();
buttons.ForEach((btn) => btn.onClick.AddListener(() => PlayMenuClickSound(clickSound)));
//buttons.ForEach((btn) => btn.onClick.AddListener (() => OnButtonEnter(null, buttons[index++].gameObject)));
for (int i = 0; i < buttons.Count; i++)
{
int index = i;
buttons[index].onClick.AddListener(() => OnButtonEnter(null, index, buttons[index].gameObject));
}
player = Rewired.ReInput.players.GetPlayer(0);
AddMenuButtonHandlers();
}
public ComboAction(Rewired.Player inputManager, List <string> expectedCombos, int comboGoal, System.Action actionToDo, string name = DEFAULT_NAME) : base(actionToDo, name)
{
this.actualCombo = 0;
this.comboGoal = comboGoal;
this.expectedCombos = expectedCombos;
this.inputManager = inputManager;
comboBuffer = new Queue <string>();
expectedCombos.ForEach(comboBuffer.Enqueue);
}
public static bool MenuAccept(Rewired.Player p)
{
// can add other buttons to this condition, so leaving it like this
if (p.GetButton("Fire"))
{
return(true);
}
return(false);
}
public GunScriptBase(PlayerController player)
{
rewiredPlayer = Rewired.ReInput.players.GetPlayer(player.playerID - 1);
this.player = player;
myInfo = GameObject.Find("Player" + player.playerID.ToString()).GetComponent <InfoTracker>(); // get info
modApp = player.modApp;
fpsCam = player.GetComponentInParent <Camera>(); // which cam are we
mag = magSize; // mag size
bloodBurst = player.blood;
}
private void Start()
{
currentSelectedGameObject = eventSystem.firstSelectedGameObject;
player1 = Rewired.ReInput.players.GetPlayer(0);
player2 = Rewired.ReInput.players.GetPlayer(1);
player1.controllers.maps.SetAllMapsEnabled(false);
player1.controllers.maps.SetMapsEnabled(true, Rewired.ControllerType.Joystick, RewiredConsts.Category.Default, RewiredConsts.Layout.Joystick.Menu);
player2.controllers.maps.SetAllMapsEnabled(false);
player2.controllers.maps.SetMapsEnabled(true, Rewired.ControllerType.Joystick, RewiredConsts.Category.Default, RewiredConsts.Layout.Joystick.Menu);
}
private void Start()
{
playerController1 = player1.GetComponent <PlayerController>().getGamePadController();
playerController2 = player2.GetComponent <PlayerController>().getGamePadController();
// don't allow player to jump
originalJumpForce = player1.GetComponent <PlayerController>().jumpForce;
player1.GetComponent <PlayerController>().jumpForce = 0f;
player2.GetComponent <PlayerController>().jumpForce = 0f;
}
private void Update()
{
for (int i = 0; i < RInputs.Count; ++i)
{
Rewired.Player RInput = RInputs[i];
_slider.value += RInput.GetAxis("MoveH") * Time.deltaTime;
}
_slider.value = Mathf.Clamp(_slider.value, _slider.minValue, _slider.maxValue);
SetGamma(_slider.value);
}
void Start()
{
foreach (Button button in buttons)
{
button.gameObject.AddComponent <EventButton>();
button.onClick.AddListener(PlayClick);
}
quit.gameObject.AddComponent <EventButton>();
quit.onClick.AddListener(QuitClick);
pInput = Rewired.ReInput.players.GetPlayer(0);
}
void Start()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
pInput = Rewired.ReInput.players.GetPlayer(0);
}
void Start()
{
gamePadController1 = Rewired.ReInput.players.GetPlayer(0);
gamePadController2 = Rewired.ReInput.players.GetPlayer(1);
EventSystem.current.SetSelectedGameObject(null);
EventSystem.current.SetSelectedGameObject(rightArrowButton);
setupSlides();
// set value of game duration
//setTimeDurationText();
}
// Use this for initialization
void Start()
{
if (!player.isBot)
{
rePlayer = Rewired.ReInput.players.GetPlayer(player.Id);
}
oPart = this.transform.Find("O_parts").gameObject.GetComponent <ParticleSystem>();
xPart = this.transform.Find("X_parts").gameObject.GetComponent <ParticleSystem>();
yPart = this.transform.Find("Y_parts").gameObject.GetComponent <ParticleSystem>();
aPart = this.transform.Find("A_parts").gameObject.GetComponent <ParticleSystem>();
bPart = this.transform.Find("B_parts").gameObject.GetComponent <ParticleSystem>();
}
private void Update()
{
if (!Rewired.ReInput.isReady)
{
return;
}
Rewired.Player player = Rewired.ReInput.players.GetPlayer(0);
if (IsDragging)
{
// If current dragged thing was destroyed, cancel drag
if (_currentDraggable == null)
{
StopDrag();
return;
}
float distanceScale = Vector3.Distance(Camera.main.transform.position, _currentDraggable.position);
float horizontalAxis = player.GetAxis("CursorX") * Time.deltaTime * _handDragSensitivity;
float verticalAxis = player.GetAxis("CursorY") * Time.deltaTime * _handDragSensitivity;
Vector3 cameraMovement = Camera.main.transform.position - _dragStartCameraPos;
_targetHandPos += Camera.main.transform.right.WithY(0).normalized *horizontalAxis *distanceScale;
_targetHandPos += Camera.main.transform.forward.WithY(0).normalized *verticalAxis *distanceScale;
_targetHandPos += cameraMovement;
_targetHandPos.y = _handDragHeight;
_dragStartCameraPos = Camera.main.transform.position;
_isRotating = player.GetButton("Context");
}
else
{
Ray mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
bool hit = Physics.Raycast(mouseRay, out hitInfo, 100.0f, _raycastMask);
if (hit)
{
_targetHandPos = hitInfo.point + hitInfo.normal * _handHoverDistance;
if (player.GetButtonDown("Select"))
{
StartDrag(hitInfo);
}
}
}
if (player.GetButtonUp("Select"))
{
StopDrag();
}
_handObject.transform.position = Mathfx.Damp(_handObject.transform.position, _targetHandPos, 0.5f, Time.deltaTime * _handAnimateSpeed);
}
protected override void Start()
{
base.Start();
input = transform.parent.GetComponentInParent<Player>().InputPlayer;
//ren = GetComponent<MeshRenderer>();
col = GetComponent<BoxCollider2D>();
//ren.enabled = alwaysVisible;
col.enabled = false;
visuals.enabled = alwaysVisible;
}
void Start()
{
player = Rewired.ReInput.players.GetPlayer(playerId);
playerMoveController = GetComponent<IPlayerMovable>();
playerJump = GetComponent<IPlayerJump>();
playerRightTriggerAction = GetComponent<PlayerRightTriggerAction>();
//playerSwinging = GetComponent<SwingingWeapon>();
//playerWallJump = GetComponent<WallJump>();
//playerCamera = FindObjectOfType<Camera>().GetComponent<PlayerCamera>();
}
public void Init(int p_playerId)
{
if (m_mouseParent)
{
m_cursor = Instantiate(m_mousePrefab, m_mouseParent.transform);
}
else
{
m_cursor = Instantiate(m_mousePrefab);
}
m_uiCursor = Instantiate(m_uiCursorPrefab, m_uiCanvas.transform).GetComponent <UICursor>();
m_mouse = m_cursor.GetComponent <PlayerMouse>();
m_mouse.useHardwarePointerPosition = false;
m_mouse.playerId = p_playerId;
m_rewiredPlayer = Rewired.ReInput.players.GetPlayer(p_playerId);
if (Player.m_players.Count > 0)
{
m_player = Player.GetPlayerFromId(p_playerId);
}
m_mouse.leftButton.actionName = "UIInteract1";
m_mouse.rightButton.actionName = "UIInteract3";
//m_mouse.middleButton.actionName = "UIInteract3";
m_mouse.wheel.yAxis.actionName = "UIWheelY";
float sens = (float)Game.m_options.LoadOptionInt("Sensitivity" + "_" + p_playerId, 100).GetInt() / 50f;
float size = (float)Game.m_options.LoadOptionInt("CursorSize" + "_" + p_playerId, 100).GetInt() / 200f;
m_mouse.pointerSpeed = sens;
m_uiCursor.transform.localScale = new Vector3(size, size, size);
List <PlayerMouse> mice = Game.m_rewiredEventSystem.PlayerMice;
mice.Add(m_mouse);
Game.m_rewiredEventSystem.PlayerMice = mice;
ChangeMode(m_useUICoordinatesOnly ? CursorModes.CURSOR : CursorModes.LINE, true);
m_mouse.ScreenPositionChangedEvent += OnScreenPositionChanged;
m_mouse.screenPosition = new Vector2(Screen.width / 2, Screen.height / 2 + 1);
string cursorSprite = Game.m_options.Get("CursorSprite", p_playerId).GetString();
Sprite sprite = SpriteUtils.LoadSpriteFromFile(Application.dataPath + "/Data/Cursors/" + cursorSprite + ".png");
if (sprite != null)
{
SetCursorImage(sprite);
}
}
// Start is called before the first frame update
public PlayerMoveBase(PlayerController player)
{
rewiredPlayer = Rewired.ReInput.players.GetPlayer(player.playerID - 1);
this.player = player;
playerBody = player.playerBody;
/* // depricated
* axis1 = "Joy" + player.playerID + "Axis1";
* axis2 = "Joy" + player.playerID + "Axis2";
* axis5bump = "Joy" + player.playerID + "Axis5Bump";
* axis4bump = "Joy" + player.playerID + "Axis4Bump";
*/
}
void Awake()
{
controller = GetComponent <CustomCharacterController>();
if (aimSpace == null)
{
aimSpace = transform;
}
player = Rewired.ReInput.players.GetPlayer(0);
manager = FindObjectOfType <SlowMoManager>();
engines = GetComponentInChildren <Engine>();
engines.OnEngineWake.AddListener(OnStopDrift);
engines.OnEngineStop.AddListener(OnStartDrift);
}
// Use this for initialization
void Start()
{
if (Player == null)
{
Player = gameObject;
}
_playerStatus = GetComponent <Lightable>();
_battery = GetComponent <FlashlightBattery>();
_ool = GetComponent <OnOffLight>();
//le joueur démarre la lampe allumé
_playerStatus.LightSources = 1;
_ool.OnToggle += (on) =>
{
if (on == true)
{
_playerStatus.LightSources += 1;
}
else
{
_playerStatus.LightSources -= 1;
}
};
_fov = GetComponent <FieldOfView>();
_baseAngle = _fov.ViewAngle;
if (_baseAngle + AngleIncrease > 360)
{
AngleIncrease = 360 - _baseAngle;
}
_baseLightAngle = _ool.Lights[0].spotAngle;
// To determine joypad or keyboard
inputManager = GameObject.Find("GameManager").GetComponent <InputManager>();
if (Player.name == "Player2")
{
RInput = Rewired.ReInput.players.GetPlayer(inputManager.Player2Index);
}
else
{
RInput = Rewired.ReInput.players.GetPlayer(inputManager.Player1Index);
}
_ool.ToggleOff();
}
public void Init()
{
if (useSystemPlayer)
{
player = Rewired.ReInput.players.GetSystemPlayer();
}
else
{
player = Rewired.ReInput.players.GetPlayer(rewiredPlayerID);
}
Assert.IsNotNull(player, "Rewired player with ID " + rewiredPlayerID + " could not be found!");
Assert.IsTrue(Rewired.ReInput.mapping.Actions.Any(o => o.name == rewiredActionName), "No rewired action found with name: " + rewiredActionName);
}
public override bool ShouldActivateModule()
{
if (!base.ShouldActivateModule())
{
return(false);
}
if (recompiling)
{
return(false);
}
if (!ReInput.isReady)
{
return(false);
}
bool shouldActivate = false;
// Combine input for all players
for (int i = 0; i < playerIds.Length; i++)
{
Rewired.Player player = ReInput.players.GetPlayer(playerIds[i]);
if (player == null)
{
continue;
}
shouldActivate |= player.GetButtonDown(m_SubmitButton);
shouldActivate |= player.GetButtonDown(m_CancelButton);
if (moveOneElementPerAxisPress) // axis press moves only to the next UI element with each press
{
shouldActivate |= player.GetButtonDown(m_HorizontalAxis) || player.GetNegativeButtonDown(m_HorizontalAxis);
shouldActivate |= player.GetButtonDown(m_VerticalAxis) || player.GetNegativeButtonDown(m_VerticalAxis);
}
else // default behavior - axis press scrolls quickly through UI elements
{
shouldActivate |= !Mathf.Approximately(player.GetAxisRaw(m_HorizontalAxis), 0.0f);
shouldActivate |= !Mathf.Approximately(player.GetAxisRaw(m_VerticalAxis), 0.0f);
}
}
if (isMouseSupported)
{
shouldActivate |= (m_MousePosition - m_LastMousePosition).sqrMagnitude > 0.0f;
shouldActivate |= ReInput.controllers.Mouse.GetButtonDown(0);
}
return(shouldActivate);
}
public void AssignPlayer(Rewired.Player player)
{
this.player = player;
if (player.controllers.joystickCount > 0)
{
buttonHint.gameObject.SetActive(true);
}
else if (player.controllers.hasKeyboard)
{
Join();
keyboard.gameObject.SetActive(false);
keyboardHinter.gameObject.SetActive(true);
keyboardHinter.Setup(player);
}
}
protected override void OnUpdate()
{
Rewired.Player[] rewiredPlayers = GameManager.Instance.RewiredPlayers;
for (int i = 0; i < inputFilter.Length; i++)
{
PlayerInput input = inputFilter.Inputs[i];
Player player = inputFilter.Players[i];
Rewired.Player rewiredPlayer = rewiredPlayers[player.Id];
float hMove = rewiredPlayer.GetAxis("Move Horizontally");
float vMove = rewiredPlayer.GetAxis("Move Vertically");
input.Movement = new float2(hMove, vMove);
}
}
protected void OnInit(Transform root)
{
input = Rewired.ReInput.players.GetPlayer(InputPlayer.System);
//input.isPlaying = true;
clientWorld = root.GetComponent <__ClientWorld>();
Debug.Assert(clientWorld != null, $"clientWorld != null root={root}", root);
//
World.GetExistingSystem <NetworkStreamStateSystem>().connectHandle += connect;
World.GetExistingSystem <NetworkStreamStateSystem>().connectedHandle += connected;
World.GetExistingSystem <NetworkStreamStateSystem>().disconnectedHandle += disconnected;
playerInputClientSystem = World.GetExistingSystem <PlayerInputClientSystem>();
cameraControllerSystem = World.GetExistingSystem <CameraControllerSystem>();
}
void OnEnable()
{
if (Time.timeScale == 0f)
{
m_paused = true;
}
else
{
m_paused = false;
}
m_openedMenus = new List <Menu>();
m_handlingPlayer = null;
m_lastSelectedGameObject = null;
SceneManager.sceneLoaded += OnSceneLoad;
}
private void initRewired(int rewiredPlayerID)
{
_rewired = Rewired.ReInput.players.GetPlayer(rewiredPlayerID);
// register input event listeners
_rewired.AddInputEventDelegate(
onLeftTriggerUpdate,
Rewired.UpdateLoopType.Update,
Rewired.InputActionEventType.Update,
Constants.RewiredInputActions.LeftTrigger);
_rewired.AddInputEventDelegate(
onRightTriggerUpdate,
Rewired.UpdateLoopType.Update,
Rewired.InputActionEventType.Update,
Constants.RewiredInputActions.RightTrigger);
_rewired.AddInputEventDelegate(
onRightTriggerUpdate,
Rewired.UpdateLoopType.Update,
Rewired.InputActionEventType.Update,
Constants.RewiredInputActions.RightTrigger);
_rewired.AddInputEventDelegate(
onDeflatePressed,
Rewired.UpdateLoopType.Update,
Rewired.InputActionEventType.ButtonJustPressed,
Constants.RewiredInputActions.Deflate);
_rewired.AddInputEventDelegate(
onDeflateReleased,
Rewired.UpdateLoopType.Update,
Rewired.InputActionEventType.ButtonJustReleased,
Constants.RewiredInputActions.Deflate);
_rewired.AddInputEventDelegate(
onInflatePressed,
Rewired.UpdateLoopType.Update,
Rewired.InputActionEventType.ButtonJustPressed,
Constants.RewiredInputActions.Inflate);
_rewired.AddInputEventDelegate(
onInflateReleased,
Rewired.UpdateLoopType.Update,
Rewired.InputActionEventType.ButtonJustReleased,
Constants.RewiredInputActions.Inflate);
}
private void Update()
{
if (!Rewired.ReInput.isReady || GameStateManager.Instance.CurrentStage != GameStateManager.GameStage.Game)
{
return;
}
// Iterate over existing rewired players and spawn their character if they press a button
for (int i = 0; i < Rewired.ReInput.players.playerCount; ++i)
{
Rewired.Player player = Rewired.ReInput.players.GetPlayer(i);
if (!IsPlayerJoined(i) && player.GetAnyButton())
{
AddPlayer(player);
}
}
}
void StartBuild()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
if (!car)
{
car = FindObjectOfType <CND.Car.ArcadeCarController>();
}
enabled = car;
if (!particlesCamera)
{
particlesCamera = Camera.main.transform.GetChild(0).GetComponent <Camera>();
}
Canvas canvas = GetComponent <Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceCamera;
canvas.worldCamera = Camera.main;
chrono.SetActive(afficheChrono && !GameManager.instance.practise);
colorBoost = boost[0].color;
pInput = Rewired.ReInput.players.GetPlayer(0);
pauseButtons[0].onClick.AddListener(Resume);
pauseButtons[1].onClick.AddListener(ReStart);
pauseButtons[2].onClick.AddListener(Quit);
endButtons[0].onClick.AddListener(ReStart);
endButtons[1].onClick.AddListener(SaveGhost);
endButtons[2].onClick.AddListener(Quit);
Pause = false;
fin.SetActive(false);
}
public static Vector3?DirectionFromAxes(Rewired.Player p, int a1, int a2)
{
//this code is for radial deadzone
float deadzone = 0.25f;
Vector3 stickInput = Vector3.Normalize(VectorFromAxes(p, a1, a2));
if (stickInput.magnitude < deadzone)
{
stickInput = Vector3.zero;
}
else
{
stickInput = stickInput.normalized * ((stickInput.magnitude - deadzone) / (1 - deadzone));
}
//var v = Vector3.Normalize(VectorFromAxes(p, a1, a2));
return(stickInput == Vector3.zero ? Vector3.zero : stickInput);
}
private bool CheckButtonOrKeyMovement(float time)
{
bool allow = false;
for (int i = 0; i < playerIds.Length; i++)
{
Rewired.Player player = ReInput.players.GetPlayer(playerIds[i]);
if (player == null)
{
continue;
}
allow |= player.GetButtonDown(m_HorizontalAxis) || player.GetNegativeButtonDown(m_HorizontalAxis);
allow |= player.GetButtonDown(m_VerticalAxis) || player.GetNegativeButtonDown(m_VerticalAxis);
}
return(allow);
}
private void Awake()
{
player1 = Rewired.ReInput.players.GetPlayer(0);
player2 = Rewired.ReInput.players.GetPlayer(1);
if (analogGlitch == null && mainCamera != null)
{
analogGlitch = mainCamera.GetComponent <AnalogGlitch>();
}
if (Instance != null && Instance != this)
{
Destroy(this);
throw new Exception("An instance of this singleton already exists.");
}
else
{
Instance = this;
}
}
private void ManageBackToMenu()
{
if (Time.time < InputAcceptation)
{
return;
}
for (int i = 0; i < RInputs.Count; ++i)
{
Rewired.Player RInput = RInputs[i];
if (RInput.GetButtonDown("Interact"))
{
Debug.Log("RInput " + RInput.name + " pressed a button");
MainOptions.SetPanel(main: true);
ButtonToBack = false;
StartCoroutine(ReturnToMenu());
}
}
}
private void Start()
{
// Get reference on start to make sure that it exist in PlayerController
_inputs = GetComponent <PlayerController>().PlayerInputs; // Get the MainPlayer's inputs
// Setup default Inventory
InventoryItem[] tempInv = inventory;
inventory = new InventoryItem[INVENTORY_SIZE];
// Placing item in new inventory
for (int i = 0; i < inventory.Length && i < tempInv.Length; i++)
{
inventory[i] = tempInv[i];
}
// Start with first item
_currentActivePosition = 0;
// _holder.ChangeSelectedItem(_currentActivePosition);
}
void Start()
{
AkSoundEngine.PostEvent("Music_Menu_Play", gameObject);
currentMenu = titleScreen;
animator = cameraVHS.GetComponent <Animator>();
pInput = Rewired.ReInput.players.GetPlayer(0);
rendererMovie.gameObject.SetActive(playMovie);
if (playMovie)
{
StartCoroutine(PlayMovie());
}
else
{
startPressed = false;
SetSelection();
}
}
private void Start()
{
player = Rewired.ReInput.players.GetPlayer(PlayerIndex - 1);
//set the playernumber for all of the children
foreach (Carousel c in GetComponentsInChildren<Carousel>())
{
c.playerNumber = PlayerIndex;
c.p = player;
}
foreach (NameCarousel c in GetComponentsInChildren<NameCarousel>())
{
c.playerNumber = PlayerIndex;
c.p = player;
}
foreach (Stage s in stages)
{
s.activeObject.SetActive(false);
}
ourGroup = GetComponentInParent<CanvasGroup>();
stages[currentStage].activeObject.SetActive(true);
stages[currentStage].onEnter.Invoke();
}
void Start()
{
//zDistanceCurrent = zDistance;
//player = GameObject.FindGameObjectWithTag("Hero").GetComponent<IPlayerMovable>();
MonoBehaviour[] list = FindObjectsOfType<MonoBehaviour>();
foreach (MonoBehaviour mb in list)
{
if (mb is IPlayerMovable) player = mb as IPlayerMovable;
}
//player = FindObjectOfType(typeof(IPlayerMovable)) as IPlayerMovable;
two5d = player.GetMovementStats().twoFiveD;
target = player.GetGameObject();
inputController = FindObjectOfType<InputController>();
cam = GetComponent<Camera>();
currentXdistance = xDistance;
currentYdistance = yDistance;
currentZdistance = zDistance;
playerInput = Rewired.ReInput.players.GetPlayer(0);
}
