Upload from upload_mods.ps1

KFAttached/FPSPack/Demo.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1b7fe40f86d8131479dac6a7eb9f7f66
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/Demo/FPSDemoGUI.cs

@@ -0,0 +1,68 @@
+using UnityEngine;
+
+public class FPSDemoGUI : MonoBehaviour
+{
+    public GameObject[] Prefabs;
+    public Transform muzzleFlashPoint;
+    public GameObject Gun;
+    public float reactivateTime = 4;
+    public Light Sun;
+
+    private int currentNomber;
+    private GameObject currentInstance;
+    private GUIStyle guiStyleHeader = new GUIStyle();
+    private float sunIntensity;
+    float dpiScale;
+
+    // Use this for initialization
+    void Start()
+    {
+        if (Screen.dpi < 1) dpiScale = 1;
+        if (Screen.dpi < 200) dpiScale = 1;
+        else dpiScale = Screen.dpi / 200f;
+        guiStyleHeader.fontSize = (int)(15f * dpiScale);
+        guiStyleHeader.normal.textColor = new Color(0.15f, 0.15f, 0.15f);
+        currentInstance = Instantiate(Prefabs[currentNomber], transform.position, transform.rotation) as GameObject;
+        var reactivator = currentInstance.AddComponent<FPSDemoReactivator>();
+        reactivator.TimeDelayToReactivate = reactivateTime;
+        sunIntensity = Sun.intensity;
+    }
+
+    private void OnGUI()
+    {
+        if (GUI.Button(new Rect(10 * dpiScale, 15 * dpiScale, 135 * dpiScale, 37 * dpiScale), "PREVIOUS EFFECT"))
+        {
+            ChangeCurrent(-1);
+        }
+        if (GUI.Button(new Rect(160 * dpiScale, 15 * dpiScale, 135 * dpiScale, 37 * dpiScale), "NEXT EFFECT"))
+        {
+            ChangeCurrent(+1);
+        }
+        sunIntensity = GUI.HorizontalSlider(new Rect(10 * dpiScale, 70 * dpiScale, 285 * dpiScale, 15 * dpiScale), sunIntensity, 0, 0.6f);
+        Sun.intensity = sunIntensity;
+        GUI.Label(new Rect(300 * dpiScale, 70 * dpiScale, 30 * dpiScale, 30 * dpiScale), "SUN INTENSITY", guiStyleHeader);
+        GUI.Label(new Rect(400 * dpiScale, 15 * dpiScale, 100 * dpiScale, 20 * dpiScale), "Prefab name is \"" + Prefabs[currentNomber].name + "\"  \r\nHold any mouse button that would move the camera", guiStyleHeader);
+    }
+    // Update is called once per frame
+    void ChangeCurrent(int delta)
+    {
+        currentNomber += delta;
+        if (currentNomber > Prefabs.Length - 1)
+            currentNomber = 0;
+        else if (currentNomber < 0)
+            currentNomber = Prefabs.Length - 1;
+        if (currentInstance != null) Destroy(currentInstance);
+        if (currentNomber < 10)
+        {
+            currentInstance = Instantiate(Prefabs[currentNomber], transform.position, transform.rotation) as GameObject;
+            Gun.SetActive(false);
+        }
+        else
+        {
+            currentInstance = Instantiate(Prefabs[currentNomber], muzzleFlashPoint.position, muzzleFlashPoint.rotation) as GameObject;
+            Gun.SetActive(true);
+        }
+        var reactivator = currentInstance.AddComponent<FPSDemoReactivator>();
+        reactivator.TimeDelayToReactivate = reactivateTime;
+    }
+}

KFAttached/FPSPack/Demo/FPSDemoGUI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7f44a7ad42765c94b896425517325f1a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/Demo/FPSDemoReactivator.cs

@@ -0,0 +1,19 @@
+using UnityEngine;
+
+public class FPSDemoReactivator : MonoBehaviour
+{
+
+    public float StartDelay = 0;
+    public float TimeDelayToReactivate = 3;
+
+    void Start()
+    {
+        InvokeRepeating("Reactivate", StartDelay, TimeDelayToReactivate);
+    }
+
+    void Reactivate()
+    {
+        gameObject.SetActive(false);
+        gameObject.SetActive(true);
+    }
+}

