private object CanCraft(ItemCrafter itemCrafter, ItemBlueprint bp, int amount)
{
var player = itemCrafter.GetComponent <BasePlayer>();
var item = bp.GetComponent <ItemDefinition>();
if (permission.UserHasPermission(player.UserIDString, Perm))
{
return(null);
}
if (CFile.BlockAll.Enabled)
{
if (CFile.BlockAll.SendMessage)
{
PrintToChat(player, Lang(Msg.CraftingDisabled, player.UserIDString));
}
return(false);
}
if (CFile.BlockedItems.ContainsKey(item.shortname))
{
if (CFile.BlockedItems[item.shortname])
{
PrintToChat(player, Lang(Msg.CantCraft, player.UserIDString, item.displayName.english));
}
return(false);
}
return(null);
}
float DrawNeeds(ItemCrafter crafter, float offset)
{
float res = 0;
for (int i = 0; i < crafter.ItemNeeds.Length; i++)
{
GameObject obj = (GameObject)GameObject.Instantiate(GUICraftNeed.gameObject, Vector3.zero, Quaternion.identity);
obj.transform.SetParent(Canvas.gameObject.transform);
GUIItemDataNeed itemdata = obj.GetComponent <GUIItemDataNeed> ();
if (itemdata)
{
itemdata.Item = crafter.ItemNeeds [i].Item;
itemdata.Need = crafter.ItemNeeds [i].Num;
if (UnitZ.playerManager != null && UnitZ.playerManager.PlayingCharacter != null)
{
itemdata.Inventory = UnitZ.playerManager.PlayingCharacter.inventory;
}
}
RectTransform rect = obj.GetComponent <RectTransform> ();
rect.anchoredPosition = new Vector2(5, -((rect.sizeDelta.y * i) + offset));
rect.localScale = GUICraftNeed.gameObject.transform.localScale;
res += rect.sizeDelta.y;
}
return(res);
}
bool CanCraft(ItemCrafter itemCrafter, ItemBlueprint bp, int amount)
{
var player = itemCrafter.GetComponent <BasePlayer>();
var item = bp.GetComponent <ItemDefinition>();
if (player == null || item == null)
{
return(false);
}
if (permission.UserHasPermission(player.UserIDString, perm1))
{
return(true);
}
if (permission.UserHasPermission(player.UserIDString, perm2))
{
SendReply(player, "You are not allowed to craft at all");
return(false);
}
if (blacklist.Contains(item.shortname))
{
SendReply(player, "You are not allowed to craft <color=#eb4034>" + item.shortname + "</color>");
return(false);
}
return(true);
}
object OnCanCraft(ItemCrafter item_crafter, ItemBlueprint blueprint, int amount)
{
if (item_crafter.containers.Count < 1)
{
return(false);
}
var item = blueprint.targetItem;
if (!item)
{
return(null);
}
var player = item_crafter.containers[0].playerOwner;
if (!player)
{
return(null);
}
if (!player.IsAdmin() && item.shortname.StartsWith("sign."))
{
PrintToChat(player, notAllowedMessage);
return(false);
}
return(null);
}
public CraftEvent(ItemCrafter self, ItemBlueprint bp, BasePlayer owner, ProtoBuf.Item.InstanceData instanceData)
{
Crafter = Server.GetPlayer(owner);
Target = bp.targetItem;
itemCrafter = self;
bluePrint = bp;
}
private object OnIngredientsCollect(ItemCrafter itemCrafter, ItemBlueprint blueprint, ItemCraftTask task, int amount, BasePlayer player)
{
var ruleset = GetPlayerRuleset(player.UserIDString);
if (ruleset == null)
{
return(null);
}
var collect = new List <Item>();
ruleset.TakeFromContainers(itemCrafter.containers, blueprint.ingredients, amount, collect);
// Re-implementing some vanilla logic.
task.potentialOwners = new List <ulong>();
foreach (var item in collect)
{
item.CollectedForCrafting(player);
if (!task.potentialOwners.Contains(player.userID))
{
task.potentialOwners.Add(player.userID);
}
}
task.takenItems = collect;
// Return non-null to skip vanilla ingredient collection.
return(false);
}
public CraftEvent(ItemCrafter self, ItemBlueprint bp, BasePlayer owner, ProtoBuf.Item.InstanceData instanceData, int amount)
{
Crafter = Server.GetPlayer(owner);
Target = bp.targetItem;
itemCrafter = self;
Amount = amount;
bluePrint = bp;
}
public void OnPointerUp(PointerEventData eventData)
{
if (ItemCrafter.CraftingSequenceActive)
{
Debug.Log("To-do: Finish crafting sequence if active sequence");
ItemCrafter.EndCraftingSequence();
}
}
public CraftEvent(ItemCrafter self, ItemBlueprint bp, BasePlayer owner, ProtoBuf.Item.InstanceData instanceData, int amount, int skinid)
{
Crafter = Server.GetPlayer(owner);
Target = bp.targetItem;
itemCrafter = self;
Amount = amount;
bluePrint = bp;
SkinID = skinid;
}
private void CanCraft(ItemCrafter itemCrafter, ItemBlueprint bp, int amount)
{
var oplayer = itemCrafter?.GetComponent <BasePlayer>();
if (oplayer != null && TrackedPlayers.ContainsKey(oplayer.userID))
{
TrackedPlayers[oplayer.userID].ResetAFKTime();
}
}
void CancelAllCrafting(BasePlayer player)
{
ItemCrafter crafter = player.inventory.crafting;
foreach (ItemCraftTask task in crafter.queue)
{
crafter.CancelTask(task.taskUID, true);
}
}
private void ForceUsableItem(ItemCrafter itemCrafter, int itemid, int required)
{
var player = itemCrafter.GetComponent <BasePlayer>();
Item item = ItemManager.CreateByItemID(itemid, required);
if (item != null)
{
player.GiveItem(item);
}
}
// ItemCrafter.CraftItem()
public static bool PlayerStartCrafting(ItemCrafter self, ItemBlueprint bp, BasePlayer owner, ProtoBuf.Item.InstanceData instanceData = null)
{
ItemBlueprint bpcopy = new ItemBlueprint();
bpcopy.amountToCreate = bp.amountToCreate;
bpcopy.defaultBlueprint = bp.defaultBlueprint;
bpcopy.ingredients = bp.ingredients;
bpcopy.rarity = bp.rarity;
bpcopy.targetItem = bp.targetItem;
bpcopy.time = bp.time / Server.GetInstance().CraftingTimeScale;
bpcopy.userCraftable = bp.userCraftable;
CraftEvent ce = new CraftEvent(self, bpcopy, owner, instanceData);
OnPlayerStartCrafting.OnNext(ce);
if (!self.CanCraft(bpcopy, 1))
{
return(false);
}
if (ce.Cancel)
{
if (ce.cancelReason != "")
{
owner.SendConsoleCommand("chat.add", 0, String.Format("{0}: {1}", Server.server_message_name.ColorText("fa5"), ce.cancelReason));
}
return(false);
}
self.taskUID++;
ItemCraftTask itemCraftTask = new ItemCraftTask();
itemCraftTask.blueprint = bpcopy;
if (!ce.FreeCraft)
{
foreach (ItemAmount current in bpcopy.ingredients)
{
float amount = current.amount;
foreach (ItemContainer current2 in self.containers)
{
amount -= current2.Take(itemCraftTask.ingredients, current.itemid, (int)amount);
}
}
}
itemCraftTask.endTime = 0;
itemCraftTask.taskUID = self.taskUID;
itemCraftTask.owner = owner;
itemCraftTask.instanceData = instanceData;
self.queue.Enqueue(itemCraftTask);
if (itemCraftTask.owner != null)
{
itemCraftTask.owner.Command(String.Format("note.craft_add {0} {1}",
itemCraftTask.taskUID,
itemCraftTask.blueprint.targetItem.itemid));
}
return(true);
}
private static void CollectIngredient(ItemCrafter itemCrafter, int item, int amount, List <Item> collect)
{
foreach (var container in itemCrafter.containers)
{
amount -= container.Take(collect, item, amount);
if (amount <= 0)
{
break;
}
}
}
private static bool CanAffordCraftMultiplier(ItemCrafter itemCrafter, ItemBlueprint bp, int amount)
{
foreach (var ingredient in bp.ingredients)
{
if (!DoesHaveUsableItem(itemCrafter, ingredient.itemid, (int)ingredient.amount * amount))
{
return(false);
}
}
return(true);
}
public void SelectCraft(int index, ItemCrafter crafter)
{
if (indexSelected == index)
{
indexSelected = -1;
}
else
{
indexSelected = index;
}
SetupCrafterList();
}
void CompleteCrafting(BasePlayer player)
{
ItemCrafter crafter = player.inventory.crafting;
if (crafter.queue.Count == 0)
{
return;
}
ItemCraftTask task = crafter.queue.First <ItemCraftTask>();
FinishCraftingTask.Invoke(crafter, new object[] { task });
crafter.queue.Dequeue();
}
private object Process(ItemCrafter crafter, ItemBlueprint blueprint, int amount)
{
PrintDebug("PROCESSING");
var player = crafter.gameObject.GetComponent <BasePlayer>(); // Getting the player
if (player == null)
{
PrintWarning("Crafter player is null");
return(null);
}
return(Process(player, blueprint, amount));
}
bool CanCraft(ItemCrafter itemCrafter, ItemBlueprint bp, int amount)
{
BasePlayer player = itemCrafter.GetComponent <BasePlayer>();
if (InWorkbenchRadius.Contains(player.userID) == false)
{
if ((bool)Config["ShowMessages"] == true)
{
player.IPlayer.Reply(lang.GetMessage("outofrange", this, player.IPlayer.Id));
}
return(false);
}
return(true);
}
public bool CheckNeeds(ItemCrafter Crafter, CharacterInventory inventory)
{
if (Crafter == null || inventory == null)
return false;
for (int i=0; i<Crafter.ItemNeeds.Length; i++) {
if (Crafter.ItemNeeds [i].Item) {
if (inventory.GetItemNum (Crafter.ItemNeeds [i].Item) < Crafter.ItemNeeds [i].Num) {
return false;
}
}
}
return true;
}
public CraftEvent(ItemCrafter itemCrafter,
ItemBlueprint itemBlueprint,
BasePlayer owner,
ProtoBuf.Item.InstanceData instanceData,
int amount,
int skinid)
{
this.itemCrafter = itemCrafter;
bluePrint = itemBlueprint;
Crafter = Server.GetPlayer(owner);
Target = itemBlueprint.targetItem;
Amount = amount;
SkinID = skinid;
}
public void ServerUpdate(float delta)
{
if (this.queue.Count == 0)
{
return;
}
ItemCraftTask task = this.queue.Peek();
if (task.cancelled)
{
task.owner.Command("note.craft_done", (object)task.taskUID, (object)0);
this.queue.Dequeue();
}
else
{
float currentCraftLevel = task.owner.currentCraftLevel;
if ((double)task.endTime > (double)Time.get_realtimeSinceStartup())
{
return;
}
if ((double)task.endTime == 0.0)
{
float scaledDuration = ItemCrafter.GetScaledDuration(task.blueprint, currentCraftLevel);
task.endTime = Time.get_realtimeSinceStartup() + scaledDuration;
if (!Object.op_Inequality((Object)task.owner, (Object)null))
{
return;
}
task.owner.Command("note.craft_start", (object)task.taskUID, (object)scaledDuration, (object)task.amount);
if (!task.owner.IsAdmin || !Craft.instant)
{
return;
}
task.endTime = Time.get_realtimeSinceStartup() + 1f;
}
else
{
this.FinishCrafting(task);
if (task.amount <= 0)
{
this.queue.Dequeue();
}
else
{
task.endTime = 0.0f;
}
}
}
}
private static void CollectIngredients(ItemCrafter itemCrafter, ItemBlueprint bp, ItemCraftTask task,
int amount, BasePlayer player)
{
var collect = new List <Item>();
foreach (var ingredient in bp.ingredients)
{
CollectIngredient(itemCrafter, ingredient.itemid, (int)ingredient.amount * amount, collect);
}
foreach (var item in collect)
{
item.CollectedForCrafting(player);
}
task.takenItems.AddRange(collect);
}
// ItemCrafter.CraftItem()
public static bool On_PlayerStartCrafting(ItemCrafter self, ItemBlueprint bp, BasePlayer owner, ProtoBuf.Item.InstanceData instanceData = null, int amount = 1, int skinID = 0)
{
CraftEvent ce = new CraftEvent(self, bp, owner, instanceData, amount, skinID);
OnNext("On_PlayerStartCrafting", ce);
if (!self.CanCraft(bp, ce.Amount))
{
return(false);
}
if (ce.Cancel)
{
if (ce.cancelReason != String.Empty)
{
ce.Crafter.Message(ce.cancelReason);
}
return(false);
}
self.taskUID++;
ItemCraftTask itemCraftTask = Facepunch.Pool.Get <ItemCraftTask>();
itemCraftTask.blueprint = bp;
self.CallMethod("CollectIngredients", bp, ce.Amount, owner);
itemCraftTask.endTime = 0;
itemCraftTask.taskUID = self.taskUID;
itemCraftTask.owner = owner;
itemCraftTask.instanceData = instanceData;
if (itemCraftTask.instanceData != null)
{
itemCraftTask.instanceData.ShouldPool = false;
}
itemCraftTask.amount = ce.Amount;
itemCraftTask.skinID = ce.SkinID;
self.queue.Enqueue(itemCraftTask);
if (itemCraftTask.owner != null)
{
itemCraftTask.owner.Command("note.craft_add", new object[] {
itemCraftTask.taskUID,
itemCraftTask.blueprint.targetItem.itemid,
amount
});
}
return(true);
}
object CanCraft(ItemCrafter itemCrafter, ItemBlueprint bp, int amount)
{
if (bp.name == "map.item")
{
BasePlayer player = itemCrafter.containers[0].GetOwnerPlayer();
if (player == null)
{
return(false);
}
if (!permission.UserHasPermission(player.UserIDString, permissionName))
{
return(null);
}
player.ChatMessage(msg("Unable to craft", player.UserIDString));
return(false);
}
return(null);
}
void RemoveCraftAt(int indexshow)
{
ItemCrafter[] itemCraft = new ItemCrafter[itemCraftManager.ItemCraftList.Length - 1];
int count = 0;
for (int i = 0; i < itemCraftManager.ItemCraftList.Length; i++)
{
if (i != indexshow)
{
itemCraft [count] = itemCraftManager.ItemCraftList [i];
count++;
}
}
itemCraftManager.ItemCraftList = (ItemCrafter[])itemCraft.Clone();
EditorUtility.SetDirty(gameManager);
}
protected void Initialize()
{
this.containerMain = new ItemContainer();
this.containerMain.SetFlag(ItemContainer.Flag.IsPlayer, true);
this.containerBelt = new ItemContainer();
this.containerBelt.SetFlag(ItemContainer.Flag.IsPlayer, true);
this.containerBelt.SetFlag(ItemContainer.Flag.Belt, true);
this.containerWear = new ItemContainer();
this.containerWear.SetFlag(ItemContainer.Flag.IsPlayer, true);
this.containerWear.SetFlag(ItemContainer.Flag.Clothing, true);
this.crafting = base.GetComponent <ItemCrafter>();
this.crafting.AddContainer(this.containerMain);
this.crafting.AddContainer(this.containerBelt);
this.loot = base.GetComponent <PlayerLoot>();
if (!this.loot)
{
this.loot = base.gameObject.AddComponent <PlayerLoot>();
}
}
public void ServerUpdate(float delta)
{
if (this.queue.Count == 0)
{
return;
}
ItemCraftTask itemCraftTask = this.queue.Peek();
if (itemCraftTask.cancelled)
{
itemCraftTask.owner.Command("note.craft_done", new object[] { itemCraftTask.taskUID, 0 });
this.queue.Dequeue();
return;
}
float single = itemCraftTask.owner.currentCraftLevel;
if (itemCraftTask.endTime > UnityEngine.Time.realtimeSinceStartup)
{
return;
}
if (itemCraftTask.endTime != 0f)
{
this.FinishCrafting(itemCraftTask);
if (itemCraftTask.amount > 0)
{
itemCraftTask.endTime = 0f;
return;
}
this.queue.Dequeue();
return;
}
float scaledDuration = ItemCrafter.GetScaledDuration(itemCraftTask.blueprint, single);
itemCraftTask.endTime = UnityEngine.Time.realtimeSinceStartup + scaledDuration;
if (itemCraftTask.owner != null)
{
itemCraftTask.owner.Command("note.craft_start", new object[] { itemCraftTask.taskUID, scaledDuration, itemCraftTask.amount });
if (itemCraftTask.owner.IsAdmin && Craft.instant)
{
itemCraftTask.endTime = UnityEngine.Time.realtimeSinceStartup + 1f;
}
}
}
private object CanCraft(ItemCrafter itemCrafter, ItemBlueprint blueprint, int craftAmount, bool free)
{
var ruleset = GetPlayerRuleset(itemCrafter.baseEntity.UserIDString);
if (ruleset == null)
{
return(null);
}
var args = new object[] { itemCrafter, blueprint, craftAmount, free };
object otherPluginResult;
if (PluginReturnedResult(CraftSpamBlocker, nameof(CanCraft), out otherPluginResult, args) ||
PluginReturnedResult(Guardian, nameof(CanCraft), out otherPluginResult, args) ||
PluginReturnedResult(ItemPuller, nameof(CanCraft), out otherPluginResult, args) ||
PluginReturnedResult(NoCraft, nameof(CanCraft), out otherPluginResult, args) ||
PluginReturnedResult(NoEscape, nameof(CanCraft), out otherPluginResult, args) ||
PluginReturnedResult(TimedProgression, nameof(CanCraft), out otherPluginResult, args) ||
PluginReturnedResult(VerificationGatekeeper, nameof(CanCraft), out otherPluginResult, args) ||
PluginReturnedResult(ZoneManager, nameof(CanCraft), out otherPluginResult, args))
{
return(otherPluginResult);
}
foreach (var itemAmount in blueprint.ingredients)
{
var playerAmount = ruleset.GetFreeAmount(itemAmount);
foreach (var container in itemCrafter.containers)
{
playerAmount += container.GetAmount(itemAmount.itemid, onlyUsableAmounts: true);
}
if (playerAmount < itemAmount.amount * craftAmount)
{
return(false);
}
}
// Return non-null to force craft, skipping vanilla validation.
return(true);
}
public bool CheckNeeds(ItemCrafter Crafter, CharacterInventory inventory)
{
if (Crafter == null || inventory == null)
{
return(false);
}
for (int i = 0; i < Crafter.ItemNeeds.Length; i++)
{
if (Crafter.ItemNeeds [i].Item)
{
if (inventory.GetItemNum(Crafter.ItemNeeds [i].Item) < Crafter.ItemNeeds [i].Num)
{
return(false);
}
}
}
return(true);
}
void BulkCraft(BasePlayer player, ItemCraftTask task, int amount)
{
ItemCrafter crafter = player.inventory.crafting;
if (crafter.queue.ToArray()[0] == task)
{
amount--;
}
for (int i = 1; i <= amount; i++)
{
if (!crafter.CanCraft(task.blueprint, 1))
{
break;
}
crafter.taskUID++;
ItemCraftTask item = new ItemCraftTask {
blueprint = task.blueprint
};
CollectIngredients.Invoke(crafter, new object[] { item.blueprint, item.ingredients });
if (craftingRate == 0)
{
item.endTime = 1f;
}
else
{
item.endTime = 0f;
}
item.taskUID = crafter.taskUID;
item.owner = player;
item.instanceData = null;
crafter.queue.Enqueue(item);
if (item.owner != null)
{
object[] args = new object[] { item.taskUID, item.blueprint.targetItem.itemid };
item.owner.Command("note.craft_add", args);
}
}
}
protected void Initialize()
{
this.containerMain = new ItemContainer();
this.containerMain.SetFlag(ItemContainer.Flag.IsPlayer, true);
this.containerBelt = new ItemContainer();
this.containerBelt.SetFlag(ItemContainer.Flag.IsPlayer, true);
this.containerBelt.SetFlag(ItemContainer.Flag.Belt, true);
this.containerWear = new ItemContainer();
this.containerWear.SetFlag(ItemContainer.Flag.IsPlayer, true);
this.containerWear.SetFlag(ItemContainer.Flag.Clothing, true);
this.crafting = (ItemCrafter)((Component)this).GetComponent <ItemCrafter>();
this.crafting.AddContainer(this.containerMain);
this.crafting.AddContainer(this.containerBelt);
this.loot = (PlayerLoot)((Component)this).GetComponent <PlayerLoot>();
if (Object.op_Implicit((Object)this.loot))
{
return;
}
this.loot = (PlayerLoot)((Component)this).get_gameObject().AddComponent <PlayerLoot>();
}
private bool HasIngredient(ItemCrafter itemCrafter, ItemAmount itemAmount, int amount)
{
int num = 0;
foreach (var itemContainer in itemCrafter.containers)
{
num += itemContainer.GetAmount(itemAmount.itemid, true);
}
float iAmount = itemAmount.amount * amount;
int required = (int)iAmount - num;
if (!(num >= iAmount))
{
return(false);
}
else
{
return(true);
}
}
public void CancelCraft()
{
CraftingDurationNormalize = 0;
crafting = false;
ItemSelected = null;
}
public void CraftSelected(ItemCrafter item)
{
ItemSelected = item;
}
// ItemCrafter.CraftItem()
public static bool PlayerStartCrafting(ItemCrafter self, ItemBlueprint bp, BasePlayer owner, ProtoBuf.Item.InstanceData instanceData = null, int amount = 1)
{
/*ItemBlueprint bpcopy = new ItemBlueprint();
bpcopy.amountToCreate = bp.amountToCreate;
bpcopy.defaultBlueprint = bp.defaultBlueprint;
bpcopy.ingredients = bp.ingredients;
bpcopy.rarity = bp.rarity;
bpcopy.targetItem = bp.targetItem;
bpcopy.time = bp.time / Server.GetInstance().CraftingTimeScale;
bpcopy.userCraftable = bp.userCraftable;*/
CraftEvent ce = new CraftEvent(self, bp, owner, instanceData, amount);
OnPlayerStartCrafting.OnNext(ce);
if (!self.CanCraft(bp, 1)) {
return false;
}
if (ce.Cancel) {
if (ce.cancelReason != "")
owner.SendConsoleCommand("chat.add", 0, String.Format("{0}: {1}", Server.server_message_name.ColorText("fa5"), ce.cancelReason));
return false;
}
self.taskUID++;
ItemCraftTask itemCraftTask = new ItemCraftTask();
itemCraftTask.blueprint = bp;
if (!ce.FreeCraft) {
List<Item> list = new List<Item>();
foreach (ItemAmount current in bp.ingredients) {
int amount2 = (int)current.amount * amount;
foreach (ItemContainer current2 in self.containers) {
amount2 -= current2.Take(list, current.itemid, amount2);
}
}
foreach (Item current2 in list) {
current2.Remove(0f);
}
}
itemCraftTask.endTime = 0;
itemCraftTask.taskUID = self.taskUID;
itemCraftTask.owner = owner;
itemCraftTask.instanceData = instanceData;
itemCraftTask.amount = amount;
self.queue.Enqueue(itemCraftTask);
if (itemCraftTask.owner != null) {
itemCraftTask.owner.Command("note.craft_add", new object[] {
itemCraftTask.taskUID,
itemCraftTask.blueprint.targetItem.itemid,
amount
});
}
return true;
}
/// <summary>
/// Called from <c>ItemCrafter.CraftItem(ItemBlueprint, BasePlayer, ProtoBuf.Item.InstanceData, int, int, Item)</c> .
/// </summary>
public static bool On_PlayerStartCrafting(ItemCrafter self,
ItemBlueprint bp,
BasePlayer owner,
ProtoBuf.Item.InstanceData instanceData = null,
int amount = 1,
int skinID = 0,
Item fromTempBlueprint = null)
{
var ce = new CraftEvent(self, bp, owner, instanceData, amount, skinID);
OnNext("On_PlayerStartCrafting", ce);
if (!self.CanCraft(bp, ce.Amount))
return false;
if (ce.Cancel) {
if (ce.cancelReason != String.Empty)
ce.Crafter.Message(ce.cancelReason);
return false;
}
self.taskUID++;
ItemCraftTask itemCraftTask = Facepunch.Pool.Get<ItemCraftTask>();
itemCraftTask.blueprint = bp;
self.CallMethod("CollectIngredients", bp, itemCraftTask, ce.Amount, owner);
itemCraftTask.endTime = 0;
itemCraftTask.taskUID = self.taskUID;
itemCraftTask.owner = owner;
itemCraftTask.instanceData = instanceData;
if (itemCraftTask.instanceData != null) {
itemCraftTask.instanceData.ShouldPool = false;
}
itemCraftTask.amount = ce.Amount;
itemCraftTask.skinID = ce.SkinID;
if (fromTempBlueprint != null) {
fromTempBlueprint.RemoveFromContainer();
itemCraftTask.takenItems.Add(fromTempBlueprint);
itemCraftTask.conditionScale = 0.5f;
}
self.queue.Enqueue(itemCraftTask);
if (itemCraftTask.owner != null) {
itemCraftTask.owner.Command("note.craft_add", new object[] {
itemCraftTask.taskUID,
itemCraftTask.blueprint.targetItem.itemid,
amount
});
}
return true;
}
