/// <summary>
/// Adds the effect with name effectName to info
/// </summary>
public static bool AddEffect(VehicleInfo info, string effectName, Vehicle.Flags flagsRequired = Vehicle.Flags.Created, Vehicle.Flags flagsForbidden = 0)
{
EffectInfo effect = EffectCollection.FindEffect(effectName);
if (effect == null)
{
return(false);
}
int size = info.m_effects != null ? info.m_effects.Length + 1 : 1;
VehicleInfo.Effect[] tmp = new VehicleInfo.Effect[size];
if (size > 1)
{
Array.Copy(info.m_effects, tmp, size - 1);
}
var newEffect = new VehicleInfo.Effect
{
m_effect = effect,
m_parkedFlagsForbidden = VehicleParked.Flags.Created,
m_parkedFlagsRequired = VehicleParked.Flags.None,
m_vehicleFlagsForbidden = flagsForbidden,
m_vehicleFlagsRequired = flagsRequired,
};
tmp[size - 1] = newEffect;
info.m_effects = tmp;
return(true);
}
public void Display(VehicleInfo.Effect effect, int index)
{
if (m_buttonFlagsForbidden == null)
{
return;
}
m_effect = effect;
m_index = index;
m_buttonFlagsRequired.tooltip = m_effect.m_vehicleFlagsRequired.ToString();
m_buttonFlagsForbidden.tooltip = m_effect.m_vehicleFlagsForbidden.ToString();
m_buttonParkedFlagsRequired.tooltip = m_effect.m_parkedFlagsRequired.ToString();
m_buttonParkedFlagsForbidden.tooltip = m_effect.m_parkedFlagsForbidden.ToString();
m_nameLabel.text = m_effect.m_effect != null ? m_effect.m_effect.name : "ERROR: Missing effect!";
var le = m_effect.m_effect as LightEffect;
if (le != null && le.m_positionIndex >= 0)
{
m_indexLabel.text = "Light index: " + le.m_positionIndex;
}
else
{
m_indexLabel.text = "Light index: None";
}
var me = m_effect.m_effect as MultiEffect;
if (me != null)
{
m_subEffectsLabel.text = "";
foreach (var se in me.m_effects)
{
if (se.m_effect != null)
{
m_subEffectsLabel.text += se.m_effect.name;
var sle = se.m_effect as LightEffect;
if (sle != null && sle.m_positionIndex >= 0)
{
m_subEffectsLabel.text += " (Light index " + sle.m_positionIndex + ")";
}
}
else
{
m_subEffectsLabel.text += "ERROR: Missing effect!";
}
m_subEffectsLabel.text += "\r\n";
}
}
else
{
m_subEffectsLabel.text = "None";
}
}
public void ChangeEffect(VehicleInfo.Effect data, int index)
{
if (m_vehicle != null)
{
if (m_vehicle.m_effects == null || index < 0 || index >= m_vehicle.m_effects.Length)
{
return;
}
m_vehicle.m_effects[index] = data;
}
}
public void AddEffect(VehicleInfo.Effect effectData)
{
if (m_vehicle != null)
{
var array = new VehicleInfo.Effect[m_vehicle.m_effects.Length + 1];
m_vehicle.m_effects.CopyTo(array, 0);
array[m_vehicle.m_effects.Length] = effectData;
m_vehicle.m_effects = array;
PopulateList();
m_effectList.DisplayAt(m_vehicle.m_effects.Length - 1);
m_effectList.selectedIndex = m_vehicle.m_effects.Length - 1;
}
}
// Run before the original method. Skip the original one if the vehicle is a cable car
public static bool Prefix(RenderManager.CameraInfo cameraInfo, VehicleInfo info, Vector3 position, ref Quaternion rotation, Vector3 swayPosition, Vector4 lightState, Vector4 tyrePosition, Vector3 velocity, float acceleration, Color color, Vehicle.Flags flags, int variationMask, InstanceID id, bool underground, bool overground)
{
// if the vehicle is not a cable car, skip and use the original method
if ((int)info.m_vehicleType != 0x1000)
{
return(true);
}
// limit rotation along the x and z axes for all meshes except submesh1
// submesh1 would rotate in the original way(along with the cable)
Quaternion originalRotation = rotation;
rotation.x = 0.0f;
rotation.z = 0.0f;
// change how cable cars sway
// so they don't move up and down on the cables as if they're ships moving in sea waves
swayPosition.y = 0.0f;
if ((cameraInfo.m_layerMask & (1 << info.m_prefabDataLayer)) == 0)
{
// return false to skip the original method
return(false);
}
Vector3 scale = Vector3.one;
if ((flags & Vehicle.Flags.Inverted) != 0)
{
scale = new Vector3(-1f, 1f, -1f);
Vector4 vector = lightState;
lightState.x = vector.y;
lightState.y = vector.x;
lightState.z = vector.w;
lightState.w = vector.z;
}
info.m_vehicleAI.RenderExtraStuff(id.Vehicle, ref Singleton <VehicleManager> .instance.m_vehicles.m_buffer[id.Vehicle], cameraInfo, id, position, rotation, tyrePosition, lightState, scale, swayPosition, underground, overground);
if (cameraInfo.CheckRenderDistance(position, info.m_lodRenderDistance))
{
VehicleManager instance = Singleton <VehicleManager> .instance;
Matrix4x4 bodyMatrix = info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref rotation, ref scale, ref swayPosition);
Matrix4x4 originalBodyMatrix = info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref originalRotation, ref scale, ref swayPosition);
Matrix4x4 value = info.m_vehicleAI.CalculateTyreMatrix(flags, ref position, ref rotation, ref scale, ref bodyMatrix);
if (Singleton <InfoManager> .instance.CurrentMode == InfoManager.InfoMode.None)
{
RenderGroup.MeshData effectMeshData = info.m_vehicleAI.GetEffectMeshData();
EffectInfo.SpawnArea area = new EffectInfo.SpawnArea(bodyMatrix, effectMeshData, info.m_generatedInfo.m_tyres, info.m_lightPositions);
if (info.m_effects != null)
{
for (int i = 0; i < info.m_effects.Length; i++)
{
VehicleInfo.Effect effect = info.m_effects[i];
if (((effect.m_vehicleFlagsRequired | effect.m_vehicleFlagsForbidden) & flags) == effect.m_vehicleFlagsRequired && effect.m_parkedFlagsRequired == VehicleParked.Flags.None)
{
effect.m_effect.RenderEffect(id, area, velocity, acceleration, 1f, -1f, Singleton <SimulationManager> .instance.m_simulationTimeDelta, cameraInfo);
}
}
}
}
if ((flags & Vehicle.Flags.Inverted) != 0)
{
tyrePosition.x = 0f - tyrePosition.x;
tyrePosition.y = 0f - tyrePosition.y;
}
MaterialPropertyBlock materialBlock = instance.m_materialBlock;
materialBlock.Clear();
materialBlock.SetMatrix(instance.ID_TyreMatrix, value);
materialBlock.SetVector(instance.ID_TyrePosition, tyrePosition);
materialBlock.SetVector(instance.ID_LightState, lightState);
bool flag = Singleton <ToolManager> .instance.m_properties.m_mode == ItemClass.Availability.AssetEditor;
if (!flag)
{
materialBlock.SetColor(instance.ID_Color, color);
}
bool flag2 = true;
if (flag)
{
flag2 = BuildingDecoration.IsMainMeshRendered();
}
if (info.m_subMeshes != null)
{
for (int j = 0; j < info.m_subMeshes.Length; j++)
{
VehicleInfo.MeshInfo meshInfo = info.m_subMeshes[j];
VehicleInfoBase subInfo = meshInfo.m_subInfo;
if ((!flag && ((meshInfo.m_vehicleFlagsRequired | meshInfo.m_vehicleFlagsForbidden) & flags) == meshInfo.m_vehicleFlagsRequired && (meshInfo.m_variationMask & variationMask) == 0 && meshInfo.m_parkedFlagsRequired == VehicleParked.Flags.None) || (flag && BuildingDecoration.IsSubMeshRendered(subInfo)))
{
if (!(subInfo != null))
{
continue;
}
instance.m_drawCallData.m_defaultCalls++;
if (underground)
{
if (subInfo.m_undergroundMaterial == null && subInfo.m_material != null)
{
VehicleProperties properties = instance.m_properties;
if (properties != null)
{
subInfo.m_undergroundMaterial = new Material(properties.m_undergroundShader);
subInfo.m_undergroundMaterial.CopyPropertiesFromMaterial(subInfo.m_material);
}
}
subInfo.m_undergroundMaterial.SetVectorArray(instance.ID_TyreLocation, subInfo.m_generatedInfo.m_tyres);
if (j == 1)
{
Graphics.DrawMesh(subInfo.m_mesh, originalBodyMatrix, subInfo.m_undergroundMaterial, instance.m_undergroundLayer, null, 0, materialBlock);
}
else
{
Graphics.DrawMesh(subInfo.m_mesh, bodyMatrix, subInfo.m_undergroundMaterial, instance.m_undergroundLayer, null, 0, materialBlock);
}
}
if (overground)
{
subInfo.m_material.SetVectorArray(instance.ID_TyreLocation, subInfo.m_generatedInfo.m_tyres);
if (j == 1)
{
Graphics.DrawMesh(subInfo.m_mesh, originalBodyMatrix, subInfo.m_material, info.m_prefabDataLayer, null, 0, materialBlock);
}
else
{
Graphics.DrawMesh(subInfo.m_mesh, bodyMatrix, subInfo.m_material, info.m_prefabDataLayer, null, 0, materialBlock);
}
}
}
else if (subInfo == null)
{
flag2 = false;
}
}
}
if (!flag2)
{
// return false to skip the original method
return(false);
}
instance.m_drawCallData.m_defaultCalls++;
if (underground)
{
if (info.m_undergroundMaterial == null && info.m_material != null)
{
VehicleProperties properties2 = instance.m_properties;
if (properties2 != null)
{
info.m_undergroundMaterial = new Material(properties2.m_undergroundShader);
info.m_undergroundMaterial.CopyPropertiesFromMaterial(info.m_material);
}
}
info.m_undergroundMaterial.SetVectorArray(instance.ID_TyreLocation, info.m_generatedInfo.m_tyres);
Graphics.DrawMesh(info.m_mesh, bodyMatrix, info.m_undergroundMaterial, instance.m_undergroundLayer, null, 0, materialBlock);
}
if (overground)
{
info.m_material.SetVectorArray(instance.ID_TyreLocation, info.m_generatedInfo.m_tyres);
Graphics.DrawMesh(info.m_mesh, bodyMatrix, info.m_material, info.m_prefabDataLayer, null, 0, materialBlock);
}
// return false to skip the original method
return(false);
}
Matrix4x4 bodyMatrix2 = info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref rotation, ref scale, ref swayPosition);
Matrix4x4 originalBodyMatrix2 = info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref originalRotation, ref scale, ref swayPosition);
if (Singleton <ToolManager> .instance.m_properties.m_mode == ItemClass.Availability.AssetEditor)
{
Matrix4x4 value2 = info.m_vehicleAI.CalculateTyreMatrix(flags, ref position, ref rotation, ref scale, ref bodyMatrix2);
VehicleManager instance2 = Singleton <VehicleManager> .instance;
MaterialPropertyBlock materialBlock2 = instance2.m_materialBlock;
materialBlock2.Clear();
materialBlock2.SetMatrix(instance2.ID_TyreMatrix, value2);
materialBlock2.SetVector(instance2.ID_TyrePosition, tyrePosition);
materialBlock2.SetVector(instance2.ID_LightState, lightState);
Mesh mesh = null;
Material material = null;
if (info.m_lodObject != null)
{
MeshFilter component = info.m_lodObject.GetComponent <MeshFilter>();
if (component != null)
{
mesh = component.sharedMesh;
}
Renderer component2 = info.m_lodObject.GetComponent <Renderer>();
if (component2 != null)
{
material = component2.sharedMaterial;
}
}
if (mesh != null && material != null)
{
materialBlock2.SetVectorArray(instance2.ID_TyreLocation, info.m_generatedInfo.m_tyres);
Graphics.DrawMesh(mesh, bodyMatrix2, material, info.m_prefabDataLayer, null, 0, materialBlock2);
}
}
else if (Singleton <InfoManager> .instance.CurrentMode == InfoManager.InfoMode.None)
{
RenderGroup.MeshData effectMeshData2 = info.m_vehicleAI.GetEffectMeshData();
EffectInfo.SpawnArea area2 = new EffectInfo.SpawnArea(bodyMatrix2, effectMeshData2, info.m_generatedInfo.m_tyres, info.m_lightPositions);
if (info.m_effects != null)
{
for (int k = 0; k < info.m_effects.Length; k++)
{
VehicleInfo.Effect effect2 = info.m_effects[k];
if (((effect2.m_vehicleFlagsRequired | effect2.m_vehicleFlagsForbidden) & flags) == effect2.m_vehicleFlagsRequired && effect2.m_parkedFlagsRequired == VehicleParked.Flags.None)
{
effect2.m_effect.RenderEffect(id, area2, velocity, acceleration, 1f, -1f, Singleton <SimulationManager> .instance.m_simulationTimeDelta, cameraInfo);
}
}
}
}
bool flag3 = true;
if (info.m_subMeshes != null)
{
for (int l = 0; l < info.m_subMeshes.Length; l++)
{
VehicleInfo.MeshInfo meshInfo2 = info.m_subMeshes[l];
VehicleInfoBase subInfo2 = meshInfo2.m_subInfo;
if (((meshInfo2.m_vehicleFlagsRequired | meshInfo2.m_vehicleFlagsForbidden) & flags) == meshInfo2.m_vehicleFlagsRequired && (meshInfo2.m_variationMask & variationMask) == 0 && meshInfo2.m_parkedFlagsRequired == VehicleParked.Flags.None)
{
if (!(subInfo2 != null))
{
continue;
}
if (underground)
{
if (l == 1)
{
subInfo2.m_undergroundLodTransforms[subInfo2.m_undergroundLodCount] = originalBodyMatrix2;
}
else
{
subInfo2.m_undergroundLodTransforms[subInfo2.m_undergroundLodCount] = bodyMatrix2;
}
subInfo2.m_undergroundLodLightStates[subInfo2.m_undergroundLodCount] = lightState;
subInfo2.m_undergroundLodColors[subInfo2.m_undergroundLodCount] = color.linear;
subInfo2.m_undergroundLodMin = Vector3.Min(subInfo2.m_undergroundLodMin, position);
subInfo2.m_undergroundLodMax = Vector3.Max(subInfo2.m_undergroundLodMax, position);
if (++subInfo2.m_undergroundLodCount == subInfo2.m_undergroundLodTransforms.Length)
{
Vehicle.RenderUndergroundLod(cameraInfo, subInfo2);
}
}
if (overground)
{
if (l == 1)
{
subInfo2.m_lodTransforms[subInfo2.m_lodCount] = originalBodyMatrix2;
}
else
{
subInfo2.m_lodTransforms[subInfo2.m_lodCount] = bodyMatrix2;
}
subInfo2.m_lodLightStates[subInfo2.m_lodCount] = lightState;
subInfo2.m_lodColors[subInfo2.m_lodCount] = color.linear;
subInfo2.m_lodMin = Vector3.Min(subInfo2.m_lodMin, position);
subInfo2.m_lodMax = Vector3.Max(subInfo2.m_lodMax, position);
if (++subInfo2.m_lodCount == subInfo2.m_lodTransforms.Length)
{
Vehicle.RenderLod(cameraInfo, subInfo2);
}
}
}
else if (subInfo2 == null)
{
flag3 = false;
}
}
}
if (!flag3)
{
return(false);
}
if (underground)
{
info.m_undergroundLodTransforms[info.m_undergroundLodCount] = bodyMatrix2;
info.m_undergroundLodLightStates[info.m_undergroundLodCount] = lightState;
info.m_undergroundLodColors[info.m_undergroundLodCount] = color.linear;
info.m_undergroundLodMin = Vector3.Min(info.m_undergroundLodMin, position);
info.m_undergroundLodMax = Vector3.Max(info.m_undergroundLodMax, position);
if (++info.m_undergroundLodCount == info.m_undergroundLodTransforms.Length)
{
Vehicle.RenderUndergroundLod(cameraInfo, info);
}
}
if (overground)
{
info.m_lodTransforms[info.m_lodCount] = bodyMatrix2;
info.m_lodLightStates[info.m_lodCount] = lightState;
info.m_lodColors[info.m_lodCount] = color.linear;
info.m_lodMin = Vector3.Min(info.m_lodMin, position);
info.m_lodMax = Vector3.Max(info.m_lodMax, position);
if (++info.m_lodCount == info.m_lodTransforms.Length)
{
Vehicle.RenderLod(cameraInfo, info);
}
}
// return false to skip the original method
return(false);
}
public static void ParseEffectDefinition(VehicleEffectsDefinition.Vehicle vehicleDef, VehicleEffectsDefinition.Effect effectDef, List <VehicleInfo.Effect> effectsList, ref HashSet <string> parseErrors)
{
if (effectDef?.Name == null)
{
parseErrors.Add(vehicleDef.Name + " - Effect name missing.");
return;
}
string effectName = (effectDef.Replacment == null) ? effectDef.Name : effectDef.Replacment;
effectName += (effectDef.Base != null) ? " - " + effectDef.Base : "";
var effectPrefab = FindEffect(effectName);
if (effectPrefab == null)
{
//This effect is either a 'special' effect or simply non existent
if (effectName.StartsWith("Vehicle Effect Wrapper"))
{
// Wrapper for effects
if (effectDef.Base != null)
{
var baseEffect = FindEffect(effectDef.Base);
if (baseEffect != null)
{
effectPrefab = CustomVehicleEffect.CreateEffect(effectDef, baseEffect);
if (effectPrefab == null)
{
parseErrors.Add(vehicleDef.Name + ": An error occured trying to create a custom effect. Check debug log for details.");
return;
}
}
else
{
// Try fallback
if (effectDef.Fallback != null)
{
Logging.Log(vehicleDef.Name + ": trying to use fallback " + effectDef.Fallback + " for " + effectName);
if (effectDef.Fallback.StartsWith("None"))
{
// None specified as fallback, just exit
return;
}
else if (effectDef.Fallback.StartsWith("Remove") && effectDef.Replacment != null)
{
// Remove the existing effect
effectName = "Remove";
effectPrefab = null;
}
else
{
baseEffect = FindEffect(effectDef.Fallback);
if (baseEffect != null)
{
effectPrefab = CustomVehicleEffect.CreateEffect(effectDef, baseEffect);
if (effectPrefab == null)
{
parseErrors.Add(vehicleDef.Name + ": An error occured trying to create a custom effect. Check debug log for details.");
return;
}
}
else
{
parseErrors.Add(vehicleDef.Name + ": Vehicle Effect Wrapper fallback " + effectDef.Fallback + " was needed for " + effectDef.Base + " but not loaded either!");
}
}
}
else
{
parseErrors.Add(vehicleDef.Name + ": Vehicle Effect Wrapper base effect " + effectDef.Base + " was not loaded and no fallback was specified!");
return;
}
}
}
else
{
parseErrors.Add(vehicleDef.Name + ": Vehicle Effect Wrapper requires a base effect but it wasn't given");
return;
}
}
else if (effectName.StartsWith("Vehicle Effect Multi"))
{
// Custom MultiEffect defined in the xml
if (effectDef.SubEffects != null)
{
List <MultiEffect.SubEffect> loadedSubEffects = new List <MultiEffect.SubEffect>();
foreach (var subEffect in effectDef.SubEffects)
{
var dummyList = new List <VehicleInfo.Effect>();
ParseEffectDefinition(vehicleDef, subEffect.Effect, dummyList, ref parseErrors);
if (dummyList.Count > 0)
{
loadedSubEffects.Add(new MultiEffect.SubEffect()
{
m_effect = dummyList[0].m_effect,
m_endTime = subEffect.EndTime,
m_startTime = subEffect.StartTime,
m_probability = subEffect.Probability
});
}
}
effectPrefab = CustomVehicleMultiEffect.CreateEffect(effectDef, loadedSubEffects.ToArray(), effectDef.Duration, effectDef.UseSimulationTime);
}
else
{
parseErrors.Add(vehicleDef.Name + " Vehicle Effect Multi with no sub effects!");
return;
}
}
else if (effectName.StartsWith("None") || effectName.StartsWith("Remove"))
{
// Not a real effect, but keywords used for removal of an existing effect.
// 'None' included for < 1.2c compatibility
effectName = "Remove";
effectPrefab = null;
}
else
{
// Try fallback
if (effectDef.Fallback != null)
{
Logging.Log(vehicleDef.Name + ": trying to use fallback " + effectDef.Fallback + " for " + effectName);
if (effectDef.Fallback.StartsWith("None"))
{
// None specified as fallback, just exit
return;
}
else if (effectDef.Fallback.StartsWith("Remove") && effectDef.Replacment != null)
{
// Remove the existing effect
effectName = "Remove";
effectPrefab = null;
}
else
{
effectPrefab = FindEffect(effectDef.Fallback);
if (effectPrefab == null)
{
parseErrors.Add(vehicleDef.Name + " requested non-existing effect " + effectName + " and fallback " + effectDef.Fallback + " could not be found either!");
return;
}
}
}
else
{
parseErrors.Add(vehicleDef.Name + " requested non-existing effect " + effectName + " and no fallback was specified");
return;
}
}
}
if (effectPrefab == null && !effectName.Equals("Remove"))
{
parseErrors.Add(vehicleDef.Name + " - Effect with name " + effectDef.Name + " not loaded.");
return;
}
var vehicleInfoEffect = new VehicleInfo.Effect
{
m_effect = effectPrefab,
m_parkedFlagsForbidden = VehicleParked.Flags.Created,
m_parkedFlagsRequired = VehicleParked.Flags.None,
m_vehicleFlagsForbidden = (Vehicle.Flags)effectDef.ForbiddenFlags,
m_vehicleFlagsRequired = ((Vehicle.Flags)effectDef.RequiredFlags) | Vehicle.Flags.Created
};
if (effectDef.Replacment == null)
{
effectsList.Add(vehicleInfoEffect);
}
else
{
int indexToRemove = -1;
for (int i = 0; i < effectsList.Count; i++)
{
if (effectsList[i].m_effect.name.Equals(effectDef.Name))
{
if (effectDef.Replacment.Equals("Remove"))
{
indexToRemove = i;
break;
}
effectsList[i] = vehicleInfoEffect;
break;
}
}
if (indexToRemove >= 0)
{
effectsList.RemoveAt(indexToRemove);
}
}
}
/// <summary>
/// Applies a vehicle definition vehicle entry.
/// </summary>
/// <param name="vehicleDef">Vehicle definition to parse.</param>
/// <param name="packageName">Package name used in error messages.</param>
/// <param name="backup">Used to store original effect array.</param>
/// <param name="parseErrors">HashSet to add parse errors to.</param>
/// <param name="noParseErrors">Optional: If true no vehicle related parse errors are given.</param>
/// <param name="vehicleDefPrefab">Optional: VehicleInfo to apply definition to.</param>
public static void ParseVehicleDefinition(VehicleEffectsDefinition.Vehicle vehicleDef, string packageName, ref Dictionary <VehicleInfo, VehicleInfo.Effect[]> backup, ref HashSet <string> parseErrors, bool noParseErrors = false, VehicleInfo vehicleDefPrefab = null)
{
if (vehicleDef?.Name == null)
{
if (!noParseErrors)
{
parseErrors.Add(packageName + " - Vehicle name missing.");
}
return;
}
if (vehicleDefPrefab == null)
{
vehicleDefPrefab = FindVehicle(vehicleDef.Name, packageName);
}
if (vehicleDefPrefab == null)
{
if (!noParseErrors)
{
parseErrors.Add(packageName + " - Vehicle with name " + vehicleDef.Name + " not loaded.");
}
return;
}
if (vehicleDef.Effects == null || vehicleDef.Effects.Count == 0)
{
if (!noParseErrors)
{
parseErrors.Add(packageName + " - No effects specified for " + vehicleDef.Name + ".");
}
return;
}
if (vehicleDef.ApplyToTrailersOnly)
{
HashSet <VehicleInfo> trailers = new HashSet <VehicleInfo>();
foreach (var trailer in vehicleDefPrefab.m_trailers)
{
if (!trailers.Contains(trailer.m_info))
{
trailers.Add(trailer.m_info);
}
}
foreach (var trailer in trailers)
{
var trailerDef = new VehicleEffectsDefinition.Vehicle();
trailerDef.Name = trailer.name;
trailerDef.Effects = vehicleDef.Effects;
ParseVehicleDefinition(trailerDef, packageName, ref backup, ref parseErrors, noParseErrors, trailer);
}
return;
}
// Backup default effects array
if (!backup.ContainsKey(vehicleDefPrefab))
{
var effects = new VehicleInfo.Effect[vehicleDefPrefab.m_effects.Length];
vehicleDefPrefab.m_effects.CopyTo(effects, 0);
backup.Add(vehicleDefPrefab, effects);
}
var vehicleEffectsList = new List <VehicleInfo.Effect>();
vehicleEffectsList.AddRange(vehicleDefPrefab.m_effects);
foreach (var effectDef in vehicleDef.Effects)
{
ParseEffectDefinition(vehicleDef, effectDef, vehicleEffectsList, ref parseErrors);
}
// Remove and log null effects
for (int i = vehicleEffectsList.Count - 1; i >= 0; i--)
{
if (vehicleEffectsList[i].m_effect == null)
{
Logging.LogWarning("Found effect that is NULL for vehicle " + vehicleDef.Name + " at index " + i + ", removing.");
vehicleEffectsList.RemoveAt(i);
}
}
// Update the VehicleInfo with the new effects
vehicleDefPrefab.m_effects = vehicleEffectsList.ToArray();
// taken from VehicleInfo.InitializePrefab
if (vehicleDefPrefab.m_effects != null)
{
for (int j = 0; j < vehicleDefPrefab.m_effects.Length; j++)
{
if (vehicleDefPrefab.m_effects[j].m_effect != null)
{
vehicleDefPrefab.m_effects[j].m_effect.InitializeEffect();
}
}
}
}
public static void OnAssetLoadedImpl(string name, object asset, Dictionary <string, byte[]> userData)
{
if (!userData.TryGetValue(DataKey, out var bytes))
{
return;
}
Debug.Log($"Found custom effect data for {name}");
var propEffectsDict = new Dictionary <string, PropInfo.Effect[]>();
var vehicleEffectsDict = new Dictionary <string, VehicleInfo.Effect[]>();
using (var stream = new MemoryStream(bytes))
{
using (var reader = new PackageReader(stream))
{
var propEffectsDictCount = reader.ReadInt32();
for (var p = 0; p < propEffectsDictCount; p++)
{
var prefabName = reader.ReadString();
var effectCount = reader.ReadInt32();
var propEffects = new List <PropInfo.Effect>(effectCount);
for (var e = 0; e < effectCount; e++)
{
var effectName = reader.ReadString();
var propEffect = new PropInfo.Effect
{
m_effect = EffectCollection.FindEffect(effectName),
m_position = reader.ReadVector3(),
m_direction = reader.ReadVector3()
};
if (propEffect.m_effect != null)
{
propEffects.Add(propEffect);
Debug.LogError($"Adding effect \"{effectName}\" for ${prefabName}");
}
else
{
Debug.LogError($"Effect \"{effectName}\" not found while loading {prefabName}!");
}
}
propEffectsDict[prefabName] = propEffects.ToArray();
}
var vehicleEffectsDictCount = reader.ReadInt32();
for (var v = 0; v < vehicleEffectsDictCount; v++)
{
var prefabName = reader.ReadString();
var effectCount = reader.ReadInt32();
var propEffects = new List <VehicleInfo.Effect>(effectCount);
for (var e = 0; e < effectCount; e++)
{
var effectName = reader.ReadString();
var vehicleEffect = new VehicleInfo.Effect
{
m_effect = EffectCollection.FindEffect(effectName),
m_vehicleFlagsRequired = (Vehicle.Flags)reader.ReadInt32(),
m_vehicleFlagsForbidden = (Vehicle.Flags)reader.ReadInt32(),
m_parkedFlagsRequired = (VehicleParked.Flags)reader.ReadInt32(),
m_parkedFlagsForbidden = (VehicleParked.Flags)reader.ReadInt32()
};
if (vehicleEffect.m_effect != null)
{
propEffects.Add(vehicleEffect);
}
else
{
Debug.LogError($"Effect \"{effectName}\" not found while loading {prefabName}!");
}
}
vehicleEffectsDict[prefabName] = propEffects.ToArray();
}
}
}
if (asset is PropInfo propPrefab)
{
ApplyCustomEffects(propPrefab, propEffectsDict);
if (propPrefab.m_variations != null)
{
foreach (var variation in propPrefab.m_variations)
{
ApplyCustomEffects(variation.m_prop, propEffectsDict);
}
}
}
else if (asset is VehicleInfo vehiclePrefab)
{
ApplyCustomEffects(vehiclePrefab, vehicleEffectsDict);
if (vehiclePrefab.m_trailers != null)
{
foreach (var trailer in vehiclePrefab.m_trailers)
{
ApplyCustomEffects(trailer.m_info, vehicleEffectsDict);
}
}
}
}