KFAttached/FPSPack/Demo/FPSDemoReactivator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 77e369a1e74c2d84ead64ef026b1c433
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/Demo/FPSFireManager.cs

@@ -0,0 +1,49 @@
+using UnityEngine;
+
+public class FPSFireManager : MonoBehaviour
+{
+    public ImpactInfo[] ImpactElemets = new ImpactInfo[0];
+    public float BulletDistance = 100;
+    public GameObject ImpactEffect;
+
+    void Update()
+    {
+        if (Input.GetMouseButtonDown(0))
+        {
+            RaycastHit hit;
+            var ray = new Ray(transform.position, transform.forward);
+            if (Physics.Raycast(ray, out hit, BulletDistance))
+            {
+                var effect = GetImpactEffect(hit.transform.gameObject);
+                if (effect == null)
+                    return;
+                var effectIstance = Instantiate(effect, hit.point, new Quaternion()) as GameObject;
+                ImpactEffect.SetActive(false);
+                ImpactEffect.SetActive(true);
+                effectIstance.transform.LookAt(hit.point + hit.normal);
+                Destroy(effectIstance, 4);
+            }
+
+        }
+    }
+
+    [System.Serializable]
+    public class ImpactInfo
+    {
+        public MaterialType.MaterialTypeEnum MaterialType;
+        public GameObject ImpactEffect;
+    }
+
+    GameObject GetImpactEffect(GameObject impactedGameObject)
+    {
+        var materialType = impactedGameObject.GetComponent<MaterialType>();
+        if (materialType == null)
+            return null;
+        foreach (var impactInfo in ImpactElemets)
+        {
+            if (impactInfo.MaterialType == materialType.TypeOfMaterial)
+                return impactInfo.ImpactEffect;
+        }
+        return null;
+    }
+}

KFAttached/FPSPack/Demo/FPSFireManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eabaea637d046b649916223ab9952a50
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/Demo/MouseLock.cs

@@ -0,0 +1,22 @@
+using UnityEngine;
+
+public class MouseLock : MonoBehaviour
+{
+
+    // Use this for initialization
+    void Start()
+    {
+
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+#if UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5 || UNITY_4_6 
+		    Screen.lockCursor = true;
+#else
+        Cursor.visible = false;
+#endif
+
+    }
+}

KFAttached/FPSPack/Demo/MouseLock.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fc19b6a3661472848bf60b7ac730c242
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/FPSLightCurves.cs

@@ -0,0 +1,47 @@
+using UnityEngine;
+
+public class FPSLightCurves : MonoBehaviour
+{
+    public AnimationCurve LightCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
+    public float GraphTimeMultiplier = 1, GraphIntensityMultiplier = 1;
+
+    private bool canUpdate;
+    private bool firstUpdate;
+    private float startTime;
+    private Light lightSource;
+
+    private void Awake()
+    {
+        lightSource = GetComponent<Light>();
+    }
+
+    private void OnEnable()
+    {
+        lightSource.intensity = LightCurve.Evaluate(0);
+        if (firstUpdate)
+        {
+            firstUpdate = false;
+            return;
+        }
+        startTime = Time.time;
+        canUpdate = true;
+    }
+
+    private void OnDisable()
+    {
+        firstUpdate = true;
+        canUpdate = false;
+    }
+
+    private void Update()
+    {
+        var time = Time.time - startTime;
+        if (canUpdate)
+        {
+            var eval = LightCurve.Evaluate(time / GraphTimeMultiplier) * GraphIntensityMultiplier;
+            lightSource.intensity = eval;
+        }
+        if (time >= GraphTimeMultiplier)
+            canUpdate = false;
+    }
+}

KFAttached/FPSPack/FPSLightCurves.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 22b1c2a9f789e3e47a7c58fa60e17e5d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/FPSParticleSystemScaler.cs

@@ -0,0 +1,62 @@
+using UnityEngine;
+
+#if UNITY_EDITOR 
+using UnityEditor;
+#endif
+
+[ExecuteInEditMode]
+public class FPSParticleSystemScaler : MonoBehaviour
+{
+    public float particlesScale = 1.0f;
+
+    float oldScale;
+
+    void Start()
+    {
+        oldScale = particlesScale;
+    }
+
+    void Update()
+    {
+#if UNITY_EDITOR
+		if (Mathf.Abs(oldScale - particlesScale) > 0.0001f && particlesScale > 0)
+		{
+			transform.localScale = new Vector3(particlesScale, particlesScale, particlesScale);
+			float scale = particlesScale / oldScale;
+			var ps = this.GetComponentsInChildren<ParticleSystem>();
+			
+			foreach (ParticleSystem particles in ps)
+			{
+				particles.startSize *= scale;
+				particles.startSpeed *= scale;
+				particles.gravityModifier *= scale;
+				
+				SerializedObject serializedObject = new SerializedObject(particles);
+				serializedObject.FindProperty("ClampVelocityModule.magnitude.scalar").floatValue *= scale;
+				serializedObject.FindProperty("ClampVelocityModule.x.scalar").floatValue *= scale;
+				serializedObject.FindProperty("ClampVelocityModule.y.scalar").floatValue *= scale;
+				serializedObject.FindProperty("ClampVelocityModule.z.scalar").floatValue *= scale;
+				serializedObject.FindProperty("VelocityModule.x.scalar").floatValue *= scale;
+				serializedObject.FindProperty("VelocityModule.y.scalar").floatValue *= scale;
+				serializedObject.FindProperty("VelocityModule.z.scalar").floatValue *= scale;
+				serializedObject.FindProperty("ColorBySpeedModule.range").vector2Value *= scale;
+				serializedObject.FindProperty("RotationBySpeedModule.range").vector2Value *= scale;
+				serializedObject.FindProperty("ForceModule.x.scalar").floatValue *= scale;
+				serializedObject.FindProperty("ForceModule.y.scalar").floatValue *= scale;
+				serializedObject.FindProperty("ForceModule.z.scalar").floatValue *= scale;
+				serializedObject.FindProperty("SizeBySpeedModule.range").vector2Value *= scale;
+				
+				serializedObject.ApplyModifiedProperties();
+			}
+
+			var trails = this.GetComponentsInChildren<TrailRenderer>();
+			foreach (TrailRenderer trail in trails)
+			{
+				trail.startWidth *= scale;
+				trail.endWidth *= scale;
+			}
+			oldScale = particlesScale;
+		}
+#endif
+    }
+}

KFAttached/FPSPack/FPSParticleSystemScaler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c035660ec1d9fd64da7beb32f35b7437
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/FPSRandomRotateAngle.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+
+public class FPSRandomRotateAngle : MonoBehaviour
+{
+    public bool RotateX;
+    public bool RotateY;
+    public bool RotateZ = true;
+
+    private Transform t;
+
+    // Use this for initialization
+    void Awake()
+    {
+        t = transform;
+    }
+
+    // Update is called once per frame
+    void OnEnable()
+    {
+        var rotateVector = Vector3.zero;
+        if (RotateX)
+            rotateVector.x = Random.Range(0, 360);
+        if (RotateY)
+            rotateVector.y = Random.Range(0, 360);
+        if (RotateZ)
+            rotateVector.z = Random.Range(0, 360);
+        t.Rotate(rotateVector);
+    }
+}

KFAttached/FPSPack/FPSRandomRotateAngle.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a7a83f50808621b43bd26cd127393a40
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/FPSShaderColorGradient.cs

