//В эту процедуру попадает только в том случае, если идет расчет параметров по кораблю игрока
//Для расчета параметров противника данная процедура не подойдёт и будет отсекать обработку если
//в риге нет реального корабля
private void CreateWeapons()
{
if (rig.Ship == null)
{
return;
}
if (Weapons == null)
{
Weapons = new List <WeaponParameters>();
foreach (var rigSlot in rig.Slots)
{
if (rigSlot.IsWeapon)
{
if (!rigSlot.IsEmpty)
{
WeaponParameters curWeapon = new WeaponParameters(rigSlot.Module);
curWeapon.Slot = rigSlot.Slot;
curWeapon.Module = rigSlot.Module;
curWeapon.CalculateParameters();
Weapons.Add(curWeapon);
ReactorConsumption += curWeapon.ModuleType.EnergyNeed;
}
}
}
}
else
{
foreach (WeaponParameters weapon in Weapons)
{
//Заново создаёт внутрянку оружия
weapon.CalculateParameters();
}
}
}
public static WeaponParameters CreateWeaponSetInFolder(string folderPath, string weaponName, WeaponScript linkedWeapon)
{
WeaponParameters weaponParams = ScriptableObject.CreateInstance <WeaponParameters>();
ShootParameters shootParams = ScriptableObject.CreateInstance <ShootParameters>();
ProjectileParameters projectileParams = ScriptableObject.CreateInstance <ProjectileParameters>();
weaponParams.weaponName = weaponName;
weaponParams.SetWeaponPrefab(linkedWeapon);
weaponParams.SetShootParameters(shootParams);
ProjectileScript baseProjectilePrefab = AssetDatabase.LoadAssetAtPath <ProjectileScript>("Assets/Weapons/BaseProjectile.prefab");
shootParams.SetProjectilePrefab(baseProjectilePrefab);
shootParams.SetProjectileParameters(projectileParams);
string weaponPath = AssetDatabase.GenerateUniqueAssetPath(folderPath + "/" + weaponName + " Weapon Parameters.asset");
string shootPath = AssetDatabase.GenerateUniqueAssetPath(folderPath + "/" + weaponName + " Shoot Parameters.asset");
string projectilePath = AssetDatabase.GenerateUniqueAssetPath(folderPath + "/" + weaponName + " Projectiles Parameters.asset");
AssetDatabase.CreateAsset(weaponParams, weaponPath);
AssetDatabase.CreateAsset(shootParams, shootPath);
AssetDatabase.CreateAsset(projectileParams, projectilePath);
EditorUtility.SetDirty(weaponParams);
EditorUtility.SetDirty(shootParams);
EditorUtility.SetDirty(projectileParams);
return(weaponParams);
}
protected override void OnCreate()
{
if (Parameters == null)
{
Parameters = WeaponParameters.Instance;
}
}
private void OnGUI()
{
EditorStaticMethods.ShowFolderAndAskIfCreateNew(ref selectedFolderRef, ref createFolder);
GUILayout.Space(12);
float oldWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth *= 1.5f;
ShowWeaponSetCreationParameters(selectedFolderRef, ref newWeaponName, createFolder, ref createLinkedObject, ref newWeaponCreationParameters);
EditorGUIUtility.labelWidth = oldWidth;
if (selectedFolderRef != null)
{
if (GUILayout.Button("Create the new Weapon : \"" + newWeaponName + "\" !"))
{
string finalFolderPath = selectedFolderRef.GetFolderPath();
if (createFolder)
{
string folderCreationPath = finalFolderPath;
finalFolderPath = AssetDatabase.GenerateUniqueAssetPath(finalFolderPath + "/" + newWeaponName + " Set");
Debug.Log("Create Folder \"" + newWeaponName + "Set" + "\" in \"" + folderCreationPath + "\"");
AssetDatabase.CreateFolder(folderCreationPath, newWeaponName + " Set");
}
WeaponScript newWeaponPrefab = null;
if (createLinkedObject)
{
WeaponScript newWeapon = WeaponCreationParameters.ComposeWeapon(newWeaponCreationParameters, newWeaponName);
newWeaponPrefab = EditorStaticMethods.CreateWeaponObjectInFolder(finalFolderPath, newWeapon);
}
WeaponParameters newWeaponParameters = null;
if (newWeaponPrefab != null)
{
newWeaponParameters = EditorStaticMethods.CreateWeaponSetInFolder(finalFolderPath, newWeaponName, newWeaponPrefab);
}
else
{
newWeaponParameters = EditorStaticMethods.CreateWeaponSetInFolder(finalFolderPath, newWeaponName);
}
if (newWeaponPrefab != null)
{
Selection.activeObject = newWeaponPrefab;
EditorGUIUtility.PingObject(newWeaponPrefab);
// PrefabUtility.LoadPrefabContents(AssetDatabase.GetAssetPath(newWeaponPrefab.GetInstanceID()));
}
else if (newWeaponParameters != null)
{
Selection.activeObject = newWeaponParameters;
EditorGUIUtility.PingObject(newWeaponParameters);
}
}
}
}
public static WeaponController Create(WeaponParameters parameters, Vector3 position, Quaternion rotation,
Transform parent = null)
{
var weapon = Instantiate(parameters.towerPrefab, position, rotation, parent)
.AddComponent <WeaponController>();
weapon.Parameters = parameters;
return(weapon);
}
private static void Initialize()
{
EntityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
HitSystem.onHitSystemFinish += OnHitSystemEvent;
MultiHitSystem.onMultiHitSystemFinish += OnMultiHitSystemEvent;
ExplosiveSystem.onExplosionHitSystemFinish += OnExplosiveSystemEvent;
Parameters = WeaponParameters.Instance;
}
private void WeaponSwap()
{
var currentWep = weapon[currentWeaponIndex];
projectileTriggerable = GetComponent <ProjectileTriggerable>();
currentWeaponObj = PoolManager.Spawn(currentWep.wGameObject, weaponLocation.position, weaponLocation.rotation);
currentWeaponObj.transform.SetParent(weaponLocation);
weaponParameters = currentWeaponObj.GetComponent <WeaponParameters>();
currentWep.Initialize(gameObject);
}
public Weapon(WeaponType typ, WeaponParameters parameters, int magazine, bool wasShooting, double spread, double?fireTimer, double?lastAngle, int?lastFireTick)
{
Typ = typ;
Parameters = parameters;
Magazine = magazine;
WasShooting = wasShooting;
Spread = spread;
FireTimer = fireTimer;
LastAngle = lastAngle;
LastFireTick = lastFireTick;
}
static ExplosiveFactory()
{
EntityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
// create our archetype
Archetype = EntityManager.CreateArchetype(
ComponentType.ReadWrite <Translation>(), ComponentType.ReadWrite <Explosive>(),
ComponentType.ReadOnly <LocalToWorld>(), ComponentType.ReadWrite <OwnerID>()
);
Parameters = WeaponParameters.Instance;
}
protected override void OnCreate()
{
Parameters = WeaponParameters.Instance;
HitMask = Parameters.GetProjectileHitLayer();
DetectHitQuery = GetEntityQuery(new EntityQueryDesc
{
All = new ComponentType[] { ComponentType.ReadOnly <PreviousTranslation>(), ComponentType.ReadOnly <Translation>(),
ComponentType.ReadOnly <Rotation>(), ComponentType.ReadWrite <Damage>(), ComponentType.ReadWrite <Distance>(),
ComponentType.ReadOnly <Projectile>(), ComponentType.ReadOnly <OwnerID>() },
None = new ComponentType[] { ComponentType.ReadOnly <MultiHit>() }
});
}
protected override void OnCreate()
{
Parameters = WeaponParameters.Instance;
HitMask = Parameters.GetExplosiveHitLayer();
Colliders = new Collider[32];
ExplosiveQuery = GetEntityQuery(new EntityQueryDesc
{
All = new ComponentType[] { ComponentType.ReadOnly <Explosive>(), ComponentType.ReadOnly <Translation>(), ComponentType.ReadOnly <OwnerID>() },
None = new ComponentType[] { ComponentType.ReadOnly <Projectile>() }
});
}
public static Weapon ReadFrom(System.IO.BinaryReader reader)
{
var result = new Weapon();
switch (reader.ReadInt32())
{
case 0:
result.Typ = WeaponType.Pistol;
break;
case 1:
result.Typ = WeaponType.AssaultRifle;
break;
case 2:
result.Typ = WeaponType.RocketLauncher;
break;
default:
throw new System.Exception("Unexpected discriminant value");
}
result.Parameters = WeaponParameters.ReadFrom(reader);
result.Magazine = reader.ReadInt32();
result.WasShooting = reader.ReadBoolean();
result.Spread = reader.ReadDouble();
if (reader.ReadBoolean())
{
result.FireTimer = reader.ReadDouble();
}
else
{
result.FireTimer = null;
}
if (reader.ReadBoolean())
{
result.LastAngle = reader.ReadDouble();
}
else
{
result.LastAngle = null;
}
if (reader.ReadBoolean())
{
result.LastFireTick = reader.ReadInt32();
}
else
{
result.LastFireTick = null;
}
return(result);
}
static ProjectileFactory()
{
EntityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
// create our archetype
Archetype = EntityManager.CreateArchetype( // probably could just get away with Scale component
ComponentType.ReadWrite <Translation>(), ComponentType.ReadWrite <Rotation>(), ComponentType.ReadWrite <NonUniformScale>(),
ComponentType.ReadWrite <PreviousTranslation>(), ComponentType.ReadWrite <Speed>(), ComponentType.ReadWrite <Damage>(),
ComponentType.ReadWrite <Projectile>(), ComponentType.ReadWrite <OwnerID>(), ComponentType.ReadWrite <Distance>(),
ComponentType.ReadOnly <LocalToWorld>(), ComponentType.ReadWrite <RenderMesh>()
);
Parameters = WeaponParameters.Instance;
}
static WeaponFactory()
{
EntityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
// create our archetype
Archetype = EntityManager.CreateArchetype(
ComponentType.ReadWrite <Translation>(), ComponentType.ReadWrite <Rotation>(),
ComponentType.ReadWrite <Weapon>(), ComponentType.ReadWrite <OwnerID>(),
ComponentType.ReadOnly <LocalToWorld>(), ComponentType.ReadWrite <TimeBetweenShots>(),
ComponentType.ReadWrite <WeaponState>(), ComponentType.ReadWrite <ShootFrom>(),
ComponentType.ReadWrite <Muzzle>()
);
Parameters = WeaponParameters.Instance;
}
public static void ShowWeaponParameters(WeaponParameters weaponParameters, float indentValue, ref bool showShootParameters, ref bool showProjectileParameters)
{
SerializedObject serializedParameters = new SerializedObject(weaponParameters);
serializedParameters.Update();
#region Base Parameters
GUI.Label(EditorStaticMethods.GetIndentedControlRect(indentValue), "Base Parameters", EditorStyles.boldLabel);
SerializedProperty weaponNameAttribute = serializedParameters.FindProperty("weaponName");
EditorGUI.PropertyField(EditorStaticMethods.GetIndentedControlRect(indentValue), weaponNameAttribute);
SerializedProperty weaponPrefabAttribute = serializedParameters.FindProperty("weaponPrefab");
EditorGUI.PropertyField(EditorStaticMethods.GetIndentedControlRect(indentValue), weaponPrefabAttribute);
#endregion
#region Shoot Parameters
GUILayout.Space(20);
GUI.Label(EditorStaticMethods.GetIndentedControlRect(indentValue), "Shoot Parameters", EditorStyles.boldLabel);
SerializedProperty shootParamsAttribute = serializedParameters.FindProperty("shootParameters");
EditorGUI.PropertyField(EditorStaticMethods.GetIndentedControlRect(indentValue), shootParamsAttribute);
serializedParameters.ApplyModifiedProperties();
ShootParameters shootParams = weaponParameters.GetShootParameters;
if (shootParams != null)
{
showShootParameters = EditorGUI.BeginFoldoutHeaderGroup(EditorStaticMethods.GetIndentedControlRect(indentValue), showShootParameters, (showShootParameters ? "Close" : "Open") + " Shoot Parameters", showShootParameters ? EditorStyles.boldLabel : null);
EditorGUI.EndFoldoutHeaderGroup();
if (showShootParameters)
{
EditorGUILayout.BeginVertical("box");
ShootParametersInspector.ShowShootParameters(shootParams, indentValue + 15, ref showProjectileParameters);
EditorGUILayout.EndVertical();
}
}
#endregion
}
public static WeaponParameters ReadFrom(System.IO.BinaryReader reader)
{
var result = new WeaponParameters();
result.MagazineSize = reader.ReadInt32();
result.FireRate = reader.ReadDouble();
result.ReloadTime = reader.ReadDouble();
result.MinSpread = reader.ReadDouble();
result.MaxSpread = reader.ReadDouble();
result.Recoil = reader.ReadDouble();
result.AimSpeed = reader.ReadDouble();
result.Bullet = BulletParameters.ReadFrom(reader);
if (reader.ReadBoolean())
{
result.Explosion = ExplosionParameters.ReadFrom(reader);
}
else
{
result.Explosion = null;
}
return(result);
}
public static Weapon ReadFrom(System.IO.BinaryReader reader)
{
if (reader == null)
{
throw new System.ArgumentNullException(nameof(reader));
}
WeaponType type;
switch (reader.ReadInt32())
{
case 0:
type = WeaponType.Pistol;
break;
case 1:
type = WeaponType.AssaultRifle;
break;
case 2:
type = WeaponType.RocketLauncher;
break;
default:
throw new System.Exception("Unexpected discriminant value");
}
var parameters = WeaponParameters.ReadFrom(reader);
var magazine = reader.ReadInt32();
var wasShooting = reader.ReadBoolean();
var spread = reader.ReadDouble();
var fireTimer = reader.ReadBoolean() ? reader.ReadDouble() : (double?)null;
var lastAngle = reader.ReadBoolean() ? reader.ReadDouble() : (double?)null;
var lastFireTick = reader.ReadBoolean() ? reader.ReadInt32() : (int?)null;
return(new Weapon(type, parameters, magazine, wasShooting, spread, fireTimer, lastAngle, lastFireTick));
}
private void OnEnable()
{
targetWeaponParameters = target as WeaponParameters;
}
private void CalculateInner()
{
SetShipModelParameters();
//Если расчет ведется для корабля игрока, то надо пробежаться по слотам и в них вести расчет
//по реально установленным модулям
if (rig.Ship != null)
{
foreach (var rigSlot in rig.Slots)
{
if (rigSlot.IsWeapon)
{
//Расчет параметров оружия вынесен в отдельную процедуру
/*if (!rigSlot.IsEmpty)
* {
* WeaponParameters curWeapon = new WeaponParameters(rigSlot.Module);
* curWeapon.Slot = rigSlot.Slot;
* curWeapon.Module = rigSlot.Module;
* curWeapon.CalculateParameters();
* Weapons.Add(curWeapon);
* ReactorConsumption += curWeapon.ModuleType.EnergyNeed;
* }*/
}
else if (rigSlot.IsModule && rigSlot.Module != null)
{
AddModule(rigSlot.Module);
}
else if (rigSlot.IsOfficers)
{
foreach (var officer in rigSlot.team.OfficerList)
{
Bonuses.Add(new ParameterBonus(officer));
}
}
}
}
else
{
if (Weapons == null)
{
Weapons = new List <WeaponParameters>();
}
foreach (var rigSlot in rig.Slots)
{
if (rigSlot.IsWeapon)
{
if (rigSlot.ModuleType != null)
{
WeaponParameters curWeapon = new WeaponParameters(rigSlot.ModuleType);
curWeapon.Slot = rigSlot.Slot;
curWeapon.CalculateParameters();
Weapons.Add(curWeapon);
}
}
else if (rigSlot.IsModule)
{
AddShipModuleType(rigSlot.ModuleType);
}
}
}
CreateWeapons();
ApplyBonuses();
}
public WeaponSet(WeaponScript weaponObj, WeaponParameters weaponParams, ShootParameters shootParams)
{
weaponObject = weaponObj;
weaponParameters = weaponParams;
shootParameters = shootParams;
}
public void SetWeaponParameters(WeaponParameters parameters)
{
baseWeaponParameters = parameters;
}
public override void OnInspectorGUI()
{
EditorGUI.BeginChangeCheck();
System.Type shipType = targetSpaceShip.GetType();
if (shipType != typeof(PlayerSpaceShipScript))
{
GUILayout.Space(8);
serializedObject.Update();
SerializedProperty damageTagProperty = serializedObject.FindProperty("damageTag");
EditorGUILayout.PropertyField(damageTagProperty);
serializedObject.ApplyModifiedProperties();
}
#region Movements
GUILayout.Space(8);
EditorGUILayout.LabelField("Movement System", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
SpaceShipMovementParameters newMovementParameters =
(SpaceShipMovementParameters)EditorGUILayout.ObjectField
("Movement Parameters", targetSpaceShip.GetMovementSystem.GetMovementParameters, typeof(SpaceShipMovementParameters), false);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(targetSpaceShip, "Undo Affect Movement Parameters");
targetSpaceShip.GetMovementSystem.SetMovementParameters(newMovementParameters);
}
SpaceShipMovementParameters finalMovementParameters = targetSpaceShip.GetMovementSystem.GetMovementParameters;
if (finalMovementParameters != null)
{
showMovementParameters = EditorGUILayout.BeginFoldoutHeaderGroup(showMovementParameters, (showMovementParameters ? "Close" : "Open") + " Movement Parameters", showMovementParameters ? EditorStyles.boldLabel : null);
EditorGUILayout.EndFoldoutHeaderGroup();
if (showMovementParameters)
{
EditorGUI.indentLevel += 1;
EditorGUILayout.BeginVertical("box");
SpaceShipMovementParametersInspector.ShowMovementParameters(finalMovementParameters, 10);
EditorGUILayout.EndVertical();
EditorGUI.indentLevel -= 1;
GUILayout.Space(8);
EditorStaticMethods.DrawLine(2, Color.black);
}
}
#endregion
#region Shooting
GUILayout.Space(8);
EditorGUILayout.LabelField("Shooting System", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
Transform newWeaponsParent = (Transform)EditorGUILayout.ObjectField("Weapons Parent", targetSpaceShip.GetShootingSystem.GetWeaponsParent, typeof(Transform), true);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(targetSpaceShip, "Undo Affect Weapons Parent");
targetSpaceShip.GetShootingSystem.SetWeaponsParent(newWeaponsParent);
}
EditorGUI.BeginChangeCheck();
WeaponParameters newWeaponParameters = (WeaponParameters)EditorGUILayout.ObjectField("Weapon Parameters", targetSpaceShip.GetShootingSystem.GetBaseWeaponParameters, typeof(WeaponParameters), false);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(targetSpaceShip, "Undo Affect Weapons Parameters");
targetSpaceShip.GetShootingSystem.SetWeaponParameters(newWeaponParameters);
}
WeaponParameters finalWeaponParameters = targetSpaceShip.GetShootingSystem.GetBaseWeaponParameters;
if (finalWeaponParameters != null)
{
showWeaponParameters = EditorGUILayout.BeginFoldoutHeaderGroup(showWeaponParameters, (showWeaponParameters ? "Close" : "Open") + " Weapon Parameters", showWeaponParameters ? EditorStyles.boldLabel : null);
EditorGUILayout.EndFoldoutHeaderGroup();
if (showWeaponParameters)
{
EditorGUI.indentLevel += 1;
EditorGUILayout.BeginVertical("box");
WeaponParametersInspector.ShowWeaponParameters(finalWeaponParameters, 15, ref showShootParameters, ref showProjectileParameters);
EditorGUILayout.EndVertical();
EditorGUI.indentLevel -= 1;
GUILayout.Space(8);
EditorStaticMethods.DrawLine(2, Color.black);
}
}
#endregion
#region Others
GUILayout.Space(8);
EditorGUILayout.LabelField("Other References", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
DamageableComponent newLinkedDamagesComponent = (DamageableComponent)EditorGUILayout.ObjectField("Linked Damageable Component", targetSpaceShip.GetRelatedDamageableComponent, typeof(DamageableComponent), true);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(targetSpaceShip, "Change Damageable Component");
targetSpaceShip.SetRelatedDamageableComponent(newLinkedDamagesComponent);
}
if (targetSpaceShip.GetRelatedDamageableComponent != null)
{
EditorGUI.BeginChangeCheck();
int newLifeAmount = EditorGUILayout.IntField("Ship Life Amount", targetSpaceShip.GetRelatedDamageableComponent.GetMaxLifeAmount);
if (EditorGUI.EndChangeCheck())
{
Debug.Log("Life Amount Changed");
Undo.RecordObject(targetSpaceShip.GetRelatedDamageableComponent, "Undo Change Max Life Amount");
targetSpaceShip.GetRelatedDamageableComponent.SetMaxLifeAmount(newLifeAmount);
}
}
#endregion
if (EditorGUI.EndChangeCheck())
{
EditorSceneManager.MarkSceneDirty(targetSpaceShip.gameObject.scene);
}
//base.OnInspectorGUI();
}
void Start()
{
wParam = this.GetComponent <WeaponParameters>();
GetComponent <Animation>()[wParam.shootAnimationClip.name].speed = wParam.shootAnimationClipSpeed;
shootAudioSorce = GetComponent <AudioSource>();
}
private void OnGUI()
{
EditorStaticMethods.ShowFolderAndAskIfCreateNew(ref selectedFolderRef, ref createFolder);
float oldWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth *= 1.5f;
GUILayout.Space(8);
GUILayout.Label("Enemy Parameters", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
newEnemyName = EditorGUILayout.TextField("New Enemy Name", newEnemyName);
if (EditorGUI.EndChangeCheck())
{
newWeaponName = newEnemyName + " Weapon";
}
enemyCreationParameters.enemyIdentifyingColor = EditorGUILayout.ColorField("Enemy Identifying Color", enemyCreationParameters.enemyIdentifyingColor);
enemyCreationParameters.lifeAmount = EditorGUILayout.IntField("Life Amount", enemyCreationParameters.lifeAmount);
enemyCreationParameters.aimingType = (EnemyAimingType)EditorGUILayout.EnumPopup(new GUIContent("Aiming Type"), enemyCreationParameters.aimingType);
GUILayout.Space(8);
GUILayout.Label("Linked Weapon", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
createLinkedWeaponParameters = EditorGUILayout.Toggle("Create Linked Weapon Parameters", createLinkedWeaponParameters);
if (EditorGUI.EndChangeCheck())
{
newWeaponName = newEnemyName + " Weapon";
}
if (createLinkedWeaponParameters)
{
EditorGUI.indentLevel++;
GUILayout.BeginVertical("box");
WeaponSetCreationWindow.ShowWeaponSetCreationParameters(selectedFolderRef, ref newWeaponName, false, ref createLinkedWeaponObject, ref newWeaponCreationParameters);
EditorGUI.indentLevel--;
GUILayout.EndVertical();
}
GUILayout.Space(16);
if (selectedFolderRef != null)
{
if (GUILayout.Button("Create the new Enemy : \"" + newEnemyName + "\" !"))
{
string finalFolderPath = selectedFolderRef.GetFolderPath();
if (createFolder)
{
string folderCreationPath = finalFolderPath;
finalFolderPath = AssetDatabase.GenerateUniqueAssetPath(finalFolderPath + "/" + newEnemyName + " Set");
AssetDatabase.CreateFolder(folderCreationPath, newEnemyName + " Set");
}
EnemySpaceShipScript newEnemyTempObj = EnemyCreationParameters.ComposeEnemy(enemyCreationParameters, newEnemyName);
EnemySpaceShipScript newEnemyPrefab = EditorStaticMethods.CreateEnemyPrefabInFolder(finalFolderPath, newEnemyTempObj);
if (newEnemyPrefab == null)
{
Debug.LogError("Couldn't create enemy Set");
return;
}
WeaponScript newWeaponPrefab = null;
if (createLinkedWeaponObject)
{
WeaponScript newWeapon = WeaponCreationParameters.ComposeWeapon(newWeaponCreationParameters, newWeaponName);
newWeaponPrefab = EditorStaticMethods.CreateWeaponObjectInFolder(finalFolderPath, newWeapon);
}
WeaponParameters newWeaponParameters = null;
if (newWeaponPrefab != null)
{
newWeaponParameters = EditorStaticMethods.CreateWeaponSetInFolder(finalFolderPath, newWeaponName, newWeaponPrefab);
}
else
{
newWeaponParameters = EditorStaticMethods.CreateWeaponSetInFolder(finalFolderPath, newWeaponName);
}
newEnemyPrefab.GetShootingSystem.SetWeaponParameters(newWeaponParameters);
Selection.activeObject = newEnemyPrefab;
EditorGUIUtility.PingObject(newEnemyPrefab);
#region Library
//LevelPrefabsLibrary enemiesLibrary = AssetDatabase.LoadAssetAtPath("Assets/Resources/Level Prefabs Library.asset", typeof(LevelPrefabsLibrary)) as LevelPrefabsLibrary;
ScriptableObject library = Resources.Load("Level Prefabs Library") as ScriptableObject;
LevelPrefabsLibrary prefabsLibrary = library as LevelPrefabsLibrary;
if (prefabsLibrary == null)
{
Debug.LogError("Library Not Found");
return;
}
prefabsLibrary.AddEnemyPrefabInformations(newEnemyPrefab.gameObject, enemyCreationParameters.enemyIdentifyingColor);
EditorUtility.SetDirty(prefabsLibrary);
#endregion
}
}
EditorGUIUtility.labelWidth = oldWidth;
}
public static Weapon CreateWeapon(WeaponParameters parameters)
{
if (parameters.WeaponType == ItemType.Cannon)
{
return(new Cannon
(
weight: parameters.Weight,
volume: parameters.Volume,
energyCost: Helpers.ParseFloat(parameters.Param1),
cooldown: Helpers.ParseFloat(parameters.Param2),
scrapCost: Helpers.ParseFloat(parameters.Param3),
recoil: Helpers.ParseFloat(parameters.Param4),
projectileSpeed: Helpers.ParseFloat(parameters.Param5),
range: Helpers.ParseFloat(parameters.Param6),
damage: Helpers.ParseFloat(parameters.Param7)
));
}
else if (parameters.WeaponType == ItemType.EMPGenerator)
{
return(new EMPGenerator
(
weight: parameters.Weight,
volume: parameters.Volume,
energyCost: Helpers.ParseFloat(parameters.Param1),
cooldown: Helpers.ParseFloat(parameters.Param2),
aoe: Helpers.ParseFloat(parameters.Param4),
damage: Helpers.ParseFloat(parameters.Param5)
));
}
else if (parameters.WeaponType == ItemType.Flamethrower)
{
return(new Flamethrower
(
weight: parameters.Weight,
volume: parameters.Volume,
energyCost: Helpers.ParseFloat(parameters.Param1),
range: Helpers.ParseFloat(parameters.Param2),
damage: Helpers.ParseFloat(parameters.Param3)
));
}
else if (parameters.WeaponType == ItemType.Hangar)
{
return(new Hangar
(
weight: parameters.Weight,
volume: parameters.Volume,
energyCost: Helpers.ParseFloat(parameters.Param1),
cooldown: Helpers.ParseFloat(parameters.Param2),
minionConfiguration: parameters.Param3
));
}
else if (parameters.WeaponType == ItemType.Harpoon)
{
return(new Harpoon
(
weight: parameters.Weight,
volume: parameters.Volume,
energyCost: Helpers.ParseFloat(parameters.Param1),
cooldown: Helpers.ParseFloat(parameters.Param2),
recoil: Helpers.ParseFloat(parameters.Param3),
damage: Helpers.ParseFloat(parameters.Param4),
speed: Helpers.ParseFloat(parameters.Param5),
range: Helpers.ParseFloat(parameters.Param6),
duration: Helpers.ParseFloat(parameters.Param7)
));
}
else if (parameters.WeaponType == ItemType.Laser)
{
return(new Laser
(
weight: parameters.Weight,
volume: parameters.Volume,
energyCost: Helpers.ParseFloat(parameters.Param1),
range: Helpers.ParseFloat(parameters.Param2),
damage: Helpers.ParseFloat(parameters.Param3)
));
}
else if (parameters.WeaponType == ItemType.MineLayer)
{
return(new MineLayer
(
weight: parameters.Weight,
volume: parameters.Volume,
energyCost: Helpers.ParseFloat(parameters.Param1),
cooldown: Helpers.ParseFloat(parameters.Param2),
scrapCost: Helpers.ParseFloat(parameters.Param3),
aoe: Helpers.ParseFloat(parameters.Param4),
damage: Helpers.ParseFloat(parameters.Param5)
));
}
else if (parameters.WeaponType == ItemType.RocketLauncher)
{
return(new RocketLauncher
(
weight: parameters.Weight,
volume: parameters.Volume,
energyCost: Helpers.ParseFloat(parameters.Param1),
cooldown: Helpers.ParseFloat(parameters.Param2),
scrapCost: Helpers.ParseFloat(parameters.Param3),
recoil: Helpers.ParseFloat(parameters.Param4),
range: Helpers.ParseFloat(parameters.Param5),
initialSpeed: Helpers.ParseFloat(parameters.Param6),
maximumSpeed: Helpers.ParseFloat(parameters.Param7),
acceleration: Helpers.ParseFloat(parameters.Param8),
turnRate: Helpers.ParseFloat(parameters.Param9),
aoe: Helpers.ParseFloat(parameters.Param10),
damage: Helpers.ParseFloat(parameters.Param11)
));
}
else
{
return(null);
}
}
