public BattleObject LoadFighter(int player_num)
{
GameObject obj = new GameObject();
BattleObject battleObj = obj.AddComponent <BattleObject>();
if (abstract_fighter_info != null)
{
AbstractFighter fighter = obj.AddComponent <AbstractFighter>();
}
if (sprite_handler_info != null)
{
SpriteHandler sprite = obj.AddComponent <SpriteHandler>();
//sprite.orientation = sprite_handler_info.orientation;
}
if (action_handler_info != null)
{
ActionHandler actions = obj.AddComponent <ActionHandler>();
//actions.action_json = action_handler_info.action_json;
//actions.starting_action = action_handler_info.starting_action;
}
if (motion_handler_info != null)
{
MotionHandler mot = obj.AddComponent <MotionHandler>();
}
if (ecb_info != null)
{
//EnvironmentCollider ecb = obj.AddComponent<EnvironmentCollider>();
}
foreach (VarData vardata in variables)
{
battleObj.SetVar(vardata.name, vardata.value);
}
battleObj.LoadComponents();
return(battleObj);
}
private void Awake()
{
pick = GetComponent <Pickupable>();
spriteHandler = spriteObject.GetComponent <SpriteHandler>();
itemAttributesV2 = gameObject.GetComponent <ItemAttributesV2>();
pick.RefreshUISlotImage();
}
private void Awake()
{
stateful = GetComponent <Stateful>();
objectBehaviour = GetComponent <ObjectBehaviour>();
integrity = GetComponent <Integrity>();
spriteHandler = GetComponentInChildren <SpriteHandler>();
}
protected override void EndProcessing()
{
SpriteHandler sh = new SpriteHandler(didInit, willMove, didMove, willDraw, didDraw, didOverlap,
didExceedBounds, didEndAnim, didEndMotion);
WriteObject(sh, false);
}
public override void OnStartClient()
{
traySpriteHandler = tray.GetComponentInChildren <SpriteHandler>();
UpdateSpriteDirection();
base.OnStartClient();
}
public static void Patch()
{
darktest = AssetBundle.LoadFromFile(Environment.CurrentDirectory + "/QMods/techpistol/Assets");
Atlas.Sprite Icon = new Atlas.Sprite(darktest.LoadAsset <Sprite>("Icon"));
var gun = TechTypeHandler.AddTechType("techpistol", "tech pistol", "tech pistol", true);
SpriteHandler.RegisterSprite(gun, Icon);
GunPrefab gunper = new GunPrefab("techpistol", "WorldEntities/Tools/techpistol", gun);
PrefabHandler.RegisterPrefab(gunper);
CraftDataHandler.SetEquipmentType(gun, EquipmentType.Hand);
var techData = new TechData()
{
craftAmount = 1,
Ingredients = new List <Ingredient>()
{
new Ingredient(TechType.SeaTreaderPoop, 1),
new Ingredient(TechType.TitaniumIngot, 2),
new Ingredient(TechType.Lubricant, 1),
new Ingredient(TechType.EnameledGlass, 3),
}
};
CraftDataHandler.SetTechData(gun, techData);
CraftDataHandler.SetCraftingTime(gun, 5f);
CraftTreeHandler.AddCraftingNode(CraftTree.Type.Fabricator, gun, "Personal", "Tools", "techpistol");
CraftDataHandler.SetItemSize(gun, 2, 2);
}
public void Patch(bool auxConsolesEnabled)
{
this.TechType = TechTypeHandler.AddTechType(NameID, FriendlyName, Description, false);
if (!auxConsolesEnabled) // Even if the options have this be disabled,
{
return; // we still want to run through the AddTechType methods to prevent mismatched TechTypeIDs as these settings are switched
}
LanguageHandler.SetLanguageLine(HandOverText, "Access Auxiliary Cyclops Upgrade Console");
CraftDataHandler.AddBuildable(this.TechType);
CraftDataHandler.AddToGroup(TechGroup.InteriorModules, TechCategory.InteriorModule, this.TechType);
PrefabHandler.RegisterPrefab(this);
var recipe = new TechData()
{
craftAmount = 1,
Ingredients = new List <Ingredient>(new Ingredient[3]
{
new Ingredient(TechType.AdvancedWiringKit, 1),
new Ingredient(TechType.Titanium, 2),
new Ingredient(TechType.Lead, 1),
})
};
CraftDataHandler.SetTechData(this.TechType, recipe);
SpriteHandler.RegisterSprite(this.TechType, @"./QMods/MoreCyclopsUpgrades/Assets/AuxCyUpgradeConsole.png");
KnownTechHandler.SetAnalysisTechEntry(TechType.CyclopsHullModule1, new TechType[1] {
this.TechType
}, $"{FriendlyName} blueprint discovered!");
}
private void Awake()
{
pick = GetComponent <Pickupable>();
spriteHandler = GetComponentInChildren <SpriteHandler>();
itemAttributesV2 = GetComponent <ItemAttributesV2>();
pick.RefreshUISlotImage();
}
/// <summary>
/// Initializes a new <see cref="Spawnable"/>, the basic class needed for any item that can be spawned into the Subnautica game world.
/// </summary>
/// <param name="classId">The main internal identifier for this item. Your item's <see cref="TechType"/> will be created using this name.</param>
/// <param name="friendlyName">The name displayed in-game for this item whether in the open world or in the inventory.</param>
/// <param name="description">The description for this item; Typically seen in the PDA, inventory, or crafting screens.</param>
protected Spawnable(string classId, string friendlyName, string description)
: base(classId, $"{classId}Prefab")
{
if (string.IsNullOrEmpty(classId))
{
Logger.Log($"ClassID for Spawnables must be a non-empty value.", LogLevel.Error);
throw new ArgumentException($"Error patching Spawnable");
}
FriendlyName = friendlyName;
Description = description;
CorePatchEvents += () =>
{
PrefabHandler.RegisterPrefab(this);
SpriteHandler.RegisterSprite(TechType, GetItemSprite());
if (!SizeInInventory.Equals(defaultSize))
{
CraftDataHandler.SetItemSize(TechType, SizeInInventory);
}
if (EntityInfo != null && BiomesToSpawnIn != null)
{
LootDistributionHandler.AddLootDistributionData(this, BiomesToSpawnIn, EntityInfo);
}
else if (EntityInfo != null)
{
WorldEntityDatabaseHandler.AddCustomInfo(ClassID, EntityInfo);
}
};
}
public void RegisterFloraFabricator(List <IDecorationItem> decorationItems)
{
if (this.IsRegistered == false)
{
// Create new Craft Tree Type
CreateCustomTree(out CraftTree.Type craftType, decorationItems);
this.TreeTypeID = craftType;
// Add the new TechType to the buildables
CraftDataHandler.AddBuildable(this.TechType);
// Add the new TechType to the group of Interior Module buildables
CraftDataHandler.AddToGroup(TechGroup.InteriorModules, TechCategory.InteriorModule, this.TechType, TechType.Fabricator);
// Register handover text
LanguageHandler.SetLanguageLine(HandOverText, LanguageHelper.GetFriendlyWord(HandOverText));
// Unlock at start
KnownTechHandler.UnlockOnStart(this.TechType);
// Set the buildable prefab
PrefabHandler.RegisterPrefab(this);
// Register sprite
SpriteHandler.RegisterSprite(this.TechType, AssetsHelper.Assets.LoadAsset <Sprite>("fabricator_icon_green"));
// Load texture
this.ColoredTexture = AssetsHelper.Assets.LoadAsset <Texture2D>("submarine_fabricator_green");
// Associate the recipie to the new TechType
CraftDataHandler.SetTechData(this.TechType, this.Recipe);
this.IsRegistered = true;
}
}
// for adding group node
public static void addNode(CraftTree.Type treeType, string id, string displayName, string path, string idAfter, TechType spriteTechType)
{
getNodeList(treeType).Add(new CraftNode(id, path, idAfter));
LanguageHandler.SetLanguageLine($"{treeType.ToString()}Menu_{id}", displayName);
SpriteHandler.RegisterSprite(SpriteManager.Group.Category, $"{treeType.ToString()}_{id}", SpriteManager.Get(spriteTechType));
}
protected virtual void Patch()
{
this.TechType = TechTypeHandler.AddTechType(NameID, FriendlyName, Description, RequiredForUnlock == TechType.None);
if (!ModulesEnabled) // Even if the options have this be disabled,
{
return; // we still want to run through the AddTechType methods to prevent mismatched TechTypeIDs as these settings are switched
}
if (RequiredForUnlock == TechType.None)
{
KnownTechHandler.UnlockOnStart(this.TechType);
}
else
{
KnownTechHandler.SetAnalysisTechEntry(RequiredForUnlock, new TechType[1] {
this.TechType
}, $"{FriendlyName} blueprint discovered!");
}
PrefabHandler.RegisterPrefab(this);
SpriteHandler.RegisterSprite(this.TechType, $"./QMods/MoreCyclopsUpgrades/Assets/{NameID}.png");
CraftDataHandler.SetTechData(this.TechType, GetRecipe());
if (AddToCraftTree)
{
CraftTreeHandler.AddCraftingNode(Fabricator, this.TechType, FabricatorTabs);
}
CraftDataHandler.SetEquipmentType(this.TechType, EquipmentType.CyclopsModule);
CraftDataHandler.AddToGroup(TechGroup.Cyclops, TechCategory.CyclopsUpgrades, this.TechType);
SetStaticTechTypeID(this.TechType);
}
public void RenewParticle(Vector2 position, Vector2 initialForce, float angle, float angularVelocity, Color color, Vector2 scale, float TTL, IDs id)
{
this.Sprite = SpriteHandler.GetSprite((int)id);
if (Sprite is Sprite)
{
Sprite.Origin = new Vector2(Sprite.SpriteRect.Width / 2, Sprite.SpriteRect.Height / 2); //! If drawables constructor changes, so must this
}
Stop();
Sprite.Origin = new Vector2(Sprite.SpriteRect.Width / 2, Sprite.SpriteRect.Height / 2); //! hmmm
Position = position;
AddForce(initialForce);
this.angle = angle;
this.angularVelocity = angularVelocity;
baseColor = color;
this.Sprite.MColor = color;
baseScale = scale;
this.Sprite.Scale = baseScale;
currentTTL = new Timer(TTL);
this.TTL = TTL;
this.id = id;
IsActive = true;
Behaviour();
if (id == IDs.AFTERIMAGE)
{
currentTTL.AddTime(-currentTTL.currentTime / 2);
}
}
private void Awake()
{
container = GetComponent <ObjectContainer>();
closet = GetComponent <ClosetControl>();
spriteHandler = GetComponentInChildren <SpriteHandler>();
powerable = GetComponent <APCPoweredDevice>();
}
private void Awake()
{
pickupable = GetComponent <Pickupable>();
spriteDataHandler = GetComponentInChildren <SpriteDataHandler>();
inventoryIcon = GetComponentInChildren <SpriteHandler>();
TryInit();
}
private void Awake()
{
spriteHandler = GetComponentInChildren <SpriteHandler>();
itemAttComp = gameObject.GetComponent <ItemAttributesV2>();
gunComp = gameObject.GetComponent <Gun>();
spriteHandler.ChangeSprite(0);
}
private IEnumerator LightsOutAfterTime(ItemLightControl lightController, SpriteHandler handler)
{
yield return(WaitFor.Seconds(runsOutOverSeconds));
lightController.Toggle(false);
handler.SetSpriteSO(offSprite);
}
public void StateUpdate(PowerStates State)
{
CurrentState = State;
if (spriteHandler == null)
{
spriteHandler = GetComponentInChildren <SpriteHandler>();
}
if (APCConnectionHandler == null)
{
APCConnectionHandler = GetComponentInChildren <APCPoweredDevice>();
}
// For a future iteration, allow the jukebox to be connected to the power grid.
/*
* if (State <= PowerStates.On)
* {
* Stop();
* TabUpdateMessage.SendToPeepers(gameObject, NetTabType.Jukebox, TabAction.Close);
* }
*/
// StateUpdate might happen before start
if (IsPlaying)
{
APCConnectionHandler.Wattusage = InUseWattUsage;
}
else
{
APCConnectionHandler.Wattusage = StandByWattUsage;
}
}
protected virtual void Awake()
{
registerObject = GetComponent <RegisterObject>();
directional = GetComponent <Directional>();
drawerPushPull = GetComponent <PushPull>();
drawerSpriteHandler = GetComponentInChildren <SpriteHandler>();
}
public static void RegisterHandler(NetworkIdentity networkIdentity, SpriteHandler spriteHandler)
{
if (networkIdentity == null)
{
Logger.LogError(" RegisterHandler networkIdentity is null on > " + spriteHandler.transform.parent.name,
Category.SpriteHandler);
return;
}
if (Instance.PresentSprites.ContainsKey(networkIdentity) == false)
{
Instance.PresentSprites[networkIdentity] = new Dictionary <string, SpriteHandler>();
}
if (Instance.PresentSprites[networkIdentity].ContainsKey(spriteHandler.name))
{
if (Instance.PresentSprites[networkIdentity][spriteHandler.name] != spriteHandler)
{
Logger.LogError(
"SpriteHandler has the same name as another SpriteHandler on the game object > " +
spriteHandler.transform.parent.name + " with Net ID of " + networkIdentity.netId, Category.SpriteHandler);
}
}
Instance.PresentSprites[networkIdentity][spriteHandler.name] = spriteHandler;
}
public virtual void Patch()
{
Atlas.Sprite sprite;
if (NameUsingForFiles != null)
{
sprite = ImageUtils.LoadSpriteFromFile($"./QMods/{NameUsingForFiles}/Assets/{NameUsingForFiles}.png");
}
else
{
sprite = GetResourceIcon(PrefabTemplate);
}
TechType = TechTypeHandler.AddTechType(NameID, FriendlyName, Description, sprite, false);
SpriteHandler.RegisterSprite(TechType, sprite);
CraftTreeHandler.AddCraftingNode(FabricatorType, TechType, FabricatorTab);
CraftDataHandler.SetTechData(TechType, GetRecipe());
CraftDataHandler.AddToGroup(GroupForPDA, CategoryForPDA, TechType);
CraftDataHandler.SetEquipmentType(TechType, TypeForEquipment);
CraftDataHandler.SetQuickSlotType(TechType, TypeForQuickslot);
CraftDataHandler.SetItemSize(TechType, ItemSize);
KnownTechHandler.SetAnalysisTechEntry(RequiredForUnlock, new TechType[1] {
TechType
}, $"{FriendlyName} blueprint discovered!");
PrefabHandler.RegisterPrefab(this);
}
private void Awake()
{
baseSpriteHandler = transform.GetChild(0).GetComponent <SpriteHandler>();
chargingIndicator = transform.GetChild(1).GetComponent <SpriteHandler>();
outputEnabledIndicator = transform.GetChild(2).GetComponent <SpriteHandler>();
chargeLevelIndicator = transform.GetChild(3).GetComponent <SpriteHandler>();
}
void Awake()
{
registerTile = GetComponent <RegisterTile>();
securable = GetComponent <WrenchSecurable>();
baseSpriteHandler = GetComponentInChildren <SpriteHandler>();
electricalNodeControl = GetComponent <ElectricalNodeControl>();
}
private void EnsureInit()
{
registerTile = GetComponent <RegisterTile>();
spriteHandler = GetComponentInChildren <SpriteHandler>();
storage = GetComponent <ItemStorage>();
SetState(new MicrowaveIdle(this));
// Get the machine stock parts used in this instance and get the tier of each part.
IDictionary <GameObject, int> builtParts = GetComponent <Machine>().PartsInFrame;
ICollection <GameObject> parts = builtParts.Keys;
ItemAttributesV2 partAttributes;
// Collection is unorganized so run through the whole list.
foreach (GameObject part in parts)
{
partAttributes = part.GetComponent <ItemAttributesV2>();
if (partAttributes.HasTrait(MachinePartsItemTraits.Instance.MicroLaser))
{
laserTier = part.GetComponent <StockTier>().Tier;
}
if (partAttributes.HasTrait(MachinePartsItemTraits.Instance.MatterBin))
{
int binTier = part.GetComponent <StockTier>().Tier;
// Decide ItemStorageStructure based on tier. Currently: slot size == matter bin tier.
storage.AcceptNewStructure(TierStorage[binTier - 1]);
}
}
}
public override void Initialize(Vector2 position)
{
_inputHandler = new InputHandler();
Id = Guid.NewGuid();
Active = true;
Speed = 0;
BaseSpeed = 140;
TopSpeed = 400;
Acceleration = 1.015f;
CurrentAccelerationDirection = DirectionEnum.NoDirection;
_pushDirection = DirectionEnum.NoDirection;
var sprites = Sprites.Instance;
SpriteHandler = new SpriteHandler(position);
SpriteHandler.InitializeAnimation(SpriteKeys.Quote.RunRight, sprites.GetSprite(SpriteKeys.Quote.RunRight), 64, 64, 4, 80, Color.White, 1f, true);
SpriteHandler.InitializeAnimation(SpriteKeys.Quote.RunLeft, sprites.GetSprite(SpriteKeys.Quote.RunLeft), 64, 64, 4, 80, Color.White, 1f, true);
SpriteHandler.InitializeAnimation(SpriteKeys.Quote.PushRight, sprites.GetSprite(SpriteKeys.Quote.PushRight), 64, 64, 4, 80, Color.White, 1f, true);
SpriteHandler.InitializeAnimation(SpriteKeys.Quote.PushLeft, sprites.GetSprite(SpriteKeys.Quote.PushLeft), 64, 64, 4, 80, Color.White, 1f, true);
SpriteHandler.InitializeAnimation(SpriteKeys.Quote.StandRight, sprites.GetSprite(SpriteKeys.Quote.StandRight), 64, 64, 1, 80, Color.White, 1f, true);
SpriteHandler.InitializeAnimation(SpriteKeys.Quote.StandLeft, sprites.GetSprite(SpriteKeys.Quote.StandLeft), 64, 64, 1, 80, Color.White, 1f, true);
SpriteHandler.Initialize(SpriteKeys.Quote.StandRight);
var grid = CollisionGrid.Instance;
CollisionCellPositions = grid.UpdateCellPosition(this);
}
public static void UnRegisterHandler(NetworkIdentity networkIdentity, SpriteHandler spriteHandler)
{
if (spriteHandler == null)
{
return;
}
if (networkIdentity == null)
{
if (spriteHandler?.transform?.parent != null)
{
Logger.LogError(" RegisterHandler networkIdentity is null on > " + spriteHandler.transform.parent.name,
Category.Sprites);
return;
}
else
{
Logger.LogError(" RegisterHandler networkIdentity is null on ? ",
Category.Sprites);
}
}
if (PresentSprites.ContainsKey(networkIdentity))
{
if (PresentSprites[networkIdentity].ContainsKey(spriteHandler.name))
{
PresentSprites[networkIdentity].Remove(spriteHandler.name);
}
}
}
private void Start()
{
_commandInfoList = _commandInfo.GetAllCommandInfos("Commands");
_clothingManager = GameObject.FindWithTag("generator").GetComponent <ClothingManager>();
_spriteHandler = GameObject.FindWithTag("generator").GetComponent <SpriteHandler>();
_inputField = gameObject.GetComponent <InputField>();
}
public void Patch()
{
TechType = TechTypeHandler.AddTechType(ID, DisplayName, Tooltip, RequiredForUnlock == TechType.Seaglide);
if (RequiredForUnlock != TechType.None)
{
KnownTechHandler.SetAnalysisTechEntry(RequiredForUnlock, new TechType[] { TechType.PowerGlide });
}
if (Sprite == null)
{
SpriteHandler.RegisterSprite(TechType, $"./QMods/BetterSeaglide/Assets/powerglide.png");
}
else
{
SpriteHandler.RegisterSprite(TechType, Sprite);
}
/*switch (Fabricator)
* {
* case CraftTree.Type.Fabricator:
* CraftDataHandler.AddToGroup(TechGroup.Machines, TechCategory.Machines, TechType, AddAfter);
* break;
*
* }*/
//CraftDataHandler.AddToGroup(TechGroup.Machines, TechCategory.Machines, TechType, AddAfter);
CraftDataHandler.SetEquipmentType(TechType, EquipmentType.Hand);
CraftDataHandler.SetTechData(TechType, GetTechData());
CraftDataHandler.SetQuickSlotType(TechType, QuickSlotType.Selectable);
//CraftTreeHandler.AddTabNode(Fabricator, "Deployables", "Better Seaglide", SpriteManager.Get(BetterSeaglide));
CraftTreeHandler.AddCraftingNode(Fabricator, TechType, StepsToTab);
}
protected override void Patch()
{
DepletedNuclearModuleID = TechTypeHandler.AddTechType(DepletedNameID, FriendlyName, Description, false);
RefillNuclearModuleID = TechTypeHandler.AddTechType(RefillNameID,
"Reload Cyclops Nuclear Module",
"Reload a Depleted Cyclops Nuclear Module with a Reactor Rod",
false);
if (CyclopsModule.ModulesEnabled) // Even if the options have this be disabled,
{ // we still want to run through the AddTechType methods to prevent mismatched TechTypeIDs as these settings are switched
SpriteHandler.RegisterSprite(DepletedNuclearModuleID, $"./QMods/MoreCyclopsUpgrades/Assets/DepletedCyclopsNuclearModule.png");
SpriteHandler.RegisterSprite(RefillNuclearModuleID, $"./QMods/MoreCyclopsUpgrades/Assets/CyclopsNuclearModule.png");
CraftDataHandler.SetTechData(RefillNuclearModuleID, GetRecipe());
KnownTechHandler.SetAnalysisTechEntry(TechType.BaseNuclearReactor, new TechType[1] {
RefillNuclearModuleID
}, "Reload of cyclops nuclear module available.");
PrefabHandler.RegisterPrefab(this);
PrefabHandler.RegisterPrefab(new RefillNuclearModule(RefillNuclearModuleID));
LanguageHandler.SetLanguageLine(DepletedEventKey, "Nuclear Reactor Module depleted");
}
this.NukFabricator.Patch(CyclopsModule.ModulesEnabled);
}
public void Patch()
{
TechType = TechTypeHandler.AddTechType(ID, DisplayName, Tooltip, RequiredForUnlock == TechType.None);
if (RequiredForUnlock != TechType.None)
{
KnownTechHandler.SetAnalysisTechEntry(RequiredForUnlock, new TechType[] { TechType });
}
if (Sprite == null)
{
SpriteHandler.RegisterSprite(TechType, $"./QMods/SeamothClawArm/Assets/{ID}.png");
}
else
{
SpriteHandler.RegisterSprite(TechType, Sprite);
}
switch (Fabricator)
{
case CraftTree.Type.Workbench:
CraftDataHandler.AddToGroup(TechGroup.Workbench, TechCategory.Workbench, TechType, AddAfter);
break;
case CraftTree.Type.SeamothUpgrades:
CraftDataHandler.AddToGroup(TechGroup.VehicleUpgrades, TechCategory.VehicleUpgrades, TechType, AddAfter);
break;
}
CraftDataHandler.SetEquipmentType(TechType, EquipmentType.SeamothModule);
CraftDataHandler.SetTechData(TechType, GetTechData());
CraftTreeHandler.AddCraftingNode(Fabricator, TechType, StepsToTab);
}
void Start()
{
animate = GetComponent<SpriteHandler>();
Jump = GetComponent<JumpPlayer>();
}
void Start()
{
animeate = GetComponent<SpriteHandler>();
}
