Exemple #1
0
		private void Fire()
		{
			if(BDArmorySettings.GameIsPaused)
			{
				if(audioSource.isPlaying)
				{
					audioSource.Stop();	
				}
				return;
			}

			float timeGap = (60/roundsPerMinute) * TimeWarp.CurrentRate;
			
			if(Time.time-timeFired > timeGap && !isOverheated && !pointingAtSelf)
			{
				bool effectsShot = false;
				//Transform[] fireTransforms = part.FindModelTransforms("fireTransform");
				for(int i = 0; i < fireTransforms.Length; i++)
				{
					if(!Misc.CheckMouseIsOnGui() && WMgrAuthorized() && (BDArmorySettings.INFINITE_AMMO || part.RequestResource(ammoName, requestResourceAmount)>0))
					{
						Transform fireTransform = fireTransforms[i];
						spinningDown = false;

						//recoil
						if(hasRecoil)
						{
							gameObject.rigidbody.AddForceAtPosition((-fireTransform.forward) * (bulletVelocity*bulletMass), fireTransform.position, ForceMode.Impulse);
						}
						
						if(!effectsShot)
						{
							//sound
							if(oneShotSound)
							{
								audioSource.Stop();
								audioSource.PlayOneShot(fireSound);
							}
							else
							{
								wasFiring = true;
								if(!audioSource.isPlaying)
								{
									audioSource.clip = fireSound;
									audioSource.loop = false;
									audioSource.time = 0;
									audioSource.Play();	
								}
								else
								{
									if (audioSource.time >= fireSound.length)
									{
										audioSource.time = soundRepeatTime;	
									}
								}
							}

							//animation
							if(hasFireAnimation)
							{
								float unclampedSpeed = (roundsPerMinute*fireState.length)/60;
								fireAnimSpeed = Mathf.Clamp (unclampedSpeed, 1, 20);
								fireState.enabled = true;
								if(unclampedSpeed == fireAnimSpeed)
								{
									fireState.normalizedTime = 0;
								}
								fireState.speed = fireAnimSpeed;
								fireState.normalizedTime = Mathf.Repeat(fireState.normalizedTime, 1);
							}
							
							//muzzle flash

							foreach(Transform mtf in part.FindModelTransforms("muzzleTransform"))
							{
								KSPParticleEmitter pEmitter = mtf.gameObject.GetComponent<KSPParticleEmitter>();
								if(!pEmitter.useWorldSpace || oneShotWorldParticles)
								{
									pEmitter.Emit();
								}
							}

							foreach(var gpe in gaplessEmitters)
							{
								gpe.EmitParticles();	
							}
							
							//shell ejection
							if(BDArmorySettings.EJECT_SHELLS)
							{
								for(int e = 0; e < shellEjectTransforms.Length; e++)
								{
									Transform sTf = shellEjectTransforms[e];
									//GameObject ejectedShell = (GameObject) Instantiate(GameDatabase.Instance.GetModel("BDArmory/Models/shell/model"), sTf.position + (part.rb.velocity*Time.fixedDeltaTime), sTf.rotation);
									GameObject ejectedShell = shellPool.GetPooledObject();
									ejectedShell.transform.position = sTf.position;//+(part.rb.velocity*TimeWarp.fixedDeltaTime);
									ejectedShell.transform.rotation = sTf.rotation;
									ejectedShell.transform.localScale = Vector3.one * shellScale;
									ShellCasing shellComponent = ejectedShell.GetComponent<ShellCasing>();
									shellComponent.initialV = part.rb.velocity;
									ejectedShell.SetActive(true);
								}
							}
							effectsShot = true;
						}
						
						
						//firing bullet
						GameObject firedBullet = bulletPool.GetPooledObject();
						PooledBullet pBullet = firedBullet.GetComponent<PooledBullet>();
						firedBullet.transform.position = fireTransform.position;

						pBullet.mass = bulletMass;
                        pBullet.ballisticCoefficient = bulletBallisticCoefficient;
                        pBullet.flightTimeElapsed = 0;

						timeFired = Time.time;
						
						//Vector3 firedVelocity = fireTransform.rotation * new Vector3(randomZ,randomY,bulletVelocity).normalized * bulletVelocity;
						Vector3 firedVelocity = VectorUtils.WeightedDirectionDeviation(fireTransform.forward, maxDeviation) * bulletVelocity;
					

						//firedBullet.transform.position -= firedVelocity * Time.fixedDeltaTime;
						firedBullet.transform.position += part.rb.velocity * Time.fixedDeltaTime;
						pBullet.currentVelocity = part.rb.velocity + firedVelocity;

						pBullet.initialSpeed = bulletVelocity;
						pBullet.sourceVessel = this.vessel;
						pBullet.bulletTexturePath = bulletTexturePath;
						pBullet.projectileColor = projectileColorC;
						pBullet.startColor = startColorC;
						pBullet.fadeColor = fadeColor;

						tracerIntervalCounter++;
						if(tracerIntervalCounter > tracerInterval)
						{
							tracerIntervalCounter = 0;
							pBullet.tracerStartWidth = tracerStartWidth;
							pBullet.tracerEndWidth = tracerEndWidth;
						}
						else
						{
							pBullet.tracerStartWidth = nonTracerWidth;
							pBullet.tracerEndWidth = nonTracerWidth;
							pBullet.startColor.a *= 0.5f;
							pBullet.projectileColor.a *= 0.5f;
						}

						pBullet.tracerLength = tracerLength;
						pBullet.tracerDeltaFactor = tracerDeltaFactor;
						pBullet.tracerLuminance = tracerLuminance;

						pBullet.bulletDrop = bulletDrop;
						
						if(weaponType == "cannon")
						{
							pBullet.bulletType = PooledBullet.PooledBulletTypes.Explosive;
							pBullet.explModelPath = explModelPath;
							pBullet.explSoundPath = explSoundPath;
							pBullet.blastPower = cannonShellPower;
							pBullet.radius = cannonShellRadius;
							pBullet.airDetonation = airDetonation;
							pBullet.detonationRange = detonationRange;
						}
						else
						{
							pBullet.bulletType = PooledBullet.PooledBulletTypes.Standard;
							pBullet.airDetonation = false;
						}
                        switch(bulletDragType)
                        {
                            case BulletDragTypes.None:
                                pBullet.dragType = PooledBullet.BulletDragTypes.None;
                                break;
                            case BulletDragTypes.AnalyticEstimate:
                                pBullet.dragType = PooledBullet.BulletDragTypes.AnalyticEstimate;
                                break;
                            case BulletDragTypes.NumericalIntegration:
                                pBullet.dragType = PooledBullet.BulletDragTypes.NumericalIntegration;
                                break;
                        }

						pBullet.gameObject.SetActive(true);

						
						//heat
						heat += heatPerShot;
					}
					else
					{
						spinningDown = true;
						if(!oneShotSound && wasFiring)
						{
							audioSource.Stop ();
							wasFiring = false;
							audioSource2.PlayOneShot(overheatSound);	
						}
					}
				}


			}
			else
			{
				spinningDown = true;	
			}
		}