@@ -0,0 +1,61 @@
+using UnityEngine;
+
+public class FPSShaderColorGradient : MonoBehaviour
+{
+    public string ShaderProperty = "_TintColor";
+    public int MaterialID = 0;
+    public Gradient Color = new Gradient();
+    public float TimeMultiplier = 1;
+
+    private bool canUpdate;
+    private Material matInstance;
+    private int propertyID;
+    private float startTime;
+    private Color oldColor;
+
+    // Use this for initialization
+    private void Start()
+    {
+        var rend = GetComponent<Renderer>();
+        if (rend != null)
+        {
+            var mats = rend.materials;
+            if (MaterialID >= mats.Length)
+                Debug.Log("ShaderColorGradient: Material ID more than shader materials count.");
+            matInstance = mats[MaterialID];
+        }
+        else
+        {
+            var proj = GetComponent<Projector>();
+            var projMat = proj.material;
+            if (!projMat.name.EndsWith("(Instance)"))
+                matInstance = new Material(projMat) { name = projMat.name + " (Instance)" };
+            else
+                matInstance = projMat;
+            proj.material = matInstance;
+        }
+
+        if (!matInstance.HasProperty(ShaderProperty))
+            Debug.Log("ShaderColorGradient: Shader not have \"" + ShaderProperty + "\" property");
+        propertyID = Shader.PropertyToID(ShaderProperty);
+        oldColor = matInstance.GetColor(propertyID);
+    }
+
+    private void OnEnable()
+    {
+        startTime = Time.time;
+        canUpdate = true;
+    }
+
+    private void Update()
+    {
+        var time = Time.time - startTime;
+        if (canUpdate)
+        {
+            var eval = Color.Evaluate(time / TimeMultiplier);
+            matInstance.SetColor(propertyID, eval * oldColor);
+        }
+        if (time >= TimeMultiplier)
+            canUpdate = false;
+    }
+}

KFAttached/FPSPack/FPSShaderColorGradient.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1f6f8e03260dedb45a05a2c5f5eea632
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/FPSShaderFloatCurves.cs

@@ -0,0 +1,57 @@
+using UnityEngine;
+
+public class FPSShaderFloatCurves : MonoBehaviour
+{
+    public string ShaderProperty = "_BumpAmt";
+    public int MaterialID = 0;
+    public AnimationCurve FloatPropertyCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
+    public float GraphTimeMultiplier = 1, GraphScaleMultiplier = 1;
+
+    private bool canUpdate;
+    private Material matInstance;
+    private int propertyID;
+    private float startTime;
+
+    private void Start()
+    {
+        var rend = GetComponent<Renderer>();
+        if (rend != null)
+        {
+            var mats = rend.materials;
+            if (MaterialID >= mats.Length)
+                Debug.Log("ShaderColorGradient: Material ID more than shader materials count.");
+            matInstance = mats[MaterialID];
+        }
+        else
+        {
+            var proj = GetComponent<Projector>();
+            var projMat = proj.material;
+            if (!projMat.name.EndsWith("(Instance)"))
+                matInstance = new Material(projMat) { name = projMat.name + " (Instance)" };
+            else
+                matInstance = projMat;
+            proj.material = matInstance;
+        }
+        if (!matInstance.HasProperty(ShaderProperty))
+            Debug.Log("ShaderColorGradient: Shader not have \"" + ShaderProperty + "\" property");
+        propertyID = Shader.PropertyToID(ShaderProperty);
+    }
+
+    private void OnEnable()
+    {
+        startTime = Time.time;
+        canUpdate = true;
+    }
+
+    private void Update()
+    {
+        var time = Time.time - startTime;
+        if (canUpdate)
+        {
+            var eval = FloatPropertyCurve.Evaluate(time / GraphTimeMultiplier) * GraphScaleMultiplier;
+            matInstance.SetFloat(propertyID, eval);
+        }
+        if (time >= GraphTimeMultiplier)
+            canUpdate = false;
+    }
+}

KFAttached/FPSPack/FPSShaderFloatCurves.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 91b9007bb8bdfdc4cb4e31998935a777
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/FPSPack/MaterialType.cs

@@ -0,0 +1,22 @@
+using UnityEngine;
+
+public class MaterialType : MonoBehaviour
+{
+
+    public MaterialTypeEnum TypeOfMaterial = MaterialTypeEnum.Plaster;
+
+    [System.Serializable]
+    public enum MaterialTypeEnum
+    {
+        Plaster,
+        Metall,
+        Folliage,
+        Rock,
+        Wood,
+        Brick,
+        Concrete,
+        Dirt,
+        Glass,
+        Water
+    }
+}

KFAttached/FPSPack/MaterialType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e86c216f014d903439060cd429cb53a2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: