public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
GameObject go;
if (processedPrefab != null)
{
go = GameObject.Instantiate(processedPrefab);
go.SetActive(true);
gameObject.Set(go);
yield break;
}
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TypeToClone);
yield return(task);
GameObject prefab = task.GetResult();
if (prefab != null)
{
processedPrefab = GameObject.Instantiate(prefab);
processedPrefab.SetActive(false);
}
go = GameObject.Instantiate(processedPrefab);
go.SetActive(true);
gameObject.Set(go);
yield break;
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
Stillsuit s;
if (prefab == null)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.ColdSuit, verbose: true);
yield return(task);
prefab = task.GetResult();
//prefab.SetActive(false); // Keep the prefab inactive until we're done editing it.
// Editing prefab
if (prefab.TryGetComponent <Stillsuit>(out s))
{
GameObject.DestroyImmediate(s);
}
prefab.EnsureComponent <SurvivalsuitBehaviour>();
ModPrefabCache.AddPrefab(prefab, false); // This doesn't actually do any caching, but it does disable the prefab without "disabling" it - the prefab doesn't show up in the world [as with SetActive(false)]
// but it can still be instantiated. [unlike with SetActive(false)]
}
// Despite the component being removed from the prefab above, testing shows that the Survival Suits still add the water packs when they should.
// So we're going to force-remove it here, to be safe.
GameObject go = GameObject.Instantiate(prefab);
if (go.TryGetComponent <Stillsuit>(out s))
{
GameObject.DestroyImmediate(s);
}
gameObject.Set(go);
}
public ProcessBlock(AbsTimeGenerator _timeGenerator, IOut _queue, IIn _nextBlock)
{
m_isRequestHere = false;
m_timeGenerator = _timeGenerator;
m_queue = _queue;
m_nextBlock = _nextBlock;
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
GameObject go;
if (processedPrefab != null)
{
go = GameObject.Instantiate(processedPrefab);
go.SetActive(true);
gameObject.Set(go);
yield break;
}
GameObject prefab = Utils.CreateGenericLoot(this.TechType);
if (prefab != null)
{
processedPrefab = GameObject.Instantiate(prefab);
processedPrefab.SetActive(false);
}
go = GameObject.Instantiate(processedPrefab);
go.SetActive(true);
gameObject.Set(go);
yield break;
}
/// <summary>
/// INTERNAL ARM SPAWNING METHOD, DON'T OVERRIDE! Use ModifyGameObject() instead!
/// Initializes the visual appearance of the arm in the open world or in the inventory.
/// </summary>
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> request = CraftData.GetPrefabForTechTypeAsync(PrefabForClone);
yield return(request);
GameObject result = request.GetResult();
if (result == null)
{
BZLogger.Warn("API message: Cannot instantiate prefab from TechType!");
yield break;
}
PrefabClone = Object.Instantiate(result);
PrefabClone.name = TechTypeName;
if (ArmTemplate == ArmTemplate.ClawArm)
{
OverrideClawArm();
}
PrefabClone.transform.localScale = new Vector3(0.8f, 0.8f, 0.8f);
PostModify();
gameObject.Set(PrefabClone);
yield break;
}
private IEnumerator ChooseRandomResourceAsync(IOut <GameObject> result)
{
for (int i = 0; i < drillable.resources.Length; i++)
{
Drillable.ResourceType resourceType = drillable.resources[i];
if (resourceType.chance >= 1f)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(resourceType.techType, true);
yield return(task);
result.Set(task.GetResult());
break;
}
if (Player.main.gameObject.GetComponent <PlayerEntropy>().CheckChance(resourceType.techType, resourceType.chance))
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(resourceType.techType, true);
yield return(task);
result.Set(task.GetResult());
break;
}
}
yield break;
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
//Logger.Log("AutosortStandingTargetBuildable.GetGameObjectAsync: 1");
TaskResult <GameObject> result = new TaskResult <GameObject>();
yield return(GetPrefabAsync(TechType.Locker, result));
//Logger.Log("AutosortStandingTargetBuildable.GetGameObjectAsync: 2");
GameObject basePrefab = result.Get();
GameObject prefab = GameObject.Instantiate(basePrefab);
//Logger.Log("AutosortStandingTargetBuildable.GetGameObjectAsync: 3");
StorageContainer container = prefab.GetComponent <StorageContainer>();
//Logger.Log("AutosortStandingTargetBuildable.GetGameObjectAsync: 3.1");
container.width = Mod.config.StandingReceptacleWidth;
//Logger.Log("AutosortStandingTargetBuildable.GetGameObjectAsync: 3.2");
container.height = Mod.config.StandingReceptacleHeight;
//Logger.Log("AutosortStandingTargetBuildable.GetGameObjectAsync: 3.3, container.container " + (container.container == null ? "is" : "is not") + " null");
container.Resize(Mod.config.StandingReceptacleWidth, Mod.config.StandingReceptacleHeight);
//Logger.Log("AutosortStandingTargetBuildable.GetGameObjectAsync: 4");
gameObject.Set(prefab);
yield break;
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
IPrefabRequest request = PrefabDatabase.GetPrefabForFilenameAsync("WorldEntities/Alterra/DataBoxes/BeaconDataBox.prefab");
yield return(request);
request.TryGetPrefab(out GameObject prefab);
GameObject obj = GameObject.Instantiate(prefab);
obj.name = ClassID;
obj.SetActive(false);
obj.GetComponent <PrefabIdentifier>().classId = this.ClassID;
BlueprintHandTarget blueprintHandTarget = obj.GetComponent <BlueprintHandTarget>();
blueprintHandTarget.alreadyUnlockedTooltip = this.alreadyUnlockedTooltip;
blueprintHandTarget.primaryTooltip = this.primaryTooltip;
blueprintHandTarget.secondaryTooltip = this.secondaryTooltip;
blueprintHandTarget.unlockTechType = this.unlockTechType;
obj.SetActive(true);
gameObject.Set(obj);
}
protected IEnumerator AddInventoryAsync(TechType techType, IOut <GameObject> result = null)
{
#if SUBNAUTICA_STABLE
GameObject go = CraftData.InstantiateFromPrefab(techType, false);
#elif BELOWZERO
TaskResult <GameObject> instResult = new TaskResult <GameObject>();
yield return(CraftData.InstantiateFromPrefabAsync(techType, instResult, false));
GameObject go = instResult.Get();
#endif
Pickupable component = go?.GetComponent <Pickupable>();
if (component != null)
{
Inventory.main.ForcePickup(component);
}
else
{
Log.LogError($"DiverPerimeterDefenceBehaviour.AddInventoryAsync(): Failed to instantiate inventory item for TechType {techType.AsString()}");
}
if (result != null)
{
result.Set(go);
}
yield break;
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(this.PrefabType);
yield return(task);
gameObject.Set(ModifyPrefab(task.GetResult()));
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.ReinforcedDiveSuit);
yield return(task);
gameObject.Set(task.GetResult());
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.ReinforcedGloves);
yield return(task);
gameObject.Set(ModifyAndInstantiateGameObject(task.GetResult()));
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task;
Oxygen oxy;
if (prefab == null)
{
Log.LogDebug($"HighCapacityBooster.GetGameObjectAsync: getting SuitBoosterTank prefab");
task = CraftData.GetPrefabForTechTypeAsync(TechType.SuitBoosterTank, verbose: true);
yield return(task);
prefab = GameObject.Instantiate(task.GetResult());
ModPrefabCache.AddPrefab(prefab, false); // This doesn't actually do any caching, but it does disable the prefab without "disabling" it - the prefab doesn't show up in the world [as with SetActive(false)] but it can still be instantiated.
//HighCapacityBooster.prefab = prefab;
}
if (highCapTank == null)
{
Log.LogDebug($"HighCapacityBooster.GetGameObjectAsync: getting HighCapacityTank prefab");
task = CraftData.GetPrefabForTechTypeAsync(TechType.HighCapacityTank, verbose: true);
yield return(task);
highCapTank = GameObject.Instantiate(task.GetResult()); // The "capacity expansion" code in Customise Your Oxygen can't run unless the thing is instantiated. The prefabs can't be altered.
// So unless we instantiate, we only get default capacities.
ModPrefabCache.AddPrefab(highCapTank, false); // This doesn't actually do any caching, but it does disable the prefab without "disabling" it - the prefab doesn't show up in the world [as with SetActive(false)] but it can still be instantiated.
}
GameObject go = GameObject.Instantiate(prefab);
Oxygen highCapOxygen = highCapTank.GetComponent <Oxygen>();
//Oxygen highCapOxygen = task.GetResult().GetComponent<Oxygen>();
if (highCapOxygen != null)
{
oxy = go.EnsureComponent <Oxygen>();
if (oxy != null)
{
float oxygenCapacity = highCapOxygen.oxygenCapacity;
Log.LogDebug($"Found Oxygen component with capacity of {oxygenCapacity} for prefab HighCapacityTank and existing oxygen capacity of {oxy.oxygenCapacity} for prefab HighCapacityBooster.");
oxy.oxygenCapacity = oxygenCapacity;
}
else
{
Log.LogError($"Could not get Oxygen component of SuitBoosterTank while generating HighCapacityBooster");
}
GameObject.Destroy(highCapOxygen);
}
else
{
Log.LogError($"Could not get Oxygen component of HighCapacityTank while generating HighCapacityBooster");
}
float oxyCap = prefab.GetComponent <Oxygen>().oxygenCapacity;
Log.LogDebug($"GameObject created with oxygenCapacity of {oxyCap}");
gameObject.Set(go);
}
public static IEnumerator getPrefabCopyAsync(TechType techType, IOut <GameObject> result, CopyOptions options = CopyOptions.Default)
{
$"PrefabUtils: getPrefabCopyAsync(TechType.{techType})".logDbg();
TaskResult <GameObject> prefabResult = new();
yield return(CraftData.GetPrefabForTechTypeAsync(techType, false, prefabResult));
result.Set(_instantiate(prefabResult.Get(), options));
}
public static IEnumerator getPrefabCopyAsync(string filename, IOut <GameObject> result, CopyOptions options = CopyOptions.Default)
{
$"PrefabUtils: getPrefabCopyAsync(\"{filename}\")".logDbg();
TaskResult <GameObject> prefabResult = new();
yield return(getPrefabAsync(filename, prefabResult));
result.Set(_instantiate(prefabResult.Get(), options));
}
/// <summary>
/// Sets the SQL parameter value.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parameter">The parameter.</param>
/// <param name="value">The value.</param>
/// <param name="mode">The mode.</param>
/// <exception cref="ArgumentNullException"><paramref name="parameter"/> is <see langword="null" />.</exception>
/// <exception cref="DatabaseSchemaException"><para>The type <typeparamref name="T" /> is invalid for the <see cref="Direction" />.</para>
/// <para>-or-</para>
/// <para>The type <typeparamref name="T" /> was unsupported.</para>
/// <para>-or-</para>
/// <para>A fatal error occurred.</para>
/// <para>-or-</para>
/// <para>The object exceeded the SQL type's maximum <see cref="SqlTypeSize">size</see>.</para>
/// <para>-or-</para>
/// <para>The serialized object was truncated.</para>
/// <para>-or-</para>
/// <para>Unicode characters were found and only ASCII characters are supported in the SQL type.</para>
/// <para>-or-</para>
/// <para>The date was outside the range of accepted dates for the SQL type.</para></exception>
public void SetSqlParameterValue <T>(
[NotNull] SqlParameter parameter,
T value,
TypeConstraintMode mode = TypeConstraintMode.Warn)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (value == null)
{
parameter.Value = Type.IsTable ? null : DBNull.Value;
return;
}
IOut output = value as IOut;
if (output != null)
{
bool hasInput = output?.InputValue.IsAssigned ?? false;
string dir = hasInput ? "input/output" : "output";
switch (Direction)
{
case ParameterDirection.Input:
throw new DatabaseSchemaException(
LoggingLevel.Error,
() => "Cannot pass {0} value to input only parameter {1}",
dir,
FullName);
case ParameterDirection.Output:
case ParameterDirection.ReturnValue:
if (hasInput)
{
throw new DatabaseSchemaException(
LoggingLevel.Error,
() => "Cannot pass {0} value to output only parameter {1}",
dir,
FullName);
}
break;
}
output.SetParameter(parameter);
if (hasInput)
{
parameter.Value = Type.CastCLRValue(output.InputValue.Value, output.Type, mode);
}
}
else
{
parameter.Value = Type.CastCLRValue(value, mode);
}
}
public override IEnumerator GetGameObjectAsync(IOut<GameObject> gameObject)
{
CoroutineTask<GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.SmallLocker);
yield return task;
var smallLockerPrefab = task.GetResult();
GameObject prefab = GameObject.Instantiate(smallLockerPrefab);
var storageAccess = prefab.EnsureComponent<VehicleStorageAccess>();
storageAccess.textPrefab = GameObject.Instantiate(smallLockerPrefab.GetComponentInChildren<TextMeshProUGUI>());
#endif
var container = prefab.EnsureComponent<StorageContainer>();
container.width = Mod.config.LockerWidth;
container.height = Mod.config.LockerHeight;
container.container.Resize(Mod.config.LockerWidth, Mod.config.LockerHeight);
var meshRenderers = prefab.GetComponentsInChildren<MeshRenderer>();
foreach (var meshRenderer in meshRenderers)
{
meshRenderer.material.color = new Color(0, 0, 1);
}
var label = prefab.FindChild("Label");
DestroyImmediate(label);
var canvas = LockerPrefabShared.CreateCanvas(prefab.transform);
storageAccess.background = LockerPrefabShared.CreateBackground(canvas.transform);
storageAccess.icon = LockerPrefabShared.CreateIcon(storageAccess.background.transform, PrimaryColor, 15);
storageAccess.text = LockerPrefabShared.CreateText(storageAccess.background.transform, storageAccess.textPrefab, PrimaryColor, -40, 10, "");
storageAccess.seamothIcon = LockerPrefabShared.CreateIcon(storageAccess.background.transform, PrimaryColor, 80);
storageAccess.seamothCountText = LockerPrefabShared.CreateText(storageAccess.background.transform, storageAccess.textPrefab, PrimaryColor, 55, 10, "none");
storageAccess.exosuitIcon = LockerPrefabShared.CreateIcon(storageAccess.background.transform, PrimaryColor, 80);
storageAccess.exosuitCountText = LockerPrefabShared.CreateText(storageAccess.background.transform, storageAccess.textPrefab, PrimaryColor, 55, 10, "none");
storageAccess.seamothIcon.rectTransform.anchoredPosition += new Vector2(-23, 0);
storageAccess.seamothCountText.rectTransform.anchoredPosition += new Vector2(-23, 0);
storageAccess.exosuitIcon.rectTransform.anchoredPosition += new Vector2(23, 0);
storageAccess.exosuitCountText.rectTransform.anchoredPosition += new Vector2(23, 0);
if (Mod.config.UseAutosortMod)
{
storageAccess.autosortCheckbox = CheckboxButton.CreateCheckbox(storageAccess.background.transform, PrimaryColor, storageAccess.textPrefab, "Autosort");
storageAccess.autosortCheckbox.transform.localPosition = new Vector3(0, -104 + 19);
}
storageAccess.enableCheckbox = CheckboxButton.CreateCheckbox(storageAccess.background.transform, PrimaryColor, storageAccess.textPrefab, "Enabled");
storageAccess.enableCheckbox.transform.localPosition = new Vector3(0, -104);
storageAccess.background.gameObject.SetActive(false);
#if SN1
return prefab;
#elif BZ
gameObject.Set(prefab);
#endif
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
if (processedPrefab == null)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.SeaglideFragment);
yield return(task);
GameObject prefab = GameObject.Instantiate(task.GetResult());
MeshRenderer[] meshRenderers = prefab.GetAllComponentsInChildren <MeshRenderer>();
SkinnedMeshRenderer[] skinnedMeshRenderers = prefab.GetAllComponentsInChildren <SkinnedMeshRenderer>();
Color powerGlideColour = new Color(PowerglideEquipable.PowerglideColourR, PowerglideEquipable.PowerglideColourG, PowerglideEquipable.PowerglideColourB);
foreach (MeshRenderer mr in meshRenderers)
{
// MeshRenderers have the third-person mesh, apparently?
if (mr.name.Contains("SeaGlide_01_damaged"))
{
mr.material.color = powerGlideColour;
}
}
foreach (SkinnedMeshRenderer smr in skinnedMeshRenderers)
{
if (smr.name.Contains("SeaGlide_geo"))
{
smr.material.color = powerGlideColour;
}
}
PrefabIdentifier prefabIdentifier = prefab.GetComponent <PrefabIdentifier>();
prefabIdentifier.ClassId = this.ClassID;
prefab.GetComponent <LargeWorldEntity>().cellLevel = LargeWorldEntity.CellLevel.VeryFar;
prefab.EnsureComponent <TechTag>().type = this.TechType;
Pickupable pickupable = prefab.GetComponent <Pickupable>();
pickupable.isPickupable = false;
ResourceTracker resourceTracker = prefab.EnsureComponent <ResourceTracker>();
resourceTracker.prefabIdentifier = prefabIdentifier;
typeof(ResourceTracker).GetField("techType", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(resourceTracker, this.TechType);
//resourceTracker.techType = this.TechType;
resourceTracker.overrideTechType = TechType.Fragment;
resourceTracker.rb = prefab.GetComponent <Rigidbody>();
resourceTracker.pickupable = pickupable;
prefab.SetActive(true);
processedPrefab = prefab;
ModPrefabCache.AddPrefab(processedPrefab, false); // This doesn't actually do any caching, but it does disable the prefab without "disabling" it - the prefab doesn't show up in the world [as with SetActive(false)]
// but it can still be instantiated. [unlike with SetActive(false)]
}
gameObject.Set(processedPrefab);
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(Original, false);
yield return(task);
GameObject prefab = task.GetResult();
gameObject.Set(GameObject.Instantiate(prefab));
yield break;
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(PrefabTemplate);
yield return(task);
GameObject prefab = task.GetResult();
GameObject obj = Object.Instantiate(prefab);
gameObject.Set(obj);
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.SeamothSonarModule, false);
yield return(task);
GameObject gameObject1 = GameObject.Instantiate(task.GetResult());
gameObject.Set(gameObject1);
yield break;
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
if (prefab == null)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.HoverbikeJumpModule);
yield return(task);
prefab = GameObject.Instantiate <GameObject>(task.GetResult());
}
gameObject.Set(GameObject.Instantiate(prefab));
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
if (prefab == null)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.SeaglideFragment);
yield return(task);
prefab = PreparePrefab(task.GetResult());
}
gameObject.Set(prefab);
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.SmallLocker);
yield return(task);
GameObject originalPrefab = task.GetResult();
GameObject prefab = GameObject.Instantiate(originalPrefab);
StorageContainer container = prefab.GetComponent <StorageContainer>();
container.width = Mod.config.AutosorterWidth;
container.height = Mod.config.AutosorterHeight;
container.Resize(Mod.config.AutosorterWidth, Mod.config.AutosorterHeight);
var meshRenderers = prefab.GetComponentsInChildren <MeshRenderer>();
foreach (var meshRenderer in meshRenderers)
{
meshRenderer.material.color = new Color(1, 0, 0);
}
#if SUBNAUTICA
var prefabText = prefab.GetComponentInChildren <Text>();
#elif BELOWZERO
var prefabText = prefab.GetComponentInChildren <TextMeshProUGUI>();
#endif
var label = prefab.FindChild("Label");
DestroyImmediate(label);
var autoSorter = prefab.AddComponent <AutosortLocker>();
var canvas = LockerPrefabShared.CreateCanvas(prefab.transform);
autoSorter.background = LockerPrefabShared.CreateBackground(canvas.transform, autoSorter.name);
autoSorter.icon = LockerPrefabShared.CreateIcon(autoSorter.background.transform, MainColor, 40);
// The first number is the vertical position, the second number is the font
autoSorter.text = LockerPrefabShared.CreateText(autoSorter.background.transform, prefabText, MainColor, 0, 14, "Autosorter", "Autosorter");
autoSorter.text.rectTransform.anchoredPosition += new Vector2(20, 0);
autoSorter.sortingText = LockerPrefabShared.CreateText(autoSorter.background.transform, prefabText, MainColor, -120, 18, "Sorting...", "Autosorter");
#if SUBNAUTICA
autoSorter.sortingText.alignment = TextAnchor.UpperCenter;
#elif BELOWZERO
autoSorter.sortingText.alignment = TextAlignmentOptions.Top;
#endif
autoSorter.background.gameObject.SetActive(false);
autoSorter.icon.gameObject.SetActive(false);
autoSorter.text.gameObject.SetActive(false);
autoSorter.sortingText.gameObject.SetActive(false);
gameObject.Set(prefab);
yield break;
}
public override IEnumerator GetGameObjectAsync(IOut<GameObject> gameObject)
{
if (prefab == null)
{
CoroutineTask<GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.HoverbikeJumpModule);
yield return task;
prefab = GameObject.Instantiate<GameObject>(task.GetResult());
ModPrefabCache.AddPrefab(prefab, false); // This doesn't actually do any caching, but it does disable the prefab without "disabling" it - the prefab doesn't show up in the world [as with SetActive(false)]
// but it can still be instantiated. [unlike with SetActive(false)]
}
gameObject.Set(GameObject.Instantiate(prefab));
}
//public override string AssetsFolder => Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),"Assets");
//public override string IconFileName => "MetalHandsMK1.png";
//public override bool HasSprite => true;
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.ColdSuitGloves);
yield return(task);
GameObject prefab = task.GetResult();
GameObject obj = GameObject.Instantiate(prefab);
prefab.SetActive(false);
gameObject.Set(obj);
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
if (prefab == null)
{
var task = CraftData.GetPrefabForTechTypeAsync(TechType.MapRoomHUDChip);
yield return(task);
prefab = GameObject.Instantiate(task.GetResult());
ModPrefabCache.AddPrefab(prefab, false); // This doesn't actually do any caching, but it does disable the prefab without "disabling" it - the prefab doesn't show up in the world [as with SetActive(false)] but it can still be instantiated.
}
gameObject.Set(prefab);
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
if (prefab == null)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.SeaTruckUpgradeEnergyEfficiency);
yield return(task);
prefab = GameObject.Instantiate(task.GetResult());
Battery cell = prefab.EnsureComponent <Battery>();
cell.name = "SolarBackupBattery";
cell._capacity = cellCapacity;
}
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.HeatBlade);
yield return(task);
hbPrefab = task.GetResult();
task = CraftData.GetPrefabForTechTypeAsync(TechType.DiamondBlade);
yield return(task);
prefab = SetupPrefab(task.GetResult());
gameObject.Set(prefab);
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
if (prefab == null)
{
CoroutineTask <GameObject> task = CraftData.GetPrefabForTechTypeAsync(TechType.SeaTruckUpgradeEnergyEfficiency);
yield return(task);
prefab = GameObject.Instantiate <GameObject>(task.GetResult());
// The code is handled by the SeatruckUpdater component, rather than anything here.
ModPrefabCache.AddPrefab(prefab, false); // This doesn't actually do any caching, but it does disable the prefab without "disabling" it - the prefab doesn't show up in the world [as with SetActive(false)]
// but it can still be instantiated. [unlike with SetActive(false)]
}
gameObject.Set(GameObject.Instantiate(prefab));
}
public override IEnumerator GetGameObjectAsync(IOut <GameObject> gameObject)
{
var task = CraftData.GetPrefabForTechTypeAsync(TechType.DioramaHullPlate);
yield return(task);
var _GameObject = Object.Instantiate(task.GetResult());
var meshRenderer = _GameObject.FindChild("Icon").GetComponent <MeshRenderer>();
meshRenderer.material.mainTexture = hullPlateTexture;
_GameObject.name = ClassID;
gameObject.Set(_GameObject);
}
public AttackingSituationRule(IOut @out, ComponentService componentService)
{
_out = @out;
_componentService = componentService;
}
public DoNothingSituationRule(IOut @out)
{
_out = @out;
}