Exemple #2
0
		private bool FireLaser()
		{
			float maxDistance = BDArmorySettings.PHYSICS_RANGE;
			if(BDArmorySettings.PHYSICS_RANGE == 0) maxDistance = 2500;
			
			float chargeAmount = requestResourceAmount * TimeWarp.fixedDeltaTime;
			if(!pointingAtSelf && !Misc.CheckMouseIsOnGui() && WMgrAuthorized() && !isOverheated && (part.RequestResource(ammoName, chargeAmount)>=chargeAmount || BDArmorySettings.INFINITE_AMMO))
			{
				if(!audioSource.isPlaying)
				{
					audioSource.PlayOneShot (chargeSound);
					audioSource.Play();
					audioSource.loop = true;
					
				}
				for(int i = 0; i < fireTransforms.Length; i++)
				{
					Transform tf = fireTransforms[i];

					LineRenderer lr = laserRenderers[i];
					//lr.SetPosition(0, tf.position + (part.rb.velocity*Time.fixedDeltaTime));
					
					Vector3 rayDirection = tf.forward;
					
					Vector3 targetDirection = Vector3.zero;  //autoTrack enhancer
					Vector3 targetDirectionLR = tf.forward;
					Vector3 physStepFix = Vector3.zero;


					if(legacyTargetVessel!=null && legacyTargetVessel.loaded)
					{
						physStepFix = legacyTargetVessel.rb_velocity*Time.fixedDeltaTime;
						targetDirection = (legacyTargetVessel.CoM+physStepFix) - tf.position;


						if(Vector3.Angle(rayDirection, targetDirection) < 1)
						{
							rayDirection = targetDirection;
							targetDirectionLR = legacyTargetVessel.CoM+(2*physStepFix) - tf.position;
						}
					}
					else if(slaved)
					{
						physStepFix = (targetVelocity)*Time.fixedDeltaTime;
						targetDirection = (targetPosition+physStepFix) - tf.position;


						rayDirection = targetDirection;
						targetDirectionLR = targetDirection + physStepFix;
					}
					


					Ray ray = new Ray(tf.position, rayDirection);
					lr.useWorldSpace = false;
					lr.SetPosition(0, Vector3.zero);
					RaycastHit hit;
					if(Physics.Raycast(ray, out hit, maxDistance, 557057))
					{
						lr.useWorldSpace = true;
						laserPoint = hit.point + physStepFix;

						//lr.SetPosition(1, lr.transform.InverseTransformPoint(laserPoint));
						lr.SetPosition(0, tf.position+(part.rb.velocity*Time.fixedDeltaTime));
						lr.SetPosition(1, laserPoint);


						if(Time.time-timeFired > 6/120 && BDArmorySettings.BULLET_HITS)
						{
							BulletHitFX.CreateBulletHit(hit.point, hit.normal, false);	
						}

						Part p = hit.collider.gameObject.GetComponentInParent<Part>();
						if(p && p.vessel && p.vessel!=this.vessel)
						{
							float distance = hit.distance;
							//Scales down the damage based on the increased surface area of the area being hit by the laser. Think flashlight on a wall.
							p.temperature += laserDamage/(1+Mathf.PI*Mathf.Pow(tanAngle*distance,2))*TimeWarp.fixedDeltaTime; 
							
							if(BDArmorySettings.INSTAKILL) p.temperature += p.maxTemp;
						}
					}
					else
					{
						laserPoint = lr.transform.InverseTransformPoint((targetDirectionLR*maxDistance)+tf.position);
						lr.SetPosition(1, laserPoint);
					}
				}
				heat += heatPerShot * TimeWarp.CurrentRate;
				return true;
			}
			else
			{
				return false;
			}
		}
