// ------
public WeaponSettings.Upgrade GetUpgrade(int index)
{
if (weaponID != E_WeaponID.None)
{
WeaponSettings settings = WeaponSettingsManager.Instance.Get(weaponID);
int index2 = 0;
for (int i = 0; i < settings.Upgrades.Count; i++)
{
if (!settings.Upgrades[i].Disabled)
{
if (index == index2)
{
return(settings.Upgrades[i]);
}
else
{
++index2;
}
}
}
}
return(null);
}
// ------
public bool Enabled()
{
if (weaponID != E_WeaponID.None)
{
WeaponSettings settings = WeaponSettingsManager.Instance.Get(weaponID);
return(!settings.DISABLED);
}
else if (itemID != E_ItemID.None)
{
ItemSettings settings = ItemSettingsManager.Instance.Get(itemID);
return(!settings.DISABLED);
}
else if (upgradeID != E_UpgradeID.None)
{
UpgradeSettings settings = UpgradeSettingsManager.Instance.Get(upgradeID);
return(!settings.DISABLED);
}
else if (perkID != E_PerkID.None)
{
PerkSettings settings = PerkSettingsManager.Instance.Get(perkID);
return(!settings.DISABLED);
}
else
{
Error("Unknown type!");
}
return(false);
}
// --------
public void RegisterWeaponsInInventory()
{
ResetWeaponsList();
foreach (PPIWeaponData data in PPIManager.Instance.GetLocalPlayerPPI().EquipList.Weapons)
{
if (data.ID == E_WeaponID.None)
{
continue;
}
Weapons[data.EquipSlotIdx] = data.ID;
}
for (int idx = 0; idx < InventoryItem.Length; idx++)
{
if (idx < Weapons.Count && Weapons[idx] != E_WeaponID.None)
{
WeaponSettings settings = WeaponSettingsManager.Instance.Get(Weapons[idx]);
InventoryItem[idx].Sprite.CopyMaterialSettings(settings.HudWidget);
}
}
SetCurrentWeapon();
UpdatePlayerWeapons();
}
public WeaponSettings(Dynago.Forms.Main parent)
{
index = indexTracker;
indexTracker++;
// trigger init
parent.cmb_triggerbot_type.SelectedIndexChanged += (s, e) => WeaponSettings.RefreshTriggerSettings(parent);
parent.cb_trigger_onkey.CheckedChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
parent.txt_trigger_key.TextChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
parent.nud_trigger_delay.ValueChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
parent.nud_trigger_overshoot.ValueChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
parent.cb_trigger_shoot_teammates.CheckedChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
parent.cb_trigger_shoot_enemies.CheckedChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
parent.cb_trigger_magnetic.CheckedChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
parent.cmb_trigger_magnet_bone.SelectedIndexChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
parent.nud_trigger_magnet_fov.ValueChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
parent.nud_trigger_magnet_smooth.ValueChanged += (s, e) => WeaponSettings.UpdateTriggerSettings(parent);
// aimbot init
parent.cmb_aimbot_type.SelectedIndexChanged += (s, e) => WeaponSettings.RefreshAimSettings(parent);
parent.cb_aimbot_onkey.CheckedChanged += (s, e) => WeaponSettings.UpdateAimSettings(parent);
parent.txt_aimbot_key.TextChanged += (s, e) => WeaponSettings.UpdateAimSettings(parent);
parent.cmb_aimbot_bone.SelectedIndexChanged += (s, e) => WeaponSettings.UpdateAimSettings(parent);
parent.nud_aimbot_fov.ValueChanged += (s, e) => WeaponSettings.UpdateAimSettings(parent);
parent.nud_aimbot_smooth.ValueChanged += (s, e) => WeaponSettings.UpdateAimSettings(parent);
parent.cb_aimbot_rcs.CheckedChanged += (s, e) => WeaponSettings.UpdateAimSettings(parent);
parent.cb_aimbot_target_teammates.CheckedChanged += (s, e) => WeaponSettings.UpdateAimSettings(parent);
parent.cb_aimbot_target_enemies.CheckedChanged += (s, e) => WeaponSettings.UpdateAimSettings(parent);
types.Add(this);
}
/// <summary>
/// Sets the given setting's value generator.
/// </summary>
public void Set(WeaponSettings weaponSetting, ValueGenerator valueGenerator)
{
switch (weaponSetting)
{
case WeaponSettings.Ammo:
Ammo = valueGenerator;
break;
case WeaponSettings.Power:
Power = valueGenerator;
break;
case WeaponSettings.Delay:
Delay = valueGenerator;
break;
case WeaponSettings.Crate:
Crate = valueGenerator;
break;
default:
Debug.Assert(false, "Invalid enum.");
break;
}
}
public void ObtainWeapon(Commandments.Element element, bool obtain = true)
{
WeaponSettings aux = settings[element];
aux.obtained = obtain;
settings[element] = aux;
}
protected virtual void OnInputDown(WeaponSettings weaponSettings, Transform weaponBarrel, LayerMask damageLayer, LayerMask firedByLayer, AmmoUI ammoUI)
{
if (initialized == false)
{
Init(weaponSettings);
}
}
protected override void OnInputHeld(WeaponSettings weaponSettings, Transform weaponBarrel, LayerMask damageLayer, LayerMask firedByLayer, AmmoUI ammoUI)
{
if (shouldReset == true)
{
return;
}
if (shootCount < weaponSettings.weaponInfo.fireRateAuto)
{
shootCount += Time.deltaTime;
return;
}
shootCount = 0f;
// If we have ammo or if we are using a weapon with unlimited ammo
if (currentAmmo > 0 || currentAmmo >= 0 && maxAmmo == 0)
{
if (currentClip > 0)
{
canShoot = false;
currentClip--;
if (currentAmmo > 0)
{
currentAmmo--;
}
ammoUI.UpdateCurrentAmmo(currentClip);
SpawnProjectile(weaponSettings, weaponBarrel, damageLayer, firedByLayer);
}
}
}
public static SettingLimits GetWeaponSettingLimits(WeaponTypes weaponType, WeaponSettings weaponSetting)
{
if (weaponType == WeaponTypes.Default)
{
return(new SettingLimits(0, 255));
}
else
{
Debug.Assert(weaponType < WeaponTypes.Count);
if (weaponType < WeaponTypes.Count)
{
WeaponLimits weaponLimits = _weaponLimits[(int)weaponType];
switch (weaponSetting)
{
case WeaponSettings.Ammo:
return(weaponLimits.Ammo);
case WeaponSettings.Power:
return(weaponLimits.Power);
case WeaponSettings.Delay:
return(weaponLimits.Delay);
case WeaponSettings.Crate:
return(weaponLimits.Crate);
}
}
}
return(null);
}
int CompareWeapon(int otherId)
{
WeaponSettings otherWs = WeaponSettingsManager.Instance.Get((E_WeaponID)(otherId));
WeaponSettings myWs = WeaponSettingsManager.Instance.Get((E_WeaponID)(Id));
int res;
res = myWs.WeaponType.CompareTo(otherWs.WeaponType);
if (res != 0)
{
return(res);
}
//sort rifle into subtype
if (myWs.WeaponType == E_WeaponType.Rifle)
{
res = RifleSubtype((E_WeaponID)Id).CompareTo(RifleSubtype((E_WeaponID)otherId));
if (res != 0)
{
return(res);
}
}
//otherwise use regular order
return(Id.CompareTo(otherId));
}
///////////////////////////////////////////////////
// Member Functions
///////////////////////////////////////////////////
/// <summary>
/// Generic Constructor
/// </summary>
public WeaponController(Helpers.ObjectState state, WeaponSettings settings)
{
_state = state;
_settings = settings;
bEquipped = false;
}
protected virtual void UpdateReload(WeaponSettings weaponSettings, AmmoUI ammoUI)
{
if (reloading == false)
{
return;
}
if (reloadCount < weaponSettings.weaponInfo.reloadTime)
{
reloadCount += Time.deltaTime;
return;
}
reloading = false;
reloadCount = 0f;
canShoot = true;
if (currentAmmo < ammoPerClip && maxAmmo != 0)
{
currentClip = currentAmmo;
}
else
{
currentClip = ammoPerClip;
}
ammoUI.Reloaded();
}
// ------
public bool IsDefault()
{
if (weaponID != E_WeaponID.None)
{
WeaponSettings settings = WeaponSettingsManager.Instance.Get(weaponID);
return(settings.IsDefault());
}
else if (itemID != E_ItemID.None)
{
ItemSettings settings = ItemSettingsManager.Instance.Get(itemID);
return(settings.IsDefault());
}
else if (upgradeID != E_UpgradeID.None)
{
UpgradeSettings settings = UpgradeSettingsManager.Instance.Get(upgradeID);
return(settings.IsDefault());
}
else if (perkID != E_PerkID.None)
{
PerkSettings settings = PerkSettingsManager.Instance.Get(perkID);
return(settings.IsDefault());
}
return(false);
}
void SpawnImpact(ContactPoint contactData)
{
Vector3 impactAngle = contactData.normal;
Quaternion impactRot = Quaternion.FromToRotation(Vector3.up, impactAngle);
WeaponSettings weaponSettings = gameManager.gameSettings.weaponSettings;
GameObject effect = weaponSettings.impactEffects.Where(x => x.type == ImpactType.SparkImpact).First().effect;
Destroy(Instantiate(effect, contactData.point, impactRot), 5);
}
void Update()
{
if (health <= 0)
{
Debug.Log("You lost hun");
}
else
{
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
PlayerMovement();
CameraFPS();
ShootBullet();
HitInfo();
timeleft -= Time.deltaTime;
if (Input.GetKeyDown("e"))
{
if (curWeapons < weapons.Length - 1)
{
curWeapons++;
}
else
{
curWeapons = 0;
}
}
if (Input.GetKeyDown("q"))
{
if (curWeapons > 0)
{
curWeapons--;
}
else
{
curWeapons = weapons.Length - 1;
}
}
foreach (WeaponSettings w in weapons)
{
if (w == weapon)
{
w.gameObject.SetActive(true);
}
else
{
w.gameObject.SetActive(false);
}
}
weapon = weapons[curWeapons];
RefrshWeaponImage();
}
}
public PreviewItem(E_WeaponID weaponID)
{
if (weaponID != E_WeaponID.None)
{
WeaponSettings settings = WeaponSettingsManager.Instance.Get(weaponID);
m_ItemDescription = TextDatabase.instance[settings.Description];
m_NumberOfParams = 4;
m_WeaponID = weaponID;
}
}
protected virtual void OnInputUp(WeaponSettings weaponSettings)
{
if (shouldReset == true)
{
return;
}
shootCount = 0f;
shouldReset = true;
}
public void Additem(string weaponName)
{
WeaponSettings wSettings = GetGunSetting(weaponName);
if (items.Count == 0 && wSettings != null)
{
items.Add(wSettings);
Equip(wSettings);
}
}
/// <summary>
/// Sets a copy of the given value generator for all applicable weapons.
/// </summary>
public void SetDefault(WeaponSettings weaponSetting, ValueGenerator valueGenerator)
{
for (int i = 0; i < (int)WeaponTypes.Count; ++i)
{
if (!SchemeTypes.CanApplyWeaponSetting((WeaponTypes)i, weaponSetting))
{
continue;
}
_weaponGenerators[i].Set(weaponSetting, valueGenerator.DeepClone());
}
}
private Item FindWeaponReplacement(int weaponType)
{
foreach (Item item in items)
{
WeaponSettings weaponSettings = item.ItemSettings as WeaponSettings;
if (weaponSettings && weaponSettings.WeaponPlaceNumber == weaponType)
{
return(item);
}
}
return(null);
}
/// <summary>
/// Sets the given weapon settings's value generator.
/// </summary>
public void Set(WeaponTypes weapon, WeaponSettings weaponSetting, ValueGenerator valueGenerator)
{
Debug.Assert(weaponSetting < WeaponSettings.Count);
if (weaponSetting < WeaponSettings.Count)
{
Debug.Assert(weapon < WeaponTypes.Count);
if (weapon < WeaponTypes.Count)
{
_weaponGenerators[(int)weapon].Set(weaponSetting, valueGenerator);
}
}
}
public void Copy(Weapon w)
{
weaponType = w.weaponType;
weaponSettings = w.weaponSettings;
_bulletCounter = weaponSettings.bulletNumber;
_fireTimer = weaponSettings.fireRate;
audioSource = transform.Find("SFXWeapon").GetComponent <AudioSource>();
if (audioSource)
{
audioSource.clip = weaponSettings.fireSound;
}
}
public override void Init(string id, WeaponInfo weaponInfo, VesselAudioSystem audioSystem, AimAssist aimAssist, ProjectileType projectileType)
{
WeaponData weaponData = weaponInfo.weaponData;
this.shooterID = id;
this.audioSystem = audioSystem;
this.fireRate = weaponData.fireRate;
this.aimAssist = aimAssist;
weaponSound = weaponData.fireSound;
WeaponSettings settings = GameManager.Instance.gameSettings.weaponSettings;
this.projectileData = settings.projectiles.Where(x => x.type == projectileType).First();
}
public Weapon CreateWeapon(WeaponSettings weaponSettings)
{
// instantiate weapon
GameObject weaponMain = Instantiate(weaponPrefab, handToMove);
GameObject weaponModel = Instantiate(weaponSettings.WeaponModel, weaponMain.transform);
Weapon weaponComp = weaponMain.GetComponent <Weapon>();
weaponMain.name = "Weapon";
//weaponComp.WeaponInitialized(player, weaponSettings, weaponModel.transform.GetChild(1));
// add weapon to character
//player.CharacterWeapon = weaponComp;
return(weaponComp);
}
public void UpdateWeapon(WeaponSettings weaponSettings)
{
maxAmmo = weaponSettings.weaponInfo.maxAmmo;
UpdateCurrentAmmo(weaponSettings.currentAmmo);
CleanupProjectileImages();
for (int i = 0; i < weaponSettings.weaponInfo.ammoPerClip; i++)
{
ProjectileUI projectile = SimplePool.Spawn(projectileUIPrefab.gameObject, Vector3.zero, Quaternion.identity).GetComponent <ProjectileUI>();
projectile.Init(weaponSettings.weaponInfo.projectileSprite, weaponSettings.weaponInfo.usedProjectileSprite);
projectile.transform.SetParent(imageParent, false);
projectileImages.Add(projectile);
}
}
private void UpdateWeapon()
{
WeaponSettings w = manager.GetWeapon(currentWeaponIndex);
if (_fire && (w.allowContinuisPress || _fireJustPress))
{
if ((Time.time - _lastFireTime) >= w.firePeriod)
{
FireWeapon(w);
_lastFireTime = Time.time;
}
}
_fireJustPress = false;
}
public static void OpenWeaponSettings()
{
var window = (GameSettingsEditor)GetWindow(typeof(GameSettingsEditor));
WeaponSettings settings = Resources.Load <WeaponSettings>("WeaponSettings");
if (settings != null)
{
window.fireRate = settings.FireRate;
window.bulletSpeed = settings.BulletSpeed;
window.impulse = settings.ImpactImpulse;
}
window.settingsType = SettingsType.Weapon;
window.Show();
}
//public void WeaponShooterSetup(Character weaponChar, WeaponSettings weaponSettings)
//{
// this.weaponChar = weaponChar;
// this.inputChar = weaponChar.CharacterInput;
// this.settings = weaponSettings;
// ammoStoreMax = settings.AmmoStoreMax;
// ammoAmountInStore = settings.AmmoAmountInStore;
// ammoAmount = settings.AmmoAmount;
// //set default
// shootSpot = transform;
// isStoreEmpty = ammoAmountInStore == 0;
//}
void Start()
{
settings = GetComponentInParent <Weapon>().WeaponSettings;
// create empty object for future bullets
bulletParent = new GameObject();
bulletParent.name = "Bullets weapon:" + gameObject.name;
if (laserLineRender != null)
{
laserLineRender.useWorldSpace = true;
laserLineRender.startWidth = laserWidth;
laserLineRender.endWidth = laserWidth;
}
Debug.Log("Weapon shooter: " + settings.Name);
}
private void Init(WeaponSettings weaponSettings)
{
initialized = true;
maxAmmo = weaponSettings.weaponInfo.maxAmmo;
currentAmmo = weaponSettings.currentAmmo;
ammoPerClip = weaponSettings.weaponInfo.ammoPerClip;
if (currentAmmo < ammoPerClip && maxAmmo != 0)
{
currentClip = currentAmmo;
}
else
{
currentClip = ammoPerClip;
}
}
public static void RefreshAimSettings(Dynago.Forms.Main main)
{
main.RefreshingAimSettings = true;
WeaponSettings settings = Selected(main.cmb_aimbot_type);
main.cb_aimbot_onkey.Checked = settings.aimbot_on_key;
main.txt_aimbot_key.Text = settings.aimbot_key_txt;
main.cmb_aimbot_bone.SelectedIndex = settings.aimbot_bone_index;
main.nud_aimbot_fov.Value = Convert.ToDecimal(settings.aimbot_fov);
main.nud_aimbot_smooth.Value = Convert.ToDecimal(settings.aimbot_smooth);
main.cb_aimbot_rcs.Checked = settings.aimbot_control_recoil;
main.cb_aimbot_target_teammates.Checked = settings.aimbot_shoot_teammates;
main.cb_aimbot_target_enemies.Checked = settings.aimbot_shoot_enemies;
main.RefreshingAimSettings = false;
main.txtDummy.Focus();
}
public void GetStatusValue()
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(GameAsset.text);
XmlNodeList setting_values = xmlDoc.GetElementsByTagName(weaponsSettingsTag);
weaponsSettings = new List<WeaponSettings>();
foreach (XmlNode setting_value in setting_values) {
XmlNodeList status_contents = setting_value.ChildNodes;
WeaponSettings weaponSettings = new WeaponSettings();
weaponSettings.statusValues = new Dictionary<string, string>();
foreach (XmlNode status_content in status_contents) {
foreach (string tag_name in Enum.GetNames(typeof(TagNames))) {
if (status_content.Name == tag_name) {
weaponSettings.statusValues.Add(tag_name, status_content.InnerText);
}
}
}
weaponsSettings.Add(weaponSettings);
}
}
private void InitWep()
{
if (this.weapons.Length > 0)
{
RightHand = FirstOrDefault(transforms, a => a.tag == "rhand");
weapon = this.weapons[Random.Range(0, this.weapons.Length)];
if (RightHand != null)
{
var original = weapon.weaponPrefab;
weaponObj = (GameObject)Instantiate(original, RightHand.position + original.transform.position, RightHand.rotation * original.transform.rotation);
if (weaponObj.collider == null)
{
weaponObj.AddComponent<BoxCollider>();
weaponObj.collider.enabled = false;
m_colliders = null;
}
weaponObj.transform.parent = RightHand;
}
}
if (weapon == null) weapon = _Database.defWep;
}
