SHARE
TWEET

WaterMod [Besiege]

a guest Jun 17th, 2016 2,442 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using UnityEngine;
  8. using System.IO;
  9. using System.Threading;
  10. using spaar.ModLoader;
  11.  
  12.  
  13. namespace WaterMod {
  14.  
  15.     public class WaterLoader : spaar.ModLoader.Mod {
  16.  
  17.         public override string Author {
  18.             get { return "ITR"; }
  19.         }
  20.  
  21.         public override string DisplayName {
  22.             get { return "WaterMod"; }
  23.         }
  24.  
  25.         public override string Name {
  26.             get { return "WaterMod"; }
  27.         }
  28.  
  29.         Water water;
  30.         public override void OnLoad() {
  31.             Game.DontDestroyOnLoad(water=Water.Instance);
  32.         }
  33.  
  34.         public override void OnUnload() {
  35.             Game.Destroy(water.gameObject);
  36.         }
  37.  
  38.         public override bool CanBeUnloaded {
  39.             get {
  40.                 return true;
  41.             }
  42.         }
  43.  
  44.  
  45.         public override Version Version {
  46.             get {
  47.                 return new Version(1,0,0);
  48.             }
  49.         }
  50.     }
  51.  
  52.     public class Water : SingleInstance<Water> {
  53.         public override string Name {
  54.             get {
  55.                 return "WaterHandler";
  56.             }
  57.         }
  58.  
  59.         private FloaterController floaterController;
  60.         //      private FogVolumeInscatterX2 fogVolumeInscatterX2;
  61.  
  62.         public static float waterHeight = spaar.ModLoader.Configuration.GetFloat("WaterHeight",25);
  63.         public static float waterForce = spaar.ModLoader.Configuration.GetFloat("WaterForce",200);
  64.         public static float massMultiplier = spaar.ModLoader.Configuration.GetFloat("MassMultiplier",2.5f);
  65.         public static bool addRandomTorque = spaar.ModLoader.Configuration.GetBool("AddRandomWaterTorque",false);
  66.  
  67.         public static bool useMassChange = spaar.ModLoader.Configuration.GetBool("UseMassChange",false);
  68.         public static float dragPlus = spaar.ModLoader.Configuration.GetFloat("DragPlus",5f);
  69.         public static float dragMult = spaar.ModLoader.Configuration.GetFloat("DragMult",2f);
  70.  
  71.         public static bool useRusting = spaar.ModLoader.Configuration.GetBool("UseRusting",true);
  72.  
  73.         public static bool useSharkSoldiers = spaar.ModLoader.Configuration.GetBool("UseSharkSoldiers",true);
  74.         public static bool useDivingArchers = spaar.ModLoader.Configuration.GetBool("UseDivingArchers",true);
  75.         public static bool useJetJaks = spaar.ModLoader.Configuration.GetBool("UseJetJaks",true);
  76.  
  77.         public static bool useBoats = spaar.ModLoader.Configuration.GetBool("UseBoats",false);
  78.         public static float rotForce = spaar.ModLoader.Configuration.GetFloat("RotForce",5f);
  79.  
  80.         public static bool useWaterPlane = spaar.ModLoader.Configuration.GetBool("UseWaterPlane",true);
  81.         WaterPlane waterPlane;
  82.  
  83.         public static int RustDestroyed = 0;
  84.  
  85.         public void Start() {
  86.             //          fogVolumeInscatterX2 = gameObject.AddComponent<FogVolumeInscatterX2>();
  87.             floaterController = gameObject.AddComponent<FloaterController>();
  88.  
  89.             spaar.Commands.RegisterHelpMessage("Water commands:\n     WaterHeight /[height]\n     WaterForce /[multiplier]\n     EditMultiplier [name] [multiplier]\n     ForceCheck\n     ListFloaters /[name]\n     CheckFloater [name]\n     CheckRuster [name]\n     WaterPlane /[bool]\n     MassMultiplier /[multiplier]\n     WaterAlpha /[alpha]\n     RoofHeight /[height]\n     FogDensity /[alpha]\n     FogEndDistance /[distance]\n     CountAddedOnSimulate /[bool]\n     useSharkSoldiers /[bool]\n     useDivingArchers /[bool]\n     useJetJaks /[bool]\n     useMassChange /[bool]\n     DragAdd /[value]\n     DragMult /[multiplier]\n  UseRust /[bool]\n   Boats [bool]\n  UseOtherGraphiscForWater [bool]\n   ChangeShaderLegacies [bool]\n   AddRandomTorque [bool]\n    FloaterGravity [float]");
  90.  
  91.             spaar.Commands.RegisterCommand("WaterHeight",(args,namedArgs) => {
  92.                 try {
  93.                     waterHeight = float.Parse(args[0]);
  94.                 }
  95.                 catch {
  96.                     return "WaterHeight is "+waterHeight.ToString();
  97.                 }
  98.                 return "WaterHeight was set to "+waterHeight.ToString();
  99.             },"Sets the water level to [height] or tells you how high it is");
  100.  
  101.             spaar.Commands.RegisterCommand("WaterForce",(args,namedArgs) => {
  102.                 try {
  103.                     waterForce = float.Parse(args[0]);
  104.                 }
  105.                 catch {
  106.                     return "WaterForce is "+waterForce.ToString();
  107.                 }
  108.                 return "WaterForce was set to "+waterForce.ToString();
  109.             },"Sets the water level to [multiplier] or tells you how high it is");
  110.  
  111.             spaar.Commands.RegisterCommand("DragMult",(args,namedArgs) => {
  112.                 try {
  113.                     dragMult = float.Parse(args[0]);
  114.                 }
  115.                 catch {
  116.                     return "DragMult is "+dragMult.ToString();
  117.                 }
  118.                 return "DragMult was set to "+dragMult.ToString();
  119.             },"Sets DragMult to [multiplier] or tells you how high it is");
  120.  
  121.             spaar.Commands.RegisterCommand("DragPlus",(args,namedArgs) => {
  122.                 try {
  123.                     dragPlus = float.Parse(args[0]);
  124.                 }
  125.                 catch {
  126.                     return "DragPlus is "+dragPlus.ToString();
  127.                 }
  128.                 return "DragPlus was set to "+dragPlus.ToString();
  129.             },"Sets DragPlus to [value] or tells you how high it is");
  130.  
  131.             spaar.Commands.RegisterCommand("ForceCheck",(args,namedArgs) => {
  132.                 return floaterController.AddStuff();
  133.             },"Checks for rigidbodies without floaters");
  134.  
  135.             spaar.Commands.RegisterCommand("ListFloaters",(args,namedArgs) => {
  136.                 Floater[] floaters = floaterController.allFloaters;
  137.                 string ret = "Floaters:\n";
  138.                 for(int i = 0;i<floaters.Length;i++) {
  139.                     if(floaters[i]==null) {
  140.                         ModConsole.AddMessage(LogType.Error,"floater["+i+"] is null!");
  141.                         continue;
  142.                     }
  143.                     if(floaters[i].gameObject==null) {
  144.                         ModConsole.AddMessage(LogType.Error,"floater["+i+"].gameObject is null!");
  145.                         continue;
  146.                     }
  147.                     if(args.Length>0) {
  148.                         if(!floaters[i].gameObject.name.Contains(args[0]))
  149.                             continue;
  150.                     }
  151.                     ret += floaters[i].gameObject.name;
  152.                     if(floaters[i].gameObject.GetComponent<MyBlockInfo>()!=null)
  153.                         ret += ": " + floaters[i].gameObject.GetComponent<MyBlockInfo>().blockName;
  154.                     ret += "\n";
  155.                 }
  156.                 return ret;
  157.             },"Lists all floaters or those containing [name] in their name");
  158.  
  159.             spaar.Commands.RegisterCommand("CheckFloater",(args,namedArgs) => {
  160.                 if(args.Length<1)
  161.                     return "You forgot to name which floater you wanted to check";
  162.                 Floater[] floaters = floaterController.allFloaters;
  163.                 string ret = "";
  164.                 for(int i = 0;i<floaters.Length;i++) {
  165.                     if(floaters[i].gameObject.name.Contains(args[0])) {
  166.                         ret += floaters[i].gameObject.name +": OriginalDrag:"+floaters[i].originalDrag.ToString() + " CurrentDrag:"+floaters[i].currentDrag.ToString()+" OriginalAngularDrag: "+floaters[i].originalAngularDrag.ToString()+" CurrentAngularDrag: "+floaters[i].currentAngularDrag.ToString()+" Multiplier: "+floaters[i].multiplier.ToString()+" OriginalMass: "+floaters[i].originalMass.ToString();
  167.                         MyBlockInfo myBlockInfo = floaters[i].gameObject.GetComponent<MyBlockInfo>();
  168.                         if(myBlockInfo!=null) {
  169.                             ret += " BlockName: "+myBlockInfo.blockName;
  170.                         }
  171.                         ret += "\n";
  172.                     }
  173.                 }
  174.                 return ret;
  175.             },"Checks floaters that have [name] in their name");
  176.  
  177.             spaar.Commands.RegisterCommand("CheckRuster",(args,namedArgs) => {
  178.                 if(args.Length<1)
  179.                     return "You forgot to name which ruster you wanted to check";
  180.                 Ruster[] rusters = FindObjectsOfType<Ruster>();
  181.                 string ret = "";
  182.                 for(int i = 0;i<rusters.Length;i++) {
  183.                     if(rusters[i].name.Contains(args[0])) {
  184.                         ret += rusters[i].name +": Rusty:"+rusters[i].Rusty.ToString();
  185.                         MyBlockInfo myBlockInfo = rusters[i].GetComponent<MyBlockInfo>();
  186.                         if(myBlockInfo!=null) {
  187.                             ret += " BlockName: "+myBlockInfo.blockName;
  188.                         }
  189.                         ret += "\n";
  190.                     }
  191.                 }
  192.                 return ret;
  193.             },"Checks rusters that have [name] in their name");
  194.  
  195.             spaar.Commands.RegisterCommand("EditMultiplier",(args,namedArgs) => {
  196.                 if(args.Length<1)
  197.                     return "You forgot to name which floater you wanted to edit";
  198.                 float newMultiplier = 0;
  199.                 try {
  200.                     newMultiplier = float.Parse(args[1]);
  201.                 }
  202.                 catch {
  203.                     return "Failed to parse [multiplier]";
  204.                 }
  205.                 Floater[] floaters = floaterController.allFloaters;
  206.                 string ret = "";
  207.                 for(int i = 0;i<floaters.Length;i++) {
  208.                     if(floaters[i].gameObject.name.Contains(args[0])) {
  209.                         ret += floaters[i].gameObject.name;
  210.                         MyBlockInfo myBlockInfo = floaters[i].gameObject.GetComponent<MyBlockInfo>();
  211.                         if(myBlockInfo!=null) {
  212.                             ret += ", BlockName: "+myBlockInfo.blockName;
  213.                         }
  214.                         ret += ", Changed from:"+floaters[i].multiplier;
  215.                         floaters[i].multiplier = newMultiplier;
  216.                         ret += "\n";
  217.                     }
  218.                 }
  219.                 return ret;
  220.             },"Edits the UpForceMultipliers of floaters that have [name] in their name to [multiplier]");
  221.  
  222.             spaar.Commands.RegisterCommand("WaterPlane",(args,namedArgs) => {
  223.                 try {
  224.                     useWaterPlane = bool.Parse(args[0]);
  225.                 }
  226.                 catch {
  227.                     return "Water plane is "+useWaterPlane.ToString();
  228.                 }
  229.                 return "Set water plane to "+useWaterPlane.ToString();
  230.             },"Changes if the WaterPlane is visible to [bool]");
  231.  
  232.             spaar.Commands.RegisterCommand("MassMultiplier",(args,namedArgs) => {
  233.                 try {
  234.                     massMultiplier = float.Parse(args[0]);
  235.                 }
  236.                 catch {
  237.                     return "MassMultiplier is "+massMultiplier.ToString();
  238.                 }
  239.                 return "Set MassMultiplier to "+massMultiplier.ToString();
  240.             },"Changes the MassMultiplier to [multiplier]");
  241.  
  242.             spaar.Commands.RegisterCommand("WaterAlpha",(args,namedArgs) => {
  243.                 float alpha;
  244.                 try {
  245.                     alpha = float.Parse(args[0]);
  246.                 }
  247.                 catch {
  248.                     return "WaterAlpha is "+WaterPlane.waterAlpha.ToString();
  249.                 }
  250.                 if(alpha<0) {
  251.                     return "[alpha] must be bigger than 0";
  252.                 }
  253.                 else if(alpha>1) {
  254.                     return "[alpha] must be less than 1";
  255.                 }
  256.                 WaterPlane.waterAlpha = alpha;
  257.                 return "Set WaterAlpha to "+alpha.ToString();
  258.             },"Changes the WaterAlpha to [alpha]");
  259.  
  260.             spaar.Commands.RegisterCommand("FogDensity",(args,namedArgs) => {
  261.                 float alpha;
  262.                 try {
  263.                     alpha = float.Parse(args[0]);
  264.                 }
  265.                 catch {
  266.                     return "FogDensity is "+newFogDensity.ToString();
  267.                 }
  268.                 if(alpha<0) {
  269.                     return "[alpha] must be bigger than 0";
  270.                 }
  271.                 else if(alpha>1) {
  272.                     //                  return "[alpha] must be less than 1";
  273.                 }
  274.                 newFogDensity = alpha;
  275.                 return "Set FogDensity to "+alpha.ToString();
  276.             },"Changes the FogDensity to [alpha]");
  277.  
  278.             spaar.Commands.RegisterCommand("FogEndDistance",(args,namedArgs) => {
  279.                 float distance;
  280.                 try {
  281.                     distance = float.Parse(args[0]);
  282.                 }
  283.                 catch {
  284.                     return "FogEndDistance is "+newFogEndDistance.ToString();
  285.                 }
  286.                 if(distance<0) {
  287.                     return "[distance] must be bigger than 0";
  288.                 }
  289.                 else if(distance>1) {
  290.                     //                  return "[alpha] must be less than 1";
  291.                 }
  292.                 newFogEndDistance = distance;
  293.                 return "Set FogEndDistance to "+distance.ToString();
  294.             },"Changes the FogEndDistance to [distance]");
  295.  
  296.             spaar.Commands.RegisterCommand("RoofHeight",(args,namedArgs) => {
  297.                 float alpha;
  298.                 try {
  299.                     alpha = float.Parse(args[0]);
  300.                 }
  301.                 catch {
  302.                     return "ROOF is "+ StatMaster.Bounding.roofHeight.ToString();
  303.                 }
  304.                 StatMaster.Bounding.roofHeight = alpha;
  305.                 return "Set ROOF to "+StatMaster.Bounding.roofHeight.ToString();
  306.             },"Changes the bounding box height to [height]");
  307.  
  308.             spaar.Commands.RegisterCommand("CountAddedOnSimulate",(args,namedArgs) => {
  309.                 try {
  310.                     floaterController.countAddedOnSimulate = bool.Parse(args[0]);
  311.                 }
  312.                 catch {
  313.                     return "CountAddedOnSimulate is "+floaterController.countAddedOnSimulate.ToString();
  314.                 }
  315.                 return "Set CountAddedOnSimulate to "+floaterController.countAddedOnSimulate.ToString();
  316.             },"Changes if it outputs how many of the different stuff it adds when it starts simulating");
  317.  
  318.             spaar.Commands.RegisterCommand("useSharkSoldiers",(args,namedArgs) => {
  319.                 try {
  320.                     useSharkSoldiers = bool.Parse(args[0]);
  321.                 }
  322.                 catch {
  323.                     return "useSharkSoldiers is "+useSharkSoldiers.ToString();
  324.                 }
  325.                 return "Set useSharkSoldiers to "+useSharkSoldiers.ToString();
  326.             },"Changes useSharkSoldiers to [bool]");
  327.  
  328.             spaar.Commands.RegisterCommand("useDivingArchers",(args,namedArgs) => {
  329.                 try {
  330.                     useDivingArchers = bool.Parse(args[0]);
  331.                 }
  332.                 catch {
  333.                     return "useDivingArchers is "+useDivingArchers.ToString();
  334.                 }
  335.                 return "Set useDivingArchers to "+useDivingArchers.ToString();
  336.             },"Changes useDivingArchers to [bool]");
  337.  
  338.             spaar.Commands.RegisterCommand("useJetJaks",(args,namedArgs) => {
  339.                 try {
  340.                     useJetJaks = bool.Parse(args[0]);
  341.                 }
  342.                 catch {
  343.                     return "useJetJaks is "+useJetJaks.ToString();
  344.                 }
  345.                 return "Set useJetJaks to "+useJetJaks.ToString();
  346.             },"Changes useJetJaks to [bool]");
  347.  
  348.             spaar.Commands.RegisterCommand("useMassChange",(args,namedArgs) => {
  349.                 try {
  350.                     useMassChange = bool.Parse(args[0]);
  351.                 }
  352.                 catch {
  353.                     return "useMassChange is "+useMassChange.ToString();
  354.                 }
  355.                 return "Set useMassChange to "+useMassChange.ToString();
  356.             },"Changes useMassChange to [bool]");
  357.  
  358.             spaar.Commands.RegisterCommand("UseRust",(args,namedArgs) => {
  359.                 try {
  360.                     useRusting = bool.Parse(args[0]);
  361.                 }
  362.                 catch {
  363.                     return "Use Rust is "+useRusting.ToString();
  364.                 }
  365.                 return "Set Use Rust to "+useRusting.ToString();
  366.             },"Changes if the metal stuff will break underwater");
  367.  
  368.             spaar.Commands.RegisterCommand("Boats",(args,namedArgs) => {
  369.                 try {
  370.                     useBoats = bool.Parse(args[0]);
  371.                 }
  372.                 catch {
  373.                     return "Boats is "+useBoats.ToString();
  374.                 }
  375.                 return "Set Boats to "+useBoats.ToString();
  376.             },"Boats.");
  377.  
  378.             spaar.Commands.RegisterCommand("RotForce",(args,namedArgs) => {
  379.                 try {
  380.                     rotForce = float.Parse(args[0]);
  381.                 }
  382.                 catch {
  383.                     return "RotForce is "+rotForce.ToString();
  384.                 }
  385.                 return "Set RotForce to "+rotForce.ToString();
  386.             },"Changes the RotForce to [multiplier]");
  387.  
  388.             spaar.Commands.RegisterCommand("AddRandomTorque",(args,namedArgs) => {
  389.                 try {
  390.                     addRandomTorque = bool.Parse(args[0]);
  391.                 }
  392.                 catch {
  393.                     return "AddRandomTorque is "+addRandomTorque.ToString();
  394.                 }
  395.                 return "Set AddRandomTorque to "+addRandomTorque.ToString();
  396.             },"Makes trees fall");
  397.  
  398.             spaar.Commands.RegisterCommand("FloaterGravity",(args,namedArgs) => {
  399.                 try {
  400.                     Floater.gravity = float.Parse(args[0]);
  401.                 }
  402.                 catch {
  403.                     return "FloaterGravity is "+Floater.gravity.ToString();
  404.                 }
  405.                 return "FloaterGravity was set to "+Floater.gravity.ToString();
  406.             },"Makes the floaters assume the gravity is [float]");
  407.  
  408.             spaar.Commands.RegisterCommand("UseThreads",(args,namedArgs) => {
  409.                 if(AddPiece.isSimulating) return "This can only be done while not simulating";
  410.                 try {
  411.                     FloaterController.UseThreads = Boolean.Parse(args[0]);
  412.                 }
  413.                 catch {
  414.                     return "UseThreads is set to "+FloaterController.UseThreads;
  415.                 }
  416.                 return "Set UseThreads to "+FloaterController.UseThreads;
  417.             },"If this is true, water will calculate multithreaded");
  418.  
  419.  
  420.             if(File.Exists(Application.dataPath+"/Mods/WinterMod.dll")) {
  421.                 WINTERISHERE = true;
  422.                 ModConsole.AddMessage(LogType.Assert,("WINTER IS HERE!"));
  423.             }
  424.  
  425.         }
  426.  
  427.         public static bool WINTERISHERE = false;
  428.  
  429.         public void FixedUpdate() {
  430.             RustDestroyed = 0;
  431.         }
  432.  
  433.         public static Mesh boatMesh = null;
  434.         public static Material boatMaterial = null;
  435.  
  436.         public void Update() {
  437.             if(useWaterPlane) {
  438.                 if(waterPlane==null) {
  439.                     waterPlane = GameObject.CreatePrimitive(PrimitiveType.Cube).AddComponent<WaterPlane>();
  440.  
  441.                     if(boatMesh==null) {
  442.                         GameObject ship = GameObject.Find("SHIP");
  443.                         if(ship!=null) {
  444.                             MeshFilter[] meshFilters = ship.GetComponentsInChildren<MeshFilter>();
  445.                             for(int i = 0;i<meshFilters.Length;i++) {
  446.                                 if(meshFilters[i].name=="default") {
  447.                                     boatMesh = meshFilters[i].mesh;
  448.                                     boatMaterial = meshFilters[i].GetComponent<MeshRenderer>().material;
  449.                                     break;
  450.                                 }
  451.                             }
  452.                         }
  453.                     }
  454.                 }
  455.             }
  456.             CameraStuff();
  457.         }
  458.  
  459.         //float fogStartDistance = 2;
  460.         Color fogColor = Color.white;
  461.         float fogDensity = 0;
  462.         //float fogEndDistance = 0;
  463.         //FogMode fogMode = FogMode.Linear;
  464.         //bool hasFog = false;
  465.         Light light;
  466.  
  467.         float newFogDensity = 0.015f;
  468.         float newFogEndDistance = 0.5f;
  469.  
  470.         public void OnLevelWasLoaded(int i) {
  471.             /*          fogStartDistance = RenderSettings.fogStartDistance;
  472.                         fogColor = RenderSettings.fogColor;
  473.                         fogDensity = RenderSettings.fogDensity;
  474.                         fogEndDistance = RenderSettings.fogEndDistance;
  475.                         fogMode = RenderSettings.fogMode;
  476.                         hasFog = RenderSettings.fog;*/
  477.             GameObject tempGM = GameObject.Find("Directional light");
  478.             if(tempGM!=null) {
  479.                 light = tempGM.GetComponent<Light>();
  480.                 if(tempGM!=null) {
  481.                     fogColor = light.color;
  482.                     fogDensity = light.intensity;
  483.                 }
  484.             }
  485.         }
  486.  
  487.         public void CameraStuff() {
  488.             if(light==null)
  489.                 return;
  490.             float tempWaterHeight = Water.waterHeight;
  491.             if(waterPlane!=null) {
  492.                 tempWaterHeight = waterPlane.transform.position.y;
  493.             }
  494.             if(Camera.main.transform.position.y<=tempWaterHeight) {
  495.                 light.color = new Color(0.5f,0.5f,1f,0.5f);
  496.                 light.intensity = 2;
  497.                 //              fogVolumeInscatterX2.FogMaterial.SetColor("_Color",new Color(0.5f,0.5f,1f,0.5f));
  498.                 //              fogVolumeInscatterX2.FogMaterial.SetColor("_InscatteringColor",new Color(0.5f,0.5f,1f,0.5f));
  499.                 //              fogVolumeInscatterX2.InscatteringIntensity = 20;
  500.                 //              RenderSettings.fogColor = new Color(0.5f,0.5f,1f,0.5f);
  501.                 //              RenderSettings.fogStartDistance = 0;
  502.                 //              RenderSettings.fogEndDistance = newFogEndDistance;
  503.                 //              RenderSettings.fogMode = FogMode.ExponentialSquared;
  504.                 //              RenderSettings.fogDensity = newFogDensity;
  505.                 //              RenderSettings.fog = true;
  506.             }
  507.             else {
  508.                 light.color = fogColor;
  509.                 light.intensity = fogDensity;
  510.                 /*              if(RenderSettings.fogStartDistance == 0) {
  511.                                     RenderSettings.fogStartDistance = fogStartDistance;
  512.                                     RenderSettings.fogColor = fogColor;
  513.                                     RenderSettings.fogDensity = fogDensity;
  514.                                     RenderSettings.fogEndDistance = fogEndDistance;
  515.                                     RenderSettings.fog = hasFog;
  516.                                     RenderSettings.fogMode = fogMode;
  517.                                 }*/
  518.             }
  519.         }
  520.  
  521.         public void OnDestroy() {
  522.             spaar.ModLoader.Configuration.SetFloat("WaterHeight",waterHeight);
  523.             spaar.ModLoader.Configuration.SetFloat("WaterForce",waterForce);
  524.             spaar.ModLoader.Configuration.SetFloat("MassMultiplier",massMultiplier);
  525.             spaar.ModLoader.Configuration.SetBool("AddRandomWaterTorque",addRandomTorque);
  526.  
  527.             spaar.ModLoader.Configuration.SetBool("UseMassChange",useMassChange);
  528.             spaar.ModLoader.Configuration.SetFloat("DragPlus",dragPlus);
  529.             spaar.ModLoader.Configuration.SetFloat("DragMult",dragMult);
  530.  
  531.             spaar.ModLoader.Configuration.SetBool("UseThreads",FloaterController.UseThreads);
  532.             spaar.ModLoader.Configuration.SetBool("UseRusting",useRusting);
  533.  
  534.             spaar.ModLoader.Configuration.SetBool("UseSharkSoldiers",useSharkSoldiers);
  535.             spaar.ModLoader.Configuration.SetBool("UseDivingArchers",useDivingArchers);
  536.             spaar.ModLoader.Configuration.SetBool("UseJetJaks",useJetJaks);
  537.  
  538.             spaar.ModLoader.Configuration.SetBool("UseBoats",useBoats);
  539.             spaar.ModLoader.Configuration.SetFloat("RotForce",rotForce);
  540.  
  541.             spaar.ModLoader.Configuration.SetBool("UseWaterPlane",useWaterPlane);
  542.             spaar.ModLoader.Configuration.SetFloat("FloaterGravity",Floater.gravity);
  543.  
  544.             if(waterPlane!=null)
  545.                 Destroy(waterPlane.gameObject);
  546.             Ruster[] allRusters = FindObjectsOfType<Ruster>();
  547.             for(int i = 0;i<allRusters.Length;i++) {
  548.                 Destroy(allRusters[i]);
  549.             }
  550.             UnderWaterCannon[] allUnderWaterCannons = FindObjectsOfType<UnderWaterCannon>();
  551.             for(int i = 0;i<allUnderWaterCannons.Length;i++) {
  552.                 Destroy(allUnderWaterCannons[i]);
  553.             }
  554.             UnderWaterFlamethrower[] allUnderWaterFlamethrowers = FindObjectsOfType<UnderWaterFlamethrower>();
  555.             for(int i = 0;i<allUnderWaterFlamethrowers.Length;i++) {
  556.                 Destroy(allUnderWaterFlamethrowers[i]);
  557.             }
  558.             DivingArchers[] allDivingArchers = FindObjectsOfType<DivingArchers>();
  559.             for(int i = 0;i<allDivingArchers.Length;i++) {
  560.                 Destroy(allDivingArchers[i]);
  561.             }
  562.             SharkSoldiers[] allSharkSoldiers = FindObjectsOfType<SharkSoldiers>();
  563.             for(int i = 0;i<allSharkSoldiers.Length;i++) {
  564.                 Destroy(allSharkSoldiers[i]);
  565.             }
  566.             spaar.ModLoader.Configuration.Save();
  567.         }
  568.     }
  569.  
  570.     public class FloaterController : MonoBehaviour {
  571.         public Floater[] allFloaters = new Floater[0];
  572.         bool isSimulating = false;
  573.         public bool countAddedOnSimulate = false;
  574.         string[] RUSTY = { "BALLAST","PLOW","METAL","HOLDER","DRILL","HINGE","CANNON","THROWER","SAW","SPIKE","DECOUPLER","SUSPENSION","PISTON","SPINNING","GRABBER","STEERING","COG","JOINT","BLADE","PIPE" };
  575.  
  576.         Thread[] threads;
  577.         object[] arguments;
  578.  
  579.         public string AddStuff() {
  580.             int n,n2,n3,n4,n5;
  581.             n = n2 = n3 = n4 = n5 = 0;
  582.             List<Floater> floaterList = new List<Floater>();
  583.             Rigidbody[] rigidbodies = FindObjectsOfType<Rigidbody>();
  584.             for(int i = 0;i<rigidbodies.Length;i++) {
  585.                 if(rigidbodies[i]==null||!rigidbodies[i].gameObject.activeInHierarchy) continue;
  586.                 string currentName = rigidbodies[i].name.ToUpper().Replace(" ","");
  587.                 if(currentName.Contains("FIRETRIGGER")) continue;
  588.                 MyBlockInfo myBlockInfo = rigidbodies[i].GetComponent<MyBlockInfo>();
  589.                 float multiplier = 1;
  590.                 if(myBlockInfo!=null) {
  591.                     if(!Water.WINTERISHERE) {
  592.                         bool cont = false;
  593.                         foreach(string blockName in RUSTY) {
  594.                             if(currentName.Contains(blockName)) {
  595.                                 cont = true;
  596.                                 break;
  597.                             }
  598.                         }
  599.                         if(cont) {
  600.                             rigidbodies[i].gameObject.AddComponent<Ruster>();
  601.                             n2++;
  602.                             continue;
  603.                         }
  604.                     }
  605.                     if(currentName=="BALLOON") {
  606.                         multiplier *= 6;
  607.                     }
  608.                     else if(currentName.Contains("WOOD")) {
  609.                         multiplier *= 3;
  610.                     }
  611.                     else if(currentName.Contains("WHEEL")||currentName.Contains("GRIP")) {
  612.                         multiplier *= 2;
  613.                     }
  614.                     else if(currentName.Contains("BOULDER")) {
  615.                         multiplier = 0;
  616.                     }
  617.                     floaterList.Add(new Floater(rigidbodies[i],rigidbodies[i].transform,rigidbodies[i].gameObject,multiplier));
  618.                 }
  619.                 else {
  620.                     if(rigidbodies[i].name.Contains("Bone")) {
  621.                         multiplier = 0;
  622.                     }
  623.                     else if(rigidbodies[i].name.ToUpper().Contains("KNIGHT")) {
  624.                         rigidbodies[i].transform.position = new Vector3(rigidbodies[i].transform.position.x,Water.waterHeight,rigidbodies[i].transform.position.z);
  625.                         multiplier *= 2;
  626.                     }
  627.                     else if(rigidbodies[i].name.ToUpper().Contains("CANON")) {
  628.                         rigidbodies[i].gameObject.AddComponent<Ruster>();
  629.                         continue;
  630.                     }
  631.                     else if(rigidbodies[i].tag=="ObjectiveObj") {
  632.                         BreakOnForce breakOnForce = rigidbodies[i].GetComponent<BreakOnForce>();
  633.                         if(breakOnForce!=null) {
  634.                             if(breakOnForce.ForsToBrack<10)
  635.                                 breakOnForce.ForsToBrack *= 2;
  636.                         }
  637.                         multiplier = 0;
  638.                     }
  639.                     floaterList.Add(new Floater(rigidbodies[i],rigidbodies[i].transform,rigidbodies[i].gameObject,multiplier));
  640.  
  641.                     if(rigidbodies[i].GetComponent<ArcherAI>()!=null) {
  642.                         rigidbodies[i].gameObject.AddComponent<DivingArchers>().SinkAmount = floaterList[floaterList.Count-1].multiplier;
  643.  
  644.                     }
  645.                     else if(rigidbodies[i].GetComponent<EnemyAISimple>()!=null) {
  646.                         rigidbodies[i].gameObject.AddComponent<SharkSoldiers>().SinkAmount = floaterList[floaterList.Count-1].multiplier/10;
  647.                     }
  648.                 }
  649.                 n++;
  650.             }
  651.             BraceCode[] braceCodes = FindObjectsOfType<BraceCode>();
  652.             for(int i = 0;i<braceCodes.Length;i++) {
  653.                 if(braceCodes[i].GetComponent<Ruster>()==null) {
  654.                     braceCodes[i].gameObject.AddComponent<Ruster>();
  655.                     n2++;
  656.                 }
  657.             }
  658.             ArrowTurret[] arrowTurrets = FindObjectsOfType<ArrowTurret>();
  659.             for(int i = 0;i<arrowTurrets.Length;i++) {
  660.                 if(arrowTurrets[i].GetComponent<UnderWaterCannon>()==null) {
  661.                     arrowTurrets[i].gameObject.AddComponent<UnderWaterCannon>().arrowTurret = arrowTurrets[i];
  662.                     n3++;
  663.                 }
  664.             }
  665.             FlamethrowerController[] flamethrowerControllers = FindObjectsOfType<FlamethrowerController>();
  666.             for(int i = 0;i<flamethrowerControllers.Length;i++) {
  667.                 if(flamethrowerControllers[i].GetComponent<UnderWaterFlamethrower>()==null) {
  668.                     flamethrowerControllers[i].gameObject.AddComponent<UnderWaterFlamethrower>().flamethrowerController = flamethrowerControllers[i];
  669.                     n4++;
  670.                 }
  671.             }
  672.             for(int j = 0;j<allFloaters.Length;j++) {
  673.                 if(allFloaters[j]==null)
  674.                     continue;
  675.                 bool unique = true;
  676.                 for(int i = 0;i<floaterList.Count;i++) {
  677.                     if(floaterList[i]==null) {
  678.                         Debug.Log(i);
  679.                         floaterList.RemoveAt(i);
  680.                         continue;
  681.                     }
  682.                     if(floaterList[i].gameObject==allFloaters[j].gameObject) {
  683.                         unique = false;
  684.                         break;
  685.                     }
  686.                 }
  687.                 if(unique) {
  688.                     floaterList.Add(allFloaters[j]);
  689.                 }
  690.                 else {
  691.                     n--;
  692.                     n5++;
  693.                 }
  694.             }
  695.             allFloaters = floaterList.ToArray();
  696.             return "Added "+n.ToString()+" Floaters (Replaced "+n5+"), "+n2.ToString()+" Rusters, "+n3.ToString()+" UnderWaterCannons, and "+n4.ToString()+" UnderWaterFlamethrowers";
  697.         }
  698.  
  699.         private bool RequestDelete = false;
  700.  
  701.         public void CallFixedUpdate(object data) {
  702.             int startFrom = ((int[])data)[0];
  703.             int endBefore = ((int[])data)[1];
  704.             int myObject = ((int[])data)[2];
  705.             while(step!=-2) {
  706.                 while(step==-1) Thread.Sleep(0);
  707.                 if(step==-2) break;
  708.                 for(int i = startFrom;i<endBefore;i++) {
  709.                     if(allFloaters[i]==null) {
  710.                         RequestDelete = true;
  711.                         continue;
  712.                     }
  713.                     if(allFloaters[i].gameObject==null) {
  714.                         RequestDelete = true;
  715.                         allFloaters[i] = null;
  716.                         continue;
  717.                     }
  718.                     allFloaters[i].FixedUpdate();
  719.                 }
  720.                 locks[myObject] = false;
  721.                 while(step>-1) Thread.Sleep(0);
  722.             }
  723.         }
  724.  
  725.         public static bool UseThreads = Configuration.GetBool("UseThreads",false);
  726.         private bool[] locks = new bool[0];
  727.         private int step = 0;
  728.         public void FixedUpdate() {
  729.             if(AddPiece.isSimulating) {
  730.                 if(UseThreads) {
  731.                     if(!isSimulating) {
  732.                         //ModConsole.AddMessage(LogType.Assert,("Started all this stuff"));
  733.                         isSimulating = true;
  734.                         if(countAddedOnSimulate) {
  735.                             ModConsole.AddMessage(LogType.Assert,AddStuff());
  736.                         }
  737.                         else {
  738.                             AddStuff();
  739.                         }
  740.                         step = -1;
  741.                         //ModConsole.AddMessage(LogType.Assert,("Added stuff"));
  742.                         int numberOfThreads = 4;//Environment.ProcessorCount;
  743.                         locks = new bool[numberOfThreads];
  744.                         threads = new Thread[numberOfThreads];
  745.                         arguments = new object[numberOfThreads];
  746.                         int inEachThread = allFloaters.Length/numberOfThreads;
  747.                         for(int i = 1;i<numberOfThreads;i++) {
  748.                             threads[i] = new Thread(CallFixedUpdate);
  749.                             arguments[i] = new int[] { inEachThread*(i-1),inEachThread*i, i };
  750.                             threads[i].Start(arguments[i]);
  751.                         }
  752.                         threads[0] = new Thread(CallFixedUpdate);
  753.                         arguments[0] = new int[] { inEachThread*(numberOfThreads-1),allFloaters.Length, 0 };
  754.                         threads[0].Start(arguments[0]);
  755.                         //ModConsole.AddMessage(LogType.Assert,("Created threads"));
  756.                     }
  757.                     else {
  758.                         if(threads==null) {
  759.                             return;
  760.                         }
  761.                         for(int i = 0;i<locks.Length;i++) {
  762.                             locks[i] = true;
  763.                         }
  764.                         step = threads.Length-1;
  765.                         while(step>-1) {
  766.                             while(locks[step]) Thread.Sleep(0);
  767.                             step--;
  768.                         }
  769.                         step = 0;
  770.                         if(allFloaters!=null) {
  771.                             if(RequestDelete) {
  772.                                 List<Floater> tempList = new List<Floater>();
  773.                                 RequestDelete = false;
  774.                                 for(int i = 0;i<allFloaters.Length;i++) {
  775.                                     if(allFloaters[i]==null)
  776.                                         continue;
  777.                                     if(allFloaters[i].gameObject==null)
  778.                                         continue;
  779.                                     tempList.Add(allFloaters[i]);
  780.                                 }
  781.                                 allFloaters = tempList.ToArray();
  782.                             }
  783.                         }
  784.                     }
  785.                 }
  786.                 else {
  787.                     if(!isSimulating) {
  788.                         isSimulating = true;
  789.                         if(countAddedOnSimulate) {
  790.                             ModConsole.AddMessage(LogType.Assert,AddStuff());
  791.                         }
  792.                         else {
  793.                             AddStuff();
  794.                         }
  795.                     }
  796.                     else {
  797.                         for(int i = 0;i<allFloaters.Length;i++) {
  798.                             if(allFloaters[i]!=null) {
  799.                                 if(allFloaters[i].gameObject==null) {
  800.                                     allFloaters[i] = null;
  801.                                 }
  802.                                 else {
  803.                                     allFloaters[i].FixedUpdate();
  804.                                 }
  805.                             }
  806.                         }
  807.                     }
  808.                 }
  809.             }
  810.             else {
  811.                 if(isSimulating) {
  812.                     step = -2;
  813.                     RequestDelete = false;
  814.                     isSimulating = false;
  815.                     allFloaters = new Floater[0];
  816.                     threads = new Thread[0];
  817.                     arguments = new object[0];
  818.                     locks = new bool[0];
  819.                 }
  820.             }
  821.         }
  822.  
  823.         public void OnDestroy() {
  824.             step = -1;
  825.             Thread.Sleep(0);
  826.         }
  827.     }
  828.  
  829.     public class Floater {
  830.         public static float gravity = spaar.ModLoader.Configuration.GetFloat("FloaterGravity",32.81f);
  831.  
  832.         public GameObject gameObject;
  833.         public Transform transform;
  834.         Rigidbody rigidBody;
  835.         FireTag fireTag;
  836.  
  837.         public float originalDrag = 0;
  838.         public float currentDrag = 0;
  839.  
  840.         public float originalAngularDrag = 0;
  841.         public float currentAngularDrag = 0;
  842.  
  843.         public float originalMass = 1;
  844.  
  845.         public float multiplier = 1;
  846.  
  847.         public Floater(Rigidbody rigidbody,Transform transform,GameObject gameObject,float multiplier) {
  848.             rigidBody = rigidbody;
  849.             this.gameObject = gameObject;
  850.             this.transform = transform;
  851.             this.multiplier = gravity*multiplier;
  852.  
  853.  
  854.  
  855.             originalDrag = rigidBody.drag;
  856.             currentDrag = originalDrag;
  857.  
  858.             originalAngularDrag = rigidBody.angularDrag;
  859.             currentAngularDrag = originalAngularDrag;
  860.  
  861.             originalMass = rigidBody.mass;
  862.  
  863.             fireTag = gameObject.GetComponent<FireTag>();
  864.  
  865.         }
  866.  
  867.         bool above = true;
  868.         bool isKinematic = false;
  869.  
  870.  
  871.         public void FixedUpdate() {
  872.             if(hasHadException)
  873.                 return;
  874.             try {
  875.                 if(AddPiece.isSimulating) {
  876.                     if(fireTag!=null) {
  877.                         if(transform.position.y<=Water.waterHeight+0.1f) {
  878.                             if(fireTag.fireControllerCode!=null) {
  879.                                 fireTag.fireControllerCode.DouseFire();
  880.                                 fireTag = null;
  881.                             }
  882.                         }
  883.                     }
  884.  
  885.                     if(transform.position.y<Water.waterHeight-0.2f) {
  886.                         if(Water.WINTERISHERE) {
  887.                             if(!rigidBody.isKinematic) {
  888.                                 rigidBody.isKinematic = true;
  889.                                 isKinematic = true;
  890.                                 return;
  891.                             }
  892.                         }
  893.                         if(currentDrag!=rigidBody.drag||currentDrag==originalDrag) {
  894.                             originalDrag = rigidBody.drag;
  895.                             rigidBody.drag += Water.dragPlus;
  896.                             rigidBody.drag *= Water.dragMult;
  897.                             currentDrag = rigidBody.drag;
  898.                         }
  899.                         if(currentAngularDrag!=rigidBody.angularDrag||currentAngularDrag==originalAngularDrag) {
  900.                             originalAngularDrag = rigidBody.angularDrag;
  901.                             rigidBody.angularDrag += 1f;
  902.                             rigidBody.angularDrag *= 3;
  903.                             currentAngularDrag = rigidBody.angularDrag;
  904.                         }
  905.                         if(above) {
  906.                             above = false;
  907.                             if(Water.useMassChange) {
  908.                                 originalMass = rigidBody.mass;
  909.                                 rigidBody.mass *= Water.massMultiplier;
  910.                                 if(!rigidBody.isKinematic) {
  911.                                     rigidBody.velocity -= rigidBody.velocity/10;
  912.                                     rigidBody.velocity /= Water.massMultiplier;
  913.                                 }
  914.                             }
  915.                             else if(!rigidBody.isKinematic) {
  916.                                 rigidBody.velocity -= rigidBody.velocity.y*Vector3.up;
  917.                             }
  918.                         }
  919.                         rigidBody.AddForce(Vector3.up*multiplier*Water.waterForce*Time.fixedDeltaTime,ForceMode.Acceleration);
  920.                     }
  921.                     else if(transform.position.y>Water.waterHeight+0.2f) {
  922.                         if(Water.WINTERISHERE&&isKinematic) {
  923.                             isKinematic = false;
  924.                             rigidBody.isKinematic = false;
  925.                         }
  926.                         if(!above) {
  927.                             above = true;
  928.                             if(Water.useMassChange) {
  929.                                 rigidBody.mass = originalMass;
  930.                                 if(!rigidBody.isKinematic) {
  931.                                     rigidBody.velocity -= rigidBody.velocity/10;
  932.                                     rigidBody.velocity *= Water.massMultiplier;
  933.                                 }
  934.                             }
  935.                             else if(!rigidBody.isKinematic) {
  936.                                 rigidBody.velocity -= rigidBody.velocity.y*Vector3.up;
  937.                             }
  938.                             rigidBody.drag = originalDrag;
  939.                             currentDrag = originalDrag;
  940.                             rigidBody.angularDrag = originalAngularDrag;
  941.                             currentAngularDrag = originalAngularDrag;
  942.                         }
  943.                     }
  944.                     else if(multiplier>0) {
  945.                         if(currentDrag!=rigidBody.drag||currentDrag==originalDrag) {
  946.                             originalDrag = rigidBody.drag;
  947.                             rigidBody.drag += Water.dragPlus;
  948.                             rigidBody.drag *= Water.dragMult;
  949.                             currentDrag = rigidBody.drag;
  950.                         }
  951.                         if(currentAngularDrag!=rigidBody.angularDrag||currentAngularDrag==originalAngularDrag) {
  952.                             originalAngularDrag = rigidBody.angularDrag;
  953.                             rigidBody.angularDrag += 1f;
  954.                             rigidBody.angularDrag *= 3;
  955.                             currentAngularDrag = rigidBody.angularDrag;
  956.                         }
  957.                         if(above) {
  958.                             above = false;
  959.                             if(Water.useMassChange) {
  960.                                 originalMass = rigidBody.mass;
  961.                                 rigidBody.mass *= Water.massMultiplier;
  962.                                 if(!rigidBody.isKinematic) {
  963.                                     rigidBody.velocity -= rigidBody.velocity/10;
  964.                                     rigidBody.velocity /= Water.massMultiplier;
  965.                                 }
  966.                             }
  967.                             else if(!rigidBody.isKinematic) {
  968.                                 rigidBody.velocity -= rigidBody.velocity.y*Vector3.up;
  969.                             }
  970.                         }
  971.                         Vector3 forceToAdd = -Physics.gravity + (new Vector3(-rigidBody.angularVelocity.z,0,rigidBody.angularVelocity.x))*Water.rotForce;
  972.  
  973.                         if(Water.addRandomTorque) {
  974.                             int r = UnityEngine.Random.Range((int)0,(int)100);
  975.                             if(r==0) {
  976.                                 rigidBody.AddTorque(Vector3.right,ForceMode.VelocityChange);
  977.                             }
  978.                             else if(r==1) {
  979.                                 rigidBody.AddTorque(-Vector3.right,ForceMode.VelocityChange);
  980.                             }
  981.                             else if(r==2) {
  982.                                 rigidBody.AddTorque(Vector3.up,ForceMode.VelocityChange);
  983.                             }
  984.                             else if(r==3) {
  985.                                 rigidBody.AddTorque(-Vector3.up,ForceMode.VelocityChange);
  986.                             }
  987.                             else if(r==4) {
  988.                                 rigidBody.AddTorque(Vector3.forward,ForceMode.VelocityChange);
  989.                             }
  990.                             else if(r==5) {
  991.                                 rigidBody.AddTorque(-Vector3.forward,ForceMode.VelocityChange);
  992.                             }
  993.                         }
  994.  
  995.                         rigidBody.AddForce(forceToAdd,ForceMode.Acceleration);
  996.                     }
  997.                 }
  998.             }
  999.             catch(Exception e) {
  1000.                 hasHadException = true;
  1001.                 ModConsole.AddMessage(LogType.Exception,gameObject.name+": "+e.ToString());
  1002.             }
  1003.         }
  1004.         bool hasHadException = false;
  1005.     }
  1006.  
  1007.     public class Ruster : MonoBehaviour {
  1008.         public float Rusty = 1;
  1009.         public float originalMass = 1;
  1010.         bool aboveWater = true;
  1011.         Color[] originalColors;
  1012.         Material[] materials;
  1013.         Rigidbody rigidBody;
  1014.         public float maxRust = 8;
  1015.  
  1016.         public float originalDrag = 0;
  1017.         public float currentDrag = 0;
  1018.  
  1019.         public float originalAngularDrag = 0;
  1020.         public float currentAngularDrag = 0;
  1021.  
  1022.         public void Start() {
  1023.             Renderer[] Renderers = GetComponentsInChildren<Renderer>();
  1024.             List<Material> M = new List<Material>();
  1025.             List<Color> C = new List<Color>();
  1026.             foreach(Renderer r in Renderers) {
  1027.                 if(r.material!=null) {
  1028.                     M.Add(r.material);
  1029.                     C.Add(r.material.color);
  1030.                 }
  1031.             }
  1032.             originalColors = C.ToArray();
  1033.             materials = M.ToArray();
  1034.             rigidBody = transform.GetComponent<Rigidbody>();
  1035.             maxRust += UnityEngine.Random.Range(-0.3f,0.3f);
  1036.         }
  1037.  
  1038.         public void FixedUpdate() {
  1039.             if(AddPiece.isSimulating) {
  1040.                 if(!Water.useRusting)
  1041.                     Rusty = -1;
  1042.                 if(transform.position.y>Water.waterHeight) {
  1043.                     if(Rusty>0) {
  1044.                         Rusty -= Time.fixedDeltaTime*0.1f;
  1045.                     }
  1046.                     if(rigidBody!=null) {
  1047.                         if(!aboveWater) {
  1048.                             aboveWater = true;
  1049.                             if(!Water.useMassChange) {
  1050.                                 rigidBody.mass = originalMass;
  1051.                                 if(!rigidBody.isKinematic) {
  1052.                                     rigidBody.velocity -= rigidBody.velocity/10;
  1053.                                     rigidBody.velocity *= Water.massMultiplier;
  1054.                                 }
  1055.                             }
  1056.                             else if(!rigidBody.isKinematic) {
  1057.                                 rigidBody.velocity -= rigidBody.velocity.y*Vector3.up;
  1058.                             }
  1059.                             rigidBody.drag = originalDrag;
  1060.                             currentDrag = originalDrag;
  1061.                             rigidBody.angularDrag = originalAngularDrag;
  1062.                             currentAngularDrag = originalAngularDrag;
  1063.                         }
  1064.                     }
  1065.                 }
  1066.                 else {
  1067.                     Rusty += Time.fixedDeltaTime;
  1068.                     if(Rusty>maxRust) {
  1069.                         if(Water.RustDestroyed<4) {
  1070.                             //                          Debug.Log(name);
  1071.                             Water.RustDestroyed++;
  1072.                             Destroy(gameObject);
  1073.                         }
  1074.                         return;
  1075.                     }
  1076.                     else if(Rusty>8) {
  1077.  
  1078.                     }
  1079.                     else if(Rusty>1) {
  1080.                         for(int i = 0;i<materials.Length;i++) {
  1081.                             materials[i].color = Color.Lerp(materials[i].color,new Color(0.5f*(Rusty-1)/4,(Rusty-1)/20,0),Time.fixedDeltaTime);
  1082.                         }
  1083.                     }
  1084.                     else {
  1085.                         for(int i = 0;i<materials.Length;i++) {
  1086.                             materials[i].color = Color.Lerp(materials[i].color,originalColors[i],Time.fixedDeltaTime);
  1087.                         }
  1088.                     }
  1089.                     if(rigidBody!=null) {
  1090.                         if(currentDrag!=rigidBody.drag||currentDrag==originalDrag) {
  1091.                             originalDrag = rigidBody.drag;
  1092.                             rigidBody.drag += Water.dragPlus;
  1093.                             rigidBody.drag *= Water.dragMult;
  1094.                             currentDrag = rigidBody.drag;
  1095.                         }
  1096.                         if(currentAngularDrag!=rigidBody.angularDrag||currentAngularDrag==originalAngularDrag) {
  1097.                             originalAngularDrag = rigidBody.angularDrag;
  1098.                             rigidBody.angularDrag += 1f;
  1099.                             rigidBody.angularDrag *= 3;
  1100.                             currentAngularDrag = rigidBody.angularDrag;
  1101.                         }
  1102.                         if(aboveWater) {
  1103.                             aboveWater = false;
  1104.                             if(Water.useMassChange) {
  1105.                                 originalMass = rigidBody.mass;
  1106.                                 rigidBody.mass *= Water.massMultiplier;
  1107.                                 if(!rigidBody.isKinematic) {
  1108.                                     rigidBody.velocity -= rigidBody.velocity/10;
  1109.                                     rigidBody.velocity /= Water.massMultiplier;
  1110.                                 }
  1111.                             }
  1112.                             else if(!rigidBody.isKinematic) {
  1113.                                 rigidBody.velocity -= rigidBody.velocity.y*Vector3.up;
  1114.                             }
  1115.                         }
  1116.                     }
  1117.                 }
  1118.             }
  1119.             else {
  1120.                 Destroy(this);
  1121.             }
  1122.         }
  1123.  
  1124.     }
  1125.  
  1126.     public class UnderWaterCannon : MonoBehaviour {
  1127.         int hasNotShot = 3;
  1128.         public ArrowTurret arrowTurret;
  1129.  
  1130.         public void Start() {
  1131.             //          arrowTurret = GetComponent<ArrowTurret>();
  1132.         }
  1133.  
  1134.         public void FixedUpdate() {
  1135.             if(AddPiece.isSimulating) {
  1136.                 if(arrowTurret.hasShot) {
  1137.                     if(hasNotShot==1) {
  1138.                         GameObject cannonBall = GameObject.Find("CanonBallHeavy(Clone)");
  1139.                         if(cannonBall==null)
  1140.                             return;
  1141.                         hasNotShot=0;
  1142.                         cannonBall.name = "CanonBallHeavyParsed";
  1143.                         cannonBall.AddComponent<Ruster>();
  1144.                     }
  1145.                     else {
  1146.                         hasNotShot--;
  1147.                     }
  1148.                 }
  1149.                 else {
  1150.                     hasNotShot = 3;
  1151.                 }
  1152.             }
  1153.             else {
  1154.                 Destroy(this);
  1155.             }
  1156.         }
  1157.     }
  1158.  
  1159.     public class UnderWaterFlamethrower : MonoBehaviour {
  1160.         float flameUsed = 0;
  1161.         bool underWater = true;
  1162.         public FlamethrowerController flamethrowerController;
  1163.  
  1164.         public void FixedUpdate() {
  1165.             flamethrowerController.timeOut = false;
  1166.             if(Water.waterHeight<transform.position.y) {
  1167.                 if(underWater) {
  1168.                     flamethrowerController.timey = flameUsed;
  1169.                     underWater = false;
  1170.                 }
  1171.                 flameUsed = flamethrowerController.timey;
  1172.             }
  1173.             else {
  1174.                 flamethrowerController.timey = 100;
  1175.                 underWater = true;
  1176.             }
  1177.  
  1178.         }
  1179.     }
  1180.  
  1181.     public class WaterPlane : MonoBehaviour {
  1182.         float speed = spaar.ModLoader.Configuration.GetFloat("WaterMovementSpeed",4);
  1183.         public static float waterAlpha = spaar.ModLoader.Configuration.GetFloat("WaterAlpha",0.9f);
  1184.         static Renderer renderer;
  1185.  
  1186.         static bool hasAskedAboutWaterPlane = spaar.ModLoader.Configuration.GetBool("HasAskedAboutWaterPlane",false);
  1187.         static bool useOtherGraphicsForWater = spaar.ModLoader.Configuration.GetBool("UseOtherGraphicsForWater",false);
  1188.         static bool changeShaderOfLegacies = spaar.ModLoader.Configuration.GetBool("ChangeShaderOfLegacies",true);
  1189.         static float waveHeight = spaar.ModLoader.Configuration.GetFloat("WaveHeight",0.2f);
  1190.         static bool moreWater = spaar.ModLoader.Configuration.GetBool("More Water",false);
  1191.         static int moreWaterRoot = spaar.ModLoader.Configuration.GetInt("More Water Root",2);
  1192.         static float fancyWaterSizeX = spaar.ModLoader.Configuration.GetFloat("FancyWaterSizeX",5);
  1193.         static float fancyWaterSizeZ = spaar.ModLoader.Configuration.GetFloat("FancyWaterSizeZ",5);
  1194.  
  1195.         static Transform myTransform;
  1196.  
  1197.         public void Start() {
  1198.             myTransform = transform;
  1199.             if(changeShaderOfLegacies) {
  1200.                 MeshRenderer[] allMeshRenderers = FindObjectsOfType<MeshRenderer>();
  1201.                 for(int i = 0;i<allMeshRenderers.Length;i++) {
  1202.                     for(int j = 0;j<allMeshRenderers[i].materials.Length;j++) {
  1203.                         string myName = allMeshRenderers[i].materials[j].shader.ToString();
  1204.                         if((myName.Contains("Transparent/Cutout/Diffuse")||myName.Contains("Transparent/VertexLit")||myName.Contains("Transparent/Diffuse"))&&myName.Contains("Legacy")) {
  1205.                             //                          ModConsole.AddMessage(LogType.Log,"Changed shader on "+allMeshRenderers[i].name+"["+i+"]["+j+"] ("+allMeshRenderers[i].materials[j].shader.ToString()+")");
  1206.                             allMeshRenderers[i].materials[j].shader = Shader.Find("Legacy Shaders/Transparent/Cutout/VertexLit");
  1207.                         }
  1208.                         else {
  1209.                             //                          ModConsole.AddMessage(LogType.Log,"Didn't change shader on "+allMeshRenderers[i].name+"["+i+"]["+j+"] ("+allMeshRenderers[i].materials[j].shader.ToString()+")");
  1210.                         }
  1211.                     }
  1212.                 }
  1213.             }
  1214.  
  1215.             spaar.ModLoader.Commands.RegisterCommand("UseOtherGraphicsForWater",(args,nArgs) => {
  1216.                 try {
  1217.                     useOtherGraphicsForWater = bool.Parse(args[0]);
  1218.                 }
  1219.                 catch {
  1220.                     return "UseOtherGraphicsForWater is "+useOtherGraphicsForWater.ToString();
  1221.                 }
  1222.                 Destroy(fancyWaterChild);
  1223.                 StartCoroutine(SwitchGraphics());
  1224.                 return "Set UseOtherGraphicsForWater to "+useOtherGraphicsForWater.ToString();
  1225.             },"Changes whether or not \"Water.unity3d.dll\" is used");
  1226.  
  1227.             spaar.ModLoader.Commands.RegisterCommand("ChangeShaderOfLegacies",(args,nArgs) => {
  1228.                 try {
  1229.                     changeShaderOfLegacies = bool.Parse(args[0]);
  1230.                 }
  1231.                 catch {
  1232.                     return "ChangeShaderOfLegacies is "+changeShaderOfLegacies.ToString();
  1233.                 }
  1234.                 return "Set ChangeShaderOfLegacies to "+changeShaderOfLegacies.ToString()+" (This won't come into effect before you reload the level)";
  1235.             },"Changes what grass does under and over water");
  1236.  
  1237.             spaar.Commands.RegisterCommand("WaveHeight",(args,namedArgs) => {
  1238.                 try {
  1239.                     waveHeight = float.Parse(args[0]);
  1240.                 }
  1241.                 catch {
  1242.                     return "WaveHeight is "+waveHeight.ToString();
  1243.                 }
  1244.                 if(fancyWaterChild==null)
  1245.                     return "You need to turn on fancy water to do this!";
  1246.                 fancyWaterChild.transform.localScale = new Vector3(fancyWaterChild.transform.localScale.x,waveHeight,fancyWaterChild.transform.localScale.z);
  1247.  
  1248.                 return "WaveHeight was set to "+waveHeight.ToString();
  1249.             },"Changes the amplitude of the wave to [height] or tells you how high it is");
  1250.  
  1251.             spaar.ModLoader.Commands.RegisterCommand("MoreWater",(args,nArgs) => {
  1252.                 try {
  1253.                     moreWater = bool.Parse(args[0]);
  1254.                 }
  1255.                 catch {
  1256.                     return "More Water is set to "+moreWater.ToString();
  1257.                 }
  1258.                 if(fancyWaterChild==null)
  1259.                     return "You need to turn on fancy water to do this!";
  1260.                 Destroy(fancyWaterChild);
  1261.                 StartCoroutine(SwitchGraphics());
  1262.                 return "More Water was set to "+moreWater.ToString();
  1263.             },"Makes it so water looks better");
  1264.  
  1265.             spaar.Commands.RegisterCommand("MoreWaterRoot",(args,namedArgs) => {
  1266.                 try {
  1267.                     moreWaterRoot = int.Parse(args[0]);
  1268.                 }
  1269.                 catch {
  1270.                     return "MoreWaterRoot is "+moreWaterRoot.ToString();
  1271.                 }
  1272.                 if(fancyWaterChild==null)
  1273.                     return "You need to turn on fancy water to do this!";
  1274.                 Destroy(fancyWaterChild);
  1275.                 StartCoroutine(SwitchGraphics());
  1276.                 return "MoreWaterRoot was set to "+moreWaterRoot.ToString();
  1277.             },"Changes how many extra water-squares you get when using MoreWater");
  1278.  
  1279.             spaar.Commands.RegisterCommand("FancyWaterSizeX",(args,namedArgs) => {
  1280.                 try {
  1281.                     fancyWaterSizeX = float.Parse(args[0]);
  1282.                 }
  1283.                 catch {
  1284.                     return "FancyWaterSizeX is "+fancyWaterSizeX.ToString();
  1285.                 }
  1286.                 if(fancyWaterChild==null)
  1287.                     return "You need to turn on fancy water to do this!";
  1288.                 fancyWaterChild.transform.localScale = new Vector3(fancyWaterSizeX,waveHeight,fancyWaterSizeZ);
  1289.  
  1290.                 return "FancyWaterSizeX was set to "+fancyWaterSizeX.ToString();
  1291.             },"Changes FancyWaterSizeX");
  1292.  
  1293.             spaar.Commands.RegisterCommand("FancyWaterSizeZ",(args,namedArgs) => {
  1294.                 try {
  1295.                     fancyWaterSizeZ = float.Parse(args[0]);
  1296.                 }
  1297.                 catch {
  1298.                     return "FancyWaterSizeZ is "+fancyWaterSizeZ.ToString();
  1299.                 }
  1300.                 if(fancyWaterChild==null)
  1301.                     return "You need to turn on fancy water to do this!";
  1302.                 fancyWaterChild.transform.localScale = new Vector3(fancyWaterSizeX,waveHeight,fancyWaterSizeZ);
  1303.  
  1304.                 return "FancyWaterSizeZ was set to "+fancyWaterSizeZ.ToString();
  1305.             },"Changes FancyWaterSizeZ");
  1306.  
  1307.             spaar.Commands.RegisterCommand("FancyWaterType",(args,namedArgs) => {
  1308.                 if(www.assetBundle==null)
  1309.                     return "Please activate fancy water before doing this!";
  1310.                 if(args.Length<1) {
  1311.                     //                      ModConsole.AddMessage(LogType.Log,"All assetnames: ",String.Join("\n",www.assetBundle.GetAllAssetNames()));
  1312.                     //                      ModConsole.AddMessage(LogType.Log,"All assetpaths: ",String.Join("\n",www.assetBundle.GetAllScenePaths()));
  1313.                     return "All assetnames:\n"+String.Join("\n",www.assetBundle.GetAllAssetNames())+"\nCurrent name: "+assetName;
  1314.                 }
  1315.                 if(www.assetBundle.Contains(args[0])) {
  1316.                     assetName = args[0];
  1317.                     if(!useOtherGraphicsForWater)
  1318.                         return "You need to turn on fancy water to do this!";
  1319.                     if(fancyWater!=null)
  1320.                         Destroy(fancyWater);
  1321.                     if(fancyWaterChild!=null)
  1322.                         Destroy(fancyWaterChild);
  1323.                     StartCoroutine(SwitchGraphics());
  1324.                     return "Switched asset!";
  1325.                 }
  1326.                 return "The named asset could not be found!";
  1327.             },"Changes the type of water used (higher or lower quality, don't write a second argument to get a list");
  1328.  
  1329.             renderer = GetComponent<Renderer>();
  1330.             StatMaster.Bounding.roofHeight = 100;
  1331.             BoundingBoxController boundingBoxController = FindObjectOfType<BoundingBoxController>();
  1332.             if(boundingBoxController!=null)
  1333.                 boundingBoxController.roofPos.position += Vector3.up*100;
  1334.  
  1335.             renderer.material.shader = Shader.Find("Transparent/Diffuse");
  1336.             transform.localScale = new Vector3(512,0.1f,512);
  1337.             renderer.material.color = new Color(0.5f,0.5f,1f,waterAlpha);
  1338.             gameObject.name = "WaterPlane";
  1339.             if(!Water.WINTERISHERE)
  1340.                 Destroy(GetComponent<Collider>());
  1341.             renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
  1342.             renderer.receiveShadows = true;
  1343.  
  1344.             if(File.Exists(Application.dataPath+"/Mods/Resources/Water.unity3d.dll")) {
  1345.                 if(!hasAskedAboutWaterPlane) {
  1346.                     showGUI = true;
  1347.                 }
  1348.                 else {
  1349.                     StartCoroutine(SwitchGraphics());
  1350.                 }
  1351.             }
  1352.         }
  1353.  
  1354.         public void Update() {
  1355.  
  1356.             if(!Water.useWaterPlane)
  1357.                 Destroy(gameObject);
  1358.             if(Water.waterHeight>transform.position.y) {
  1359.                 transform.position += Vector3.up*speed*Time.deltaTime;
  1360.                 if(Water.waterHeight<transform.position.y) {
  1361.                     transform.position = new Vector3(0,Water.waterHeight,0);
  1362.                 }
  1363.             }
  1364.             else if(Water.waterHeight<transform.position.y) {
  1365.                 transform.position -= Vector3.up*speed*Time.deltaTime;
  1366.                 if(Water.waterHeight>transform.position.y) {
  1367.                     transform.position = new Vector3(0,Water.waterHeight,0);
  1368.                 }
  1369.             }
  1370.         }
  1371.  
  1372.  
  1373.  
  1374.         int windowID = Util.GetWindowID();
  1375.         Rect windowRect = new Rect(Screen.width/2-175,Screen.height/2-110,350,220);
  1376.         bool showGUI = false;
  1377.  
  1378.         void OnGUI() {
  1379.             if(showGUI) {
  1380.                 GUI.skin = spaar.ModLoader.UI.ModGUI.Skin;
  1381.                 GUI.skin.GetStyle("Label").alignment = TextAnchor.UpperCenter;
  1382.                 windowRect = GUI.Window(windowID,windowRect,DoWindow,"WARNING - DECIDE WISELY");
  1383.             }
  1384.         }
  1385.  
  1386.         void DoWindow(int id) {
  1387.             GUILayout.Label("Water.unity3d.dll was detected!");
  1388.             GUILayout.Label("Do you wish to use this instead?");
  1389.             GUILayout.Label("You can change this at a later");
  1390.             GUILayout.Label("point of time if you type");
  1391.             GUILayout.Label("\"UseOtherGraphicsForWater true\"");
  1392.             GUILayout.Label("or");
  1393.             GUILayout.Label("\"UseOtherGraphicsForWater false\"");
  1394.             GUILayout.Label("into the console");
  1395.             GUILayout.BeginHorizontal();
  1396.             if(GUILayout.Button("YES! OF COURSE!")) {
  1397.                 hasAskedAboutWaterPlane = true;
  1398.                 useOtherGraphicsForWater = true;
  1399.                 showGUI = false;
  1400.                 StartCoroutine(SwitchGraphics());
  1401.             }
  1402.             if(GUILayout.Button("NO! NEVER! >:[")) {
  1403.                 hasAskedAboutWaterPlane = true;
  1404.                 useOtherGraphicsForWater = false;
  1405.                 showGUI = false;
  1406.                 StartCoroutine(SwitchGraphics());
  1407.             }
  1408.             GUILayout.EndHorizontal();
  1409.             GUI.DragWindow();
  1410.         }
  1411.  
  1412.         public void OnDestroy() {
  1413.             spaar.ModLoader.Configuration.SetInt("More Water Root",moreWaterRoot);
  1414.             spaar.ModLoader.Configuration.SetFloat("WaveHeight",waveHeight);
  1415.             spaar.ModLoader.Configuration.SetBool("More Water",moreWater);
  1416.             spaar.ModLoader.Configuration.SetBool("HasAskedAboutWaterPlane",hasAskedAboutWaterPlane);
  1417.             spaar.ModLoader.Configuration.SetBool("UseOtherGraphicsForWater",useOtherGraphicsForWater);
  1418.             spaar.ModLoader.Configuration.SetFloat("WaterMovementSpeed",speed);
  1419.             spaar.ModLoader.Configuration.SetFloat("WaterAlpha",waterAlpha);
  1420.             spaar.ModLoader.Configuration.SetBool("ChangeShaderOfLegacies",changeShaderOfLegacies);
  1421.             spaar.ModLoader.Configuration.SetFloat("FancyWaterSizeX",fancyWaterSizeX);
  1422.             spaar.ModLoader.Configuration.SetFloat("FancyWaterSizeZ",fancyWaterSizeZ);
  1423.             spaar.ModLoader.Configuration.SetString("AssetName",assetName);
  1424.             spaar.ModLoader.Configuration.Save();
  1425.         }
  1426.  
  1427.         static string assetName = spaar.ModLoader.Configuration.GetString("AssetName","water4example (advanced)");
  1428.         public static IEnumerator SwitchGraphics() {
  1429.             if(useOtherGraphicsForWater) {
  1430.                 if(www==null) {
  1431.                     www = new WWW("file:///"+Application.dataPath+"/Mods/Resources/Water.unity3d.dll");
  1432.                     yield return www;
  1433.                 }
  1434.                 if(fancyWater==null) {
  1435.                     if(string.IsNullOrEmpty(www.error)) {
  1436.                         //                      ModConsole.AddMessage(LogType.Log,"All assetnames: ",String.Join("\n",www.assetBundle.GetAllAssetNames()));
  1437.                         //                      ModConsole.AddMessage(LogType.Log,"All assetpaths: ",String.Join("\n",www.assetBundle.GetAllScenePaths()));
  1438.                         fancyWater = www.assetBundle.LoadAsset("water4example (advanced)",typeof(GameObject));//assetName);
  1439.                         if(fancyWater==null) {
  1440.                             ModConsole.AddMessage(LogType.Error,"Loaded water, but it's null :/");
  1441.                             yield break;
  1442.                         }
  1443.                         Debug.Log(fancyWater.GetType()+"\n"+fancyWater.ToString());
  1444.                     }
  1445.                     else {
  1446.                         ModConsole.AddMessage(LogType.Error,"Error when loading Water",www.error);
  1447.                         yield break;
  1448.                     }
  1449.                 }
  1450.                 try {
  1451.                     fancyWaterChild = (GameObject)Instantiate(fancyWater);
  1452.                 }
  1453.                 catch(Exception e) {
  1454.                     Debug.LogError("Error: "+e+"\n"+fancyWater.GetType().ToString()+'\n'+fancyWater.ToString());
  1455.                     yield break;
  1456.                 }
  1457.                 if(fancyWaterChild==null) {
  1458.                     ModConsole.AddMessage(LogType.Error,"Instantiated water, but it's null :/");
  1459.                     yield break;
  1460.                 }
  1461.                 myTransform.localScale = Vector3.one;
  1462.                 fancyWaterChild.transform.localScale = new Vector3(fancyWaterSizeX,waveHeight,fancyWaterSizeZ);
  1463.                 fancyWaterChild.transform.parent = myTransform;
  1464.                 fancyWaterChild.transform.localPosition = Vector3.zero;
  1465.                 renderer.enabled = false;
  1466.  
  1467.                 if(moreWater) {
  1468.                     for(int x = -moreWaterRoot;x<=moreWaterRoot;x++) {
  1469.                         for(int z = -moreWaterRoot;z<=moreWaterRoot;z++) {
  1470.                             if(x==0&&z==0)
  1471.                                 continue;
  1472.                             GameObject tempWater = (GameObject)Instantiate(fancyWater);
  1473.                             tempWater.transform.parent = fancyWaterChild.transform;
  1474.                             tempWater.transform.localScale = Vector3.one;
  1475.                             tempWater.transform.position = new Vector3(x*250,fancyWaterChild.transform.position.y,z*250);
  1476.                             tempWater.GetComponentInChildren<Renderer>().material.color = Color.green;
  1477.                         }
  1478.                     }
  1479.                 }
  1480.             }
  1481.             else {
  1482.                 myTransform.localScale = new Vector3(512,0.1f,512);
  1483.                 renderer.enabled = true;
  1484.             }
  1485.             yield break;
  1486.         }
  1487.  
  1488.         static WWW www;
  1489.         static UnityEngine.Object fancyWater;
  1490.         static GameObject fancyWaterChild;
  1491.     }
  1492.  
  1493.     public class DivingArchers : MonoBehaviour {
  1494.         ArcherAI archerAI;
  1495.         EnemyAISimple enemyAISimple;
  1496.         BleedOnJointBreak bleedOnJointBreak;
  1497.         Rigidbody rigidBody;
  1498.         public float SinkAmount = 0;
  1499.         Machine machine;
  1500.  
  1501.         public void Start() {
  1502.             if(!Water.useDivingArchers)
  1503.                 Destroy(this);
  1504.             machine = Machine.Active();
  1505.             archerAI = GetComponent<ArcherAI>();
  1506.             archerAI.maxRange = 1;
  1507.             enemyAISimple = GetComponent<EnemyAISimple>();
  1508.             rigidBody = GetComponent<Rigidbody>();
  1509.             bleedOnJointBreak = GetComponent<BleedOnJointBreak>();
  1510.             if(bleedOnJointBreak!=null) {
  1511.                 bleedOnJointBreak.deathThreshold = 400;
  1512.             }
  1513.         }
  1514.  
  1515.         public void FixedUpdate() {
  1516.             if((machine.MiddlePosition-transform.position).magnitude<5) {
  1517.                 rigidBody.AddForce(Vector3.down*SinkAmount*Water.waterForce,ForceMode.Acceleration);
  1518.             }
  1519.         }
  1520.  
  1521.     }
  1522.  
  1523.     public class SharkSoldiers : MonoBehaviour {
  1524.         EnemyAISimple enemyAISimple;
  1525.         BleedOnJointBreak bleedOnJointBreak;
  1526.         Rigidbody rigidBody;
  1527.         SetPoseOnDisrens setPoseOnDisrens;
  1528.         public float SinkAmount = 0;
  1529.         public bool JetJak = false;
  1530.  
  1531.         public void Start() {
  1532.             if(name.ToLower().Contains("cow")) {
  1533.                 JetJak = true;
  1534.                 if(!Water.useJetJaks)
  1535.                     Destroy(this);
  1536.             }
  1537.             else if(!Water.useSharkSoldiers) {
  1538.                 Destroy(this);
  1539.             }
  1540.             //          Debug.Log(name);
  1541.             enemyAISimple = GetComponent<EnemyAISimple>();
  1542.             rigidBody = GetComponent<Rigidbody>();
  1543.             bleedOnJointBreak = GetComponent<BleedOnJointBreak>();
  1544.             setPoseOnDisrens = GetComponent<SetPoseOnDisrens>();
  1545.             if(bleedOnJointBreak!=null) {
  1546.                 bleedOnJointBreak.deathThreshold = 400;
  1547.             }
  1548.  
  1549.             if(Water.boatMesh!=null&&Water.useBoats) {
  1550.                 MeshFilter[] meshFilters = GetComponentsInChildren<MeshFilter>();
  1551.                 for(int i = 0;i<meshFilters.Length;i++) {
  1552.                     meshFilters[i].mesh = Water.boatMesh;
  1553.                     meshFilters[i].GetComponent<MeshRenderer>().material = Water.boatMaterial;
  1554.                 }
  1555.                 if(setPoseOnDisrens!=null) {
  1556.                     for(int i = 0;i<setPoseOnDisrens.Pos2.Length;i++)
  1557.                         setPoseOnDisrens.Pos2[i] = Water.boatMesh;
  1558.                 }
  1559.             }
  1560.  
  1561.  
  1562.         }
  1563.  
  1564.         public float speed = 400;
  1565.  
  1566.         public void FixedUpdate() {
  1567.             if(!AddPiece.isSimulating)
  1568.                 Destroy(this);
  1569.             if(transform.position.y>Water.waterHeight+1)
  1570.                 return;
  1571.             if(enemyAISimple.runAway) {
  1572.                 if(enemyAISimple.isRunningAway) {
  1573.                     if(enemyAISimple.runAwaySpeed<=0) {
  1574.                         Vector3 forceToAdd = Vector3.down*SinkAmount*Water.waterForce;
  1575.                         if(enemyAISimple.goal!=null)
  1576.                             forceToAdd += transform.forward*speed;
  1577.                         rigidBody.AddForce(forceToAdd,ForceMode.Acceleration);
  1578.                     }
  1579.                     else {
  1580.                         if(enemyAISimple.runVec!=null) {
  1581.                             if(new Vector3(enemyAISimple.runVec.x,0,enemyAISimple.runVec.z).sqrMagnitude<32) {
  1582.                                 Vector3 forceToAdd = (enemyAISimple.runVec).normalized*speed;
  1583.                                 if(JetJak)
  1584.                                     forceToAdd += (enemyAISimple.runVec).normalized*speed*4;
  1585.                                 rigidBody.AddForce(forceToAdd,ForceMode.Acceleration);
  1586.                             }
  1587.                             else if(transform.position.y>Water.waterHeight-5&&transform.position.y>2) {
  1588.                                 Vector3 forceToAdd = transform.forward*speed*2 + Vector3.down*SinkAmount*Water.waterForce;
  1589.  
  1590.                                 if(JetJak)
  1591.                                     forceToAdd += transform.forward*speed*4;
  1592.                                 rigidBody.AddForce(forceToAdd,ForceMode.Acceleration);
  1593.                             }
  1594.                         }
  1595.                         else if(transform.position.y>Water.waterHeight-5&&transform.position.y>2) {
  1596.                             Vector3 forceToAdd = transform.forward*speed*2 + Vector3.down*SinkAmount*Water.waterForce;
  1597.                             if(JetJak)
  1598.                                 forceToAdd += transform.forward*speed*4;
  1599.                             rigidBody.AddForce(forceToAdd,ForceMode.Acceleration);
  1600.                         }
  1601.                     }
  1602.                 }
  1603.             }
  1604.         }
  1605.     }
  1606.  
  1607.  
  1608. }
RAW Paste Data
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
 
Top