Exemple #3
0
		public override void OnStart (StartState state)
		{
			base.OnStart (state);

			ParseWeaponType();
            ParseBulletDragType();

            bulletBallisticCoefficient = bulletMass / bulletDragArea * 1000;        //1000 to convert from tonnes to kilograms

			if(shortName == string.Empty)
			{
				shortName = part.partInfo.title;
			}

			foreach(var emitter in part.FindModelComponents<KSPParticleEmitter>())
			{
				emitter.emit = false;
			}

			if(airDetonation)
			{
				var detRange = (UI_FloatRange)Fields["defaultDetonationRange"].uiControlEditor;
				detRange.maxValue = maxAirDetonationRange;
			}
			else
			{
				Fields["defaultDetonationRange"].guiActive = false;
				Fields["defaultDetonationRange"].guiActiveEditor = false;
			}

			if(HighLogic.LoadedSceneIsFlight)
			{
				if(eWeaponType != WeaponTypes.Laser)
				{
					if(bulletPool == null)
					{
						SetupBulletPool();
					}
					if(shellPool == null)
					{
						SetupShellPool();
					}
				}

				//setup transforms
				fireTransforms = part.FindModelTransforms(fireTransformName);
				shellEjectTransforms = part.FindModelTransforms(shellEjectTransformName);

				//setup emitters
				foreach(var pe in part.FindModelComponents<KSPParticleEmitter>())
				{
					pe.maxSize *= part.rescaleFactor;
					pe.minSize *= part.rescaleFactor;
					pe.shape3D *= part.rescaleFactor;
					pe.shape2D *= part.rescaleFactor;
					pe.shape1D *= part.rescaleFactor;

					if(pe.useWorldSpace && !oneShotWorldParticles)
					{
						BDAGaplessParticleEmitter gpe = pe.gameObject.AddComponent<BDAGaplessParticleEmitter>();	
						gpe.part = part;
						gaplessEmitters.Add(gpe);
					}
				}

				
				//setup projectile colors
				projectileColorC = Misc.ParseColor255(projectileColor);
				startColorC = Misc.ParseColor255(startColor);
				
				//init and zero points
				targetPosition = Vector3.zero;
				pointingAtPosition = Vector3.zero;
				bulletPrediction = Vector3.zero;

				//setup audio
				SetupAudio();

				//laser setup
				if(eWeaponType == WeaponTypes.Laser)
				{
					SetupLaserSpecifics();
				}
			}
			else if(HighLogic.LoadedSceneIsEditor)
			{
				fireTransforms = part.FindModelTransforms(fireTransformName);
			}

			//turret setup
			foreach(var turr in part.FindModulesImplementing<ModuleTurret>())
			{
				if(turr.turretID == turretID)
				{
					turret = turr;
					break;
				}
			}

			if(!turret)
			{
				Fields["onlyFireInRange"].guiActive = false;
				Fields["onlyFireInRange"].guiActiveEditor = false;
			}


			//setup animations
			if(hasDeployAnim)
			{
				deployState = Misc.SetUpSingleAnimation(deployAnimName, this.part);
				deployState.normalizedTime = 0;
				deployState.speed = 0;
				deployState.enabled = true;
			}
			if(hasFireAnimation)
			{
				fireState = Misc.SetUpSingleAnimation (fireAnimName, this.part);
				fireState.enabled = false;	
			}

			BDArmorySettings.OnVolumeChange += UpdateVolume;
		}
Exemple #4
0
        void FlyToPosition(FlightCtrlState s, Vector3 targetPosition)
        {
            if (!startedLanded)
            {
                targetPosition = FlightPosition(targetPosition, minAltitude);
            }


            Vector3d srfVel = vessel.srf_velocity;

            if (srfVel != Vector3d.zero)
            {
                velocityTransform.rotation = Quaternion.LookRotation(srfVel, -vesselTransform.forward);
            }
            velocityTransform.rotation = Quaternion.AngleAxis(90, velocityTransform.right) * velocityTransform.rotation;
            Vector3 localAngVel = vessel.angularVelocity;

            if (steerMode == SteerModes.NormalFlight)
            {
                float   angleToTarget   = Vector3.Angle(targetPosition - vesselTransform.position, vesselTransform.up);
                Vector3 dampedDirection = Vector3.RotateTowards(vesselTransform.up, targetPosition - vesselTransform.position, (angleToTarget / 2) * Mathf.Deg2Rad, 0).normalized;
                targetPosition = vesselTransform.position + (500 * dampedDirection);
            }

            if (BDArmorySettings.DRAW_DEBUG_LINES)
            {
                flyingToPosition = targetPosition;
            }

            Vector3 targetDirection;
            Vector3 targetDirectionYaw;
            float   yawError;
            float   pitchError;
            float   postYawFactor;
            float   postPitchFactor;

            if (steerMode == SteerModes.NormalFlight)
            {
                targetDirection = velocityTransform.InverseTransformDirection(targetPosition - velocityTransform.position).normalized;
                targetDirection = Vector3.RotateTowards(Vector3.up, targetDirection, 45 * Mathf.Deg2Rad, 0);

                targetDirectionYaw = vesselTransform.InverseTransformDirection(vessel.srf_velocity).normalized;
                targetDirectionYaw = Vector3.RotateTowards(Vector3.up, targetDirectionYaw, 45 * Mathf.Deg2Rad, 0);


                postYawFactor   = 1;
                postPitchFactor = 1;
            }
            else            //(steerMode == SteerModes.Aiming)
            {
                targetDirection    = vesselTransform.InverseTransformDirection(targetPosition - vesselTransform.position).normalized;
                targetDirection    = Vector3.RotateTowards(Vector3.up, targetDirection, 45 * Mathf.Deg2Rad, 0);
                targetDirectionYaw = targetDirection;

                if (command == PilotCommands.Follow)
                {
                    postYawFactor   = 1.5f;
                    postPitchFactor = 1f;
                }
                else
                {
                    postYawFactor   = 1.6f;
                    postPitchFactor = 2.4f;
                }
            }

            pitchError = VectorUtils.SignedAngle(Vector3.up, Vector3.ProjectOnPlane(targetDirection, Vector3.right), Vector3.back);
            yawError   = VectorUtils.SignedAngle(Vector3.up, Vector3.ProjectOnPlane(targetDirectionYaw, Vector3.forward), Vector3.right);



            float finalMaxSteer = threatLevel * maxSteer;

            float steerPitch = (postPitchFactor * 0.015f * steerMult * pitchError) - (postPitchFactor * steerDamping * -localAngVel.x);
            float steerYaw   = (postYawFactor * 0.022f * steerMult * yawError) - (postPitchFactor * steerDamping * -localAngVel.z);


            s.yaw   = Mathf.Clamp(steerYaw, -finalMaxSteer, finalMaxSteer);
            s.pitch = Mathf.Clamp(steerPitch, Mathf.Min(-finalMaxSteer, -0.2f), finalMaxSteer);


            //roll
            Vector3 currentRoll = -vesselTransform.forward;
            Vector3 rollTarget;

            if (steerMode == SteerModes.Aiming || Vector3.Angle(vesselTransform.up, targetPosition - vesselTransform.position) > 2)
            {
                rollTarget = (targetPosition + ((steerMode == SteerModes.Aiming ? 10 : 45f) * upDirection)) - vesselTransform.position;
            }
            else
            {
                rollTarget = upDirection;
            }

            if (command == PilotCommands.Follow && useRollHint)
            {
                rollTarget = -commandLeader.vessel.ReferenceTransform.forward;
            }

            rollTarget = Vector3.ProjectOnPlane(rollTarget, vesselTransform.up);



            float rollError = Misc.SignedAngle(currentRoll, rollTarget, vesselTransform.right);

            debugString += "\nRoll offset: " + rollError;
            float steerRoll = (steerMult * 0.0015f * rollError);

            debugString += "\nSteerRoll: " + steerRoll;
            float rollDamping = (.10f * steerDamping * -localAngVel.y);

            steerRoll   -= rollDamping;
            debugString += "\nRollDamping: " + rollDamping;



            float roll = Mathf.Clamp(steerRoll, -maxSteer, maxSteer);

            s.roll = roll;
            //
        }