API tools faq
paste
SebastianLawe

Untitled

SebastianLawe
Sep 17th, 2015
141
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 16.35 KB | None | 0 0
raw download clone embed print report
  1. using UnityEngine;
  2. using System.Collections;
  3. using System.Diagnostics;
  4. using Assets.Scripts;
  5. using System.Collections.Generic;
  6. using Photon;
  7. using XInputDotNetPure;
  8. using UnityEngine.UI;
  9.  
  10. public class ObjectInteractor : PunBehaviour {
  11.     public AudioSource lazer;
  12.     public GameObject focalObject;
  13.     public FactionManager player;
  14.     public Light _flashLight;
  15.     public LineRenderer[] linerRenderer;
  16.     private SecurityCamera securityCamera;
  17.     private Television television;
  18.     public int timeSensitivity;
  19.     private bool holdingObject;
  20.     private bool flashLightOn;
  21.     private Vector3 _lastRaycastHit;
  22.     Stopwatch timeSinceLastSwitch;
  23.     Stopwatch keyHeld;
  24.     PlacableObject placeableObject;
  25.     public Slider powerMeter;
  26.     public float power = 1;
  27.     public List<InventoryHandler> _inventory;
  28.     public bool lockInventory;
  29.     public InventoryItem currentItem;
  30.     private PlayerController controller;
  31.     public int lazerPoints;
  32.     private bool triggered;
  33.     Stopwatch wallSpawnTimer;
  34.     Stopwatch grenadeTimer;
  35.     Stopwatch falseInputTimer;
  36.     public bool resetLazerPower;
  37.     bool ignoredFalseCommand;
  38.     private bool triggered2;
  39.     private bool triggered3;
  40.     private Stopwatch teleporterTimer;
  41.     public Text[] text;
  42.  
  43.     // Use this for initialization
  44.     void Start() {
  45.         timeSinceLastSwitch = Stopwatch.StartNew();
  46.         keyHeld = new Stopwatch();
  47.         wallSpawnTimer = new Stopwatch();
  48.         controller = player.GetComponent<PlayerController>();
  49.         grenadeTimer = new Stopwatch();
  50.         teleporterTimer = new Stopwatch();
  51.         falseInputTimer = Stopwatch.StartNew();
  52.     }
  53.  
  54.     [PunRPC]
  55.     void RpcStunEffect(float x, float y, float z) {
  56.         if (!lazer.isPlaying) {
  57.             lazer.Play();
  58.         }
  59.         for (int i = 0; i < linerRenderer.Length; i++) {
  60.             linerRenderer[i].SetVertexCount(lazerPoints);
  61.             linerRenderer[i].SetPosition(0, linerRenderer[i].transform.position);
  62.             linerRenderer[i].useWorldSpace = false;
  63.             for (int j = 1; j < lazerPoints - 1; j++) {
  64.                 linerRenderer[i].SetPosition(j, (Vector3.Lerp(linerRenderer[i].transform.position,
  65.                     focalObject.transform.position, (float)(1f / ((float)lazerPoints - (float)2)) * j)
  66.                     + new Vector3(Random.Range(0, 0.1f), Random.Range(0, 0.1f), Random.Range(0, 0.1f))));
  67.             }
  68.             linerRenderer[i].useWorldSpace = true;
  69.             linerRenderer[i].SetPosition(lazerPoints - 1, focalObject.transform.position);
  70.             linerRenderer[i].SetColors(player.color, player.color);
  71.         }
  72.     }
  73.     [PunRPC]
  74.     void RpcResetStunEffect() {
  75.         lazer.Stop();
  76.         for (int i = 0; i < linerRenderer.Length; i++) {
  77.             for (int z = 0; z < lazerPoints; z++) {
  78.                 linerRenderer[i].SetVertexCount(0);
  79.             }
  80.         }
  81.     }
  82.     // Update is called once per frame
  83.     void FixedUpdate() {
  84.         if (grenadeTimer == null) {
  85.             grenadeTimer = new Stopwatch();
  86.         }
  87.         if (teleporterTimer == null) {
  88.             teleporterTimer = new Stopwatch();
  89.         }
  90.         if (wallSpawnTimer == null) {
  91.             teleporterTimer = new Stopwatch();
  92.         }
  93.         text[0].text = grenadeTimer.ElapsedMilliseconds >= 20000 || !grenadeTimer.IsRunning ? "EMP Ready" : (20000 - grenadeTimer.ElapsedMilliseconds + "ms for EMP");
  94.         text[1].text = teleporterTimer.ElapsedMilliseconds >= 20000 || !teleporterTimer.IsRunning ? "Relocator Ready" : (20000 - teleporterTimer.ElapsedMilliseconds + "ms for Relocator");
  95.         text[2].text = wallSpawnTimer.ElapsedMilliseconds >= 10000 || !wallSpawnTimer.IsRunning ? "Wall Ready" : (10000 - wallSpawnTimer.ElapsedMilliseconds + "ms for Wall");
  96.         bool isMouseAndKeyboard = controller.controllerPriority[controller.localPlayerNumber] == "mk";
  97.         if (controller.stunned) {
  98.             power = 0;
  99.         }
  100.         if (photonView.isMine) {
  101.             if (timeSinceLastSwitch.ElapsedMilliseconds >= timeSensitivity) {
  102.                 Ray ray = new Ray(transform.position, transform.forward);
  103.                 RaycastHit hit = new RaycastHit();
  104.                 Physics.Raycast(ray, out hit, 100f);
  105.                 if (hit.transform != null) {
  106.                     _lastRaycastHit = hit.point;
  107.                 }
  108.             }
  109.         } else {
  110.             GetComponent<AudioListener>().enabled = false;
  111.         }
  112.         if (photonView.isMine) {
  113.             if (isMouseAndKeyboard ?
  114.                 Input.GetButtonUp("Fire3") : (controller.prevState.Triggers.Left > 0.00)) {
  115.                 if (grenadeTimer.ElapsedMilliseconds >= 20000) {
  116.                     grenadeTimer.Reset();
  117.                 }
  118.                 if (!grenadeTimer.IsRunning) {
  119.                     photonView.RPC("RpcStunEffect", PhotonTargets.AllBuffered,
  120.                         focalObject.transform.position.x,
  121.                         focalObject.transform.position.y,
  122.                         focalObject.transform.position.z);
  123.                     PhotonNetwork.Instantiate("Grenade", focalObject.transform.position,
  124.                         Quaternion.identity, 0).GetComponent<FactionManager>().color = player.color;
  125.                     grenadeTimer.Start();
  126.                     triggered2 = true;
  127.                 }
  128.             } else {
  129.                 if (triggered2) {
  130.                     triggered2 = false;
  131.                     photonView.RPC("RpcResetStunEffect", PhotonTargets.AllBuffered);
  132.                 }
  133.             }
  134.             if (!resetLazerPower) {
  135.                 if ((isMouseAndKeyboard ?
  136.                     Input.GetButton("Fire1")
  137.                     : (controller.prevState.Triggers.Right > 0.00)) && power > 0f) {
  138.                     triggered = true;
  139.                     photonView.RPC("RpcStunEffect", PhotonTargets.AllBuffered,
  140.                         focalObject.transform.position.x,
  141.                         focalObject.transform.position.y,
  142.                         focalObject.transform.position.z);
  143.                     power -= 0.02f;
  144.                     Ray ray = new Ray(transform.position, transform.forward);
  145.                     RaycastHit hit = new RaycastHit();
  146.                     Physics.Raycast(ray, out hit, 100f);
  147.                     if (hit.transform != null) {
  148.                         if (hit.rigidbody != null) {
  149.                             PlayerController playerController = hit.rigidbody.GetComponent<PlayerController>();
  150.                             if (playerController != null) {
  151.                                 if (!playerController.stunned) {
  152.                                     if (playerController != controller) {
  153.                                         // Send the stun command to the server
  154.                                         playerController.Stun();
  155.                                     }
  156.                                 }
  157.                             }
  158.                         }
  159.                     }
  160.                     if (!isMouseAndKeyboard) {
  161.                         GamePad.SetVibration(controller.playerIndex, 0f, 0.3f);
  162.                     }
  163.                 } else {
  164.                     if (power <= 0.0f) {
  165.                         triggered = true;
  166.                         resetLazerPower = true;
  167.                     }
  168.                     if (triggered) {
  169.                         photonView.RPC("RpcResetStunEffect", PhotonTargets.AllBuffered);
  170.                         triggered = false;
  171.                         GamePad.SetVibration(controller.playerIndex, 0f, 0f);
  172.                     }
  173.                 }
  174.             } else {
  175.                 if (!controller.stunned) {
  176.                     if (power < 1f) {
  177.                         power += 0.01f;
  178.                         if (!isMouseAndKeyboard) {
  179.                             GamePad.SetVibration(controller.playerIndex, 1f, 1f);
  180.                         }
  181.                     } else {
  182.                         resetLazerPower = false;
  183.                         if (!isMouseAndKeyboard) {
  184.                             GamePad.SetVibration(controller.playerIndex, 0f, 0f);
  185.                         }
  186.                     }
  187.                 }
  188.             }
  189.             powerMeter.value = power;
  190.             lazer.volume = power;
  191.             lazer.pitch = 1 + (1 - power);
  192.             if ((isMouseAndKeyboard ?
  193.                 Input.GetButtonDown("Fire2") :
  194.                 (controller.prevState.Buttons.A == ButtonState.Pressed
  195.                 && controller.state.Buttons.A == ButtonState.Released))) {
  196.                 if (ignoredFalseCommand) {
  197.                     if (wallSpawnTimer.ElapsedMilliseconds >= 10000) {
  198.                         wallSpawnTimer.Stop();
  199.                         wallSpawnTimer.Reset();
  200.                     }
  201.                     if (!wallSpawnTimer.IsRunning) {
  202.                         wallSpawnTimer.Start();
  203.                         GameObject wall = PhotonNetwork.Instantiate("TempWall", focalObject.transform.position,
  204.                             Quaternion.Euler(0, transform.eulerAngles.y + 90, 0), 0);
  205.                         wall.GetComponent<FactionManager>().photonView.RPC("SetColor", PhotonTargets.AllBufferedViaServer,
  206.                             player.color.r, player.color.g, player.color.b);
  207.                     }
  208.                 } else {
  209.                 }
  210.             }
  211.             if ((isMouseAndKeyboard ? Input.GetButtonDown("Fire4") : (controller.prevState.Buttons.RightShoulder == ButtonState.Pressed
  212.                 && controller.state.Buttons.RightShoulder == ButtonState.Released))) {
  213.                 int id = currentItem.GetComponent<TeleporterItem>().id;
  214.                 if (teleporterTimer.ElapsedMilliseconds >= 20000) {
  215.                     teleporterTimer.Reset();
  216.                 }
  217.                 if (!teleporterTimer.IsRunning) {
  218.                     if (ignoredFalseCommand) {
  219.                         if (id == 0) {
  220.                             currentItem.Use();
  221.                         } else {
  222.                             RaycastHit hit = GetObject();
  223.                             if (hit.transform != null) {
  224.                                 PlayerController hitPlayer = hit.transform.GetComponent<PlayerController>();
  225.                                 if (hitPlayer != null) {
  226.                                     foreach (Teleporter teleporter in FindObjectsOfType<Teleporter>()) {
  227.                                         if (hitPlayer != controller) {
  228.                                             if (teleporter.id == id) {
  229.                                                 Vector3 pos = teleporter.transform.position + new Vector3(0, 2, 0);
  230.                                                 photonView.RPC("RpcStunEffect", PhotonTargets.AllBuffered,
  231.                                                  focalObject.transform.position.x,
  232.                                                  focalObject.transform.position.y,
  233.                                                  focalObject.transform.position.z);
  234.                                                 hitPlayer.photonView.RPC("Teleport", PhotonTargets.AllBuffered, pos.x, pos.y, pos.z);
  235.                                                 PhotonNetwork.Destroy(teleporter.GetComponent<PhotonView>());
  236.                                                 currentItem.GetComponent<TeleporterItem>().count--;
  237.                                                 currentItem.GetComponent<TeleporterItem>().id = 0;
  238.                                                 teleporterTimer.Reset();
  239.                                                 teleporterTimer.Start();
  240.                                                 triggered3 = true;
  241.                                             }
  242.                                         }
  243.                                     }
  244.                                 }
  245.                             }
  246.                         }
  247.                     }
  248.                 }
  249.             } else {
  250.                 if (triggered3) {
  251.                     photonView.RPC("RpcResetStunEffect", PhotonTargets.AllBuffered);
  252.                     triggered3 = false;
  253.                 }
  254.             }
  255.             if (falseInputTimer.ElapsedMilliseconds >= 1000) {
  256.                 ignoredFalseCommand = true;
  257.             }
  258.             focalObject.transform.position = Vector3.Lerp(focalObject.transform.position, _lastRaycastHit, 0.2f);
  259.             if (timeSinceLastSwitch.ElapsedMilliseconds >= timeSensitivity) {
  260.                 CheckForFlashLightChange();
  261.                 if (Input.GetKeyUp(KeyCode.E)) {
  262.                     if (keyHeld.ElapsedMilliseconds <= 500) {
  263.                         if (!holdingObject) {
  264.                             RaycastHit hit = GetObject();
  265.                             if (hit.transform != null) {
  266.                                 placeableObject = hit.transform.gameObject.GetComponent<PlacableObject>();
  267.                                 if (placeableObject != null) {
  268.                                     placeableObject.Interact();
  269.                                 }
  270.                             }
  271.                         }
  272.                     } else {
  273.                         if (!holdingObject) {
  274.                             RaycastHit hit = GetObject();
  275.                             if (hit.transform != null) {
  276.                                 placeableObject = hit.transform.gameObject.GetComponent<PlacableObject>();
  277.                                 if (placeableObject != null) {
  278.                                     placeableObject._isBeingHeld = true;
  279.                                     holdingObject = true;
  280.                                 }
  281.                             }
  282.                         } else {
  283.                             ResetHold();
  284.                         }
  285.                     }
  286.                     keyHeld.Stop();
  287.                     keyHeld.Reset();
  288.                 }
  289.                 if (Input.GetKeyDown(KeyCode.E)) {
  290.                     if (!keyHeld.IsRunning) {
  291.                         keyHeld.Start();
  292.                     }
  293.                 }
  294.                 if (!lockInventory) {
  295.                     //if (Input.GetKeyUp(KeyCode.Space)) {
  296.                     //    if (currentItem != null) {
  297.                     //        //currentItem.Use();
  298.                     //    }
  299.                     //}
  300.                     //if (Input.GetKeyUp(KeyCode.P)) {
  301.                     //  RaycastHit hit = GetObject();
  302.                     //  if (hit.transform != null) {
  303.                     //    InventoryItem newItem = hit.transform.gameObject.GetComponent<InventoryItem>();
  304.                     //    if (newItem.CanBeAddedToInventory) {
  305.                     //      switch (newItem.Type) {
  306.                     //        case InventoryItem.CategoryType.Equipment:
  307.                     //          newItem.AddToInventory(_inventory[0]._inventory);
  308.                     //          _inventory[0].Refresh();
  309.                     //          break;
  310.                     //        case InventoryItem.CategoryType.Paper:
  311.                     //          newItem.AddToInventory(_inventory[1]._inventory);
  312.                     //          break;
  313.                     //        case InventoryItem.CategoryType.Item:
  314.                     //          newItem.AddToInventory(_inventory[2]._inventory);
  315.                     //          break;
  316.                     //      }
  317.                     //    }
  318.                     //  }
  319.                     //}
  320.                 }
  321.             }
  322.             //if (Input.GetKeyUp(KeyCode.I)) {
  323.             //  FindObjectOfType<Canvas>().enabled = !FindObjectOfType<Canvas>().enabled;
  324.             //  lockInventory = FindObjectOfType<Canvas>().enabled;
  325.             //}
  326.         } else {
  327.             if (placeableObject != null) {
  328.                 ResetHold();
  329.             }
  330.         }
  331.     }
  332.  
  333.     private RaycastHit GetObject() {
  334.         Ray ray = new Ray(transform.position, transform.forward);
  335.         RaycastHit hit = new RaycastHit();
  336.         Physics.Raycast(ray, out hit, 20f);
  337.         return hit;
  338.     }
  339.  
  340.     private void CheckForFlashLightChange() {
  341.         if (Input.GetKeyDown(KeyCode.F)) {
  342.             flashLightOn = !flashLightOn;
  343.             if (flashLightOn) {
  344.                 _flashLight.intensity = 2;
  345.             } else {
  346.                 _flashLight.intensity = 0;
  347.             }
  348.         }
  349.     }
  350.     private void ResetHold() {
  351.         placeableObject._isBeingHeld = false;
  352.         placeableObject = null;
  353.         holdingObject = false;
  354.     }
  355. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!