public CraftingInventoryWorkbenchCB(InventoryPlayer inventoryplayer, World world, int i, int j, int k)
{
craftMatrix = new InventoryCrafting(this, 3, 3);
craftResult = new InventoryCraftResult();
field_20150_c = world;
field_20149_h = i;
field_20148_i = j;
field_20147_j = k;
addSlot(new SlotCrafting(craftMatrix, craftResult, 0, 124, 35));
for (int l = 0; l < 3; l++)
{
for (int k1 = 0; k1 < 3; k1++)
{
addSlot(new Slot(craftMatrix, k1 + l*3, 30 + k1*18, 17 + l*18));
}
}
for (int i1 = 0; i1 < 3; i1++)
{
for (int l1 = 0; l1 < 9; l1++)
{
addSlot(new Slot(inventoryplayer, l1 + i1*9 + 9, 8 + l1*18, 84 + i1*18));
}
}
for (int j1 = 0; j1 < 9; j1++)
{
addSlot(new Slot(inventoryplayer, j1, 8 + j1*18, 142));
}
onCraftMatrixChanged(craftMatrix);
}
public Slot(IInventory iinventory, int i, int j, int k)
{
inventory = iinventory;
slotIndex = i;
xDisplayPosition = j;
yDisplayPosition = k;
}
public BodyPart(IStorageType storageType, float hitProbability, float damageFactor)
{
bodyPartImplementation = new Inventory(storageType);
HitProbability = hitProbability;
DamageFactor = damageFactor;
}
public bool EquipItem(IItem item, IInventory inventory) {
bool result = false;
IWeapon weaponItem = item as IWeapon;
if (weaponItem != null && weaponItem.IsWieldable) {
//can't equip a wieldable weapon
}
else {
if (!equipped.ContainsKey(item.WornOn)) {
equipped.Add(item.WornOn, item);
if (inventory.inventory.Any(i => i.Id == item.Id)) {//in case we are adding it from a load and not moving it from the inventory
inventory.inventory.RemoveWhere(i => i.Id == item.Id); //we moved the item over to equipped so we need it out of inventory
}
result = true;
}
else if (item.WornOn == Wearable.WIELD_LEFT || item.WornOn == Wearable.WIELD_RIGHT) { //this item can go in the free hand
Wearable freeHand = Wearable.WIELD_LEFT; //we default to right hand for weapons
if (equipped.ContainsKey(freeHand)) freeHand = Wearable.WIELD_RIGHT; //maybe this perosn is left handed
if (!equipped.ContainsKey(freeHand)) { //ok let's equip this
item.WornOn = freeHand;
item.Save();
equipped.Add(freeHand, item);
if (inventory.inventory.Any(i => i.Id == item.Id)) {//in case we are adding it from a load and not moving it from the inventory
inventory.inventory.RemoveWhere(i => i.Id == item.Id); //we moved the item over to equipped so we need it out of inventory
}
result = true;
}
}
}
return result;
}
public CraftingInventoryChestCB(IInventory iinventory, IInventory iinventory1)
{
field_20137_a = iinventory1;
int i = iinventory1.getSizeInventory()/9;
int j = (i - 4)*18;
for (int k = 0; k < i; k++)
{
for (int j1 = 0; j1 < 9; j1++)
{
addSlot(new Slot(iinventory1, j1 + k*9, 8 + j1*18, 18 + k*18));
}
}
for (int l = 0; l < 3; l++)
{
for (int k1 = 0; k1 < 9; k1++)
{
addSlot(new Slot(iinventory, k1 + l*9 + 9, 8 + k1*18, 103 + l*18 + j));
}
}
for (int i1 = 0; i1 < 9; i1++)
{
addSlot(new Slot(iinventory, i1, 8 + i1*18, 161 + j));
}
}
public Character( StatExpressionsInfo statExpressions, CharacterPlanetPawn pawn, IInputSource inputSource, CharacterStatus status, CharacterStateController stateController, CharacterStateController weaponStateController, int teamId, CharacterInfo info )
{
this.statExpressions = statExpressions;
this.status = status;
this.health = new IntReactiveProperty( this.status.maxHealth.Value );
this.pawn = pawn;
this.inputSource = inputSource;
this.stateController = stateController;
this.weaponStateController = weaponStateController;
this.teamId = teamId;
this.info = info;
this.inventory = new BasicInventory( this );
pawn.SetCharacter( this );
this.stateController.Initialize( this );
this.weaponStateController.Initialize( this );
var inputSourceDisposable = inputSource as IDisposable;
if ( inputSourceDisposable != null ) {
_compositeDisposable.Add( inputSourceDisposable );
}
Observable.EveryUpdate().Subscribe( OnUpdate ).AddTo( _compositeDisposable );
status.moveSpeed.Subscribe( UpdatePawnSpeed ).AddTo( _compositeDisposable );
health.Subscribe( OnHealthChange );//.AddTo( _compositeDisposable );
instances.Add( this );
}
public IInventoryWindow GetInventoryWindow(string id, IImage image, float itemWidth, float itemHeight, IInventory inventory)
{
TypedParameter idParam = new TypedParameter (typeof(string), id);
TypedParameter imageParam = new TypedParameter (typeof(IImage), image);
IInventoryWindow inventoryWindow = _resolver.Resolve<IInventoryWindow>(idParam, imageParam);
inventoryWindow.Tint = Colors.Transparent;
inventoryWindow.ItemSize = new AGS.API.SizeF (itemWidth, itemHeight);
inventoryWindow.Inventory = inventory ?? _gameState.Player.Inventory;
return inventoryWindow;
}
public Player()
{
Type |= ObjectTypes.Player;
inventory = new PlayerInventory(this, (UpdateFields.PLAYER_FARSIGHT - UpdateFields.PLAYER_FIELD_INV_SLOT_HEAD) / 2);
_equipment = new EquipmentInventory(this);
_backPack = new BackPackInventory(this);
_bank = new BankInventory(this);
_bankBags = new BankBagsInventory(this);
_keyRing = new KeyRingInventory(this);
}
public void StartReward(IInventory inventory)
{
int coinAmount = inventory.CoinAmount;
int lives = inventory.LifeAmount;
int total = coinAmount * (lives / 2);
int totalCoin = PlayerPrefs.GetInt ("TotalCoin",0);
total += totalCoin;
PlayerPrefs.SetInt ("TotalCoin", total);
StartCoroutine (SetValueCoroutine(coinAmount, lives, total));
}
public IInventoryWindow GetInventoryWindow(string id, float width, float height, float itemWidth, float itemHeight, float x, float y,
IInventory inventory = null, bool addToUi = true)
{
IInventoryWindow inventoryWindow = GetInventoryWindow(id, new EmptyImage(width, height), itemWidth, itemHeight, inventory);
inventoryWindow.X = x;
inventoryWindow.Y = y;
if (addToUi)
_gameState.UI.Add(inventoryWindow);
return inventoryWindow;
}
public Slot func_20127_a(IInventory iinventory, int i)
{
for (int j = 0; j < inventorySlots.size(); j++)
{
var slot = (Slot) inventorySlots.get(j);
if (slot.isHere(iinventory, i))
{
return slot;
}
}
return null;
}
/// <summary> Default constructor. </summary>
///
public BolterInterface()
{
_basePath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd(new[] { '\\' });
_localCamera = new Camera();
_localMovement = new Movement();
_localGameCalls = new GameCalls();
_localInput = new Input();
_localResources = new Resources(Path.GetDirectoryName(_basePath) + "\\Resources\\Items.obj");
_localTarget = new Target();
_localZone = new Zone();
_localInventory = new Inventory();
Bolter.GlobalInterface = this;
}
private static void SplitItems(IInventory inventorySrc, int srcSlot, IInventory inventoryDst, int dstSlot, int amount)
{
Item srcItem = inventorySrc[srcSlot];
Item dstItem = inventoryDst[dstSlot];
if(dstItem == null) {
dstItem = Item.Create(srcItem.Template);
inventoryDst[dstSlot] = dstItem;
dstItem.StackCount = (byte)amount;
srcItem.StackCount -= (byte)amount;
}
else if(dstItem.CanStack(srcItem)) {
dstItem.StackCount += (byte)amount;
srcItem.StackCount -= (byte)amount;
}
}
public static int FindAcquireSlotForItem(IInventory inventory, int value)
{
for (int i = 0; i < inventory.SlotsCount; i++)
{
if (inventory.GetSlotCount(i) > 0 && inventory.GetSlotValue(i) == value && inventory.GetSlotCount(i) < inventory.GetSlotCapacity(i, value))
{
return(i);
}
}
for (int j = 0; j < inventory.SlotsCount; j++)
{
if (inventory.GetSlotCount(j) == 0 && inventory.GetSlotCapacity(j, value) > 0)
{
return(j);
}
}
return(-1);
}
public void Reset(IInventory playerInventory, IInventory characterInventory)
{
PlayerStartupItem = null;
CharacterStartupItem = null;
CharacterStartupStack = null;
PlayerInventory = playerInventory;
CharacterInventory = characterInventory;
CurrentCharacterStackEnablerIndex = 0;
TotalValuePlayerGoods = 0;
TotalValueCharacterGoods = 0;
BaseValuePlayerGoods = 0;
BaseValueCharacterGoods = 0;
ZeroCostMode = false;
IsActive = false;
ClearGoodsAndCurrency();
//don't reset player index
RefreshAction = null;
}
private void button4_Click(object sender, EventArgs e)
{
context.Verifiable.Scripts = context.GetScripts();
IInventory inventory = (IInventory)context.Verifiable;
var tx = inventory as Transaction;
if (tx.Verify(new List <Transaction> {
tx
}))
{
Program.LocalNode.Relay(inventory);
InformationBox.Show(inventory.Hash.ToString(), Strings.RelaySuccessText, Strings.RelaySuccessTitle);
}
else
{
MessageBox.Show("Transaction validation failed and cannot be broadcast.");
}
}
public override int GetProcessInventoryItemCapacity(IInventory inventory, int slotIndex, int value)
{
int num = Terrain.ExtractContents(value);
ArrowBlock.ArrowType arrowType = ArrowBlock.GetArrowType(Terrain.ExtractData(value));
if (num == 192 && m_supportedArrowTypes.Contains(arrowType))
{
int data = Terrain.ExtractData(inventory.GetSlotValue(slotIndex));
ArrowBlock.ArrowType?arrowType2 = CrossbowBlock.GetArrowType(data);
int draw = CrossbowBlock.GetDraw(data);
if (!arrowType2.HasValue && draw == 15)
{
return(1);
}
return(0);
}
return(0);
}
public GuiDialogHandbook(ICoreClientAPI capi) : base(capi)
{
IPlayerInventoryManager invm = capi.World.Player.InventoryManager;
creativeInv = invm.GetOwnInventory(GlobalConstants.creativeInvClassName);
capi.Settings.AddWatcher <float>("guiScale", (float val) => {
initOverviewGui();
foreach (GuiHandbookPage elem in listElements)
{
elem.Dispose();
}
});
InitStackCacheAndStacks();
initCustomPages();
initOverviewGui();
}
private void Event_PlayerJoin(IServerPlayer byPlayer)
{
IInventory inv = byPlayer.InventoryManager.GetOwnInventory(GlobalConstants.characterInvClassName);
inv.SlotModified += (slotid) => updateWearableStats(inv, byPlayer);
var bh = byPlayer.Entity.GetBehavior <EntityBehaviorHealth>();
if (bh != null)
{
bh.onDamaged += (dmg, dmgSource) => handleDamaged(byPlayer, dmg, dmgSource);
}
byPlayer.Entity.OnFootStep = () => onFootStep(byPlayer.Entity);
byPlayer.Entity.OnImpact = (motionY) => onFallToGround(byPlayer.Entity, motionY);
updateWearableStats(inv, byPlayer);
}
private void OnInventory(IInventory inventory, bool relay = true)
{
VerifyResult result = inventory switch
{
Block block => OnNewBlock(block),
Transaction transaction => OnNewTransaction(transaction),
ExtensiblePayload payload => OnNewExtensiblePayload(payload),
_ => throw new NotSupportedException()
};
if (result == VerifyResult.Succeed && relay)
{
system.LocalNode.Tell(new LocalNode.RelayDirectly {
Inventory = inventory
});
}
SendRelayResult(inventory, result);
}
public void PlayerInventoryCanBeAddedNSubs()
{
// Arrange
Player player = new Player();
IInventory inventory = Substitute.For <IInventory>();
IItem item = Substitute.For <IItem>();
int itemCount = 0;
player.inventory = inventory;
inventory.Add(Arg.Do <IItem>(x => itemCount++));
// Act
player.AddToInventory(item);
player.AddToInventory(item);
// Assert
Assert.That(itemCount, Is.EqualTo(2));
}
public static ItemStack[] ToItemStacks(this IInventory slots)
{
List <ItemStack> objects = new List <ItemStack>();
for (int i = 0; i < slots.Count; i++)
{
if (slots[i].Itemstack != null && !(slots[i] is ItemSlotOffhand) && slots[i].Itemstack.Attributes["backpack"] == null)
{
for (int j = 0; j < slots[i].Itemstack.StackSize; j++)
{
ItemStack tempstack = slots[i].Itemstack.Clone();
tempstack.StackSize = 1;
objects.Add(tempstack);
}
}
}
return(objects.ToArray());
}
internal void ClientSelectionDone(IInventory characterInv, string characterClass, bool didSelect)
{
List <ClothStack> clothesPacket = new List <ClothStack>();
for (int i = 0; i < characterInv.Count; i++)
{
ItemSlot slot = characterInv[i];
if (slot.Itemstack == null)
{
continue;
}
clothesPacket.Add(new ClothStack()
{
Code = slot.Itemstack.Collectible.Code.ToShortString(),
SlotNum = i,
Class = slot.Itemstack.Class
});
}
Dictionary <string, string> skinParts = new Dictionary <string, string>();
var bh = capi.World.Player.Entity.GetBehavior <EntityBehaviorExtraSkinnable>();
var applied = bh.AppliedSkinParts;
foreach (var val in applied)
{
skinParts[val.PartCode] = val.Code;
}
capi.Network.GetChannel("charselection").SendPacket(new CharacterSelectionPacket()
{
Clothes = clothesPacket.ToArray(),
DidSelect = didSelect,
SkinParts = skinParts,
CharacterClass = characterClass,
VoicePitch = bh.VoicePitch,
VoiceType = bh.VoiceType
});
capi.Network.SendPlayerNowReady();
createCharDlg = null;
}
void UpdateWheel()
{
if (inventory == null)
{
inventory = GameController.Instance.Inventory;
}
IWeaponsHolder weapons = inventory.Weapons;
IAmmoHolder ammo = inventory.Ammo;
List <WeaponIndex> available = weapons.GetAvailableWeaponsInGame();
int availableAmount = available.Count;
GameObject wheel = GetWheel(availableAmount);
if (wheel == null)
{
return;
}
int counter = 0;
var bs = wheel.GetComponentsInChildren <WeaponWheelButton>(true);
foreach (WeaponWheelButton b in bs)
{
b.SetColors(defaultColor, highlitedColor, disabledColor);
if (counter < availableAmount)
{
IWeaponItem w = weapons.Get(available[counter]);
IAmmoItem a = ammo.Get(w.AmmoType);
b.Set(w, a, Select, Highlight, Unhighlight);
}
else
{
// disable buttons without weapon
b.Disable();
}
counter++;
}
}
public static void PopulateItemList()
{
if (list.SelectedIndex < 0)
{
return;
}
IInventory selected = inventoriesNearby[list.SelectedIndex];
if (selected == null)
{
return;
}
items.Items.Clear();
foreach (Item i in selected.GetItems())
{
items.Items.Add(i);
}
Adds.Visible = true;
}
private async Task onMouseDown(MouseButtonEventArgs e)
{
IGameState state = _game.State;
if (!state.Player.Enabled)
{
return;
}
if (e.Button == MouseButton.Left)
{
if (state.Player.Inventory == null ||
state.Player.Inventory.ActiveItem == null)
{
var xy = e.MousePosition.GetProjectedPoint(state.Viewport, state.Player);
Position position = new Position(xy.X, xy.Y, state.Player.Z);
await state.Player.WalkAsync(position).ConfigureAwait(true);
}
else
{
}
}
else if (e.Button == MouseButton.Right)
{
IInventory inventory = state.Player.Inventory;
if (inventory == null)
{
return;
}
if (inventory.ActiveItem == null)
{
IObject hotspot = _game.HitTest.ObjectAtMousePosition;
if (hotspot == null)
{
return;
}
}
else
{
inventory.ActiveItem = null;
}
}
}
private void Initialize(IInventory inventory)
{
if (_inventory != null)
{
_inventory.Items.CollectionChanged -= ItemsVmOnCollectionChanged;
foreach (var view in _itemsView)
{
Destroy(view.gameObject);
}
_itemsView.Clear();
}
_inventory = inventory;
_inventory.Items.CollectionChanged += ItemsVmOnCollectionChanged;
foreach (var itemVm in _inventory.Items.Values)
{
_itemsView.Add(ViewManager.Instantiate <ItemView, IItemViewModel>(itemVm, _itemPrefab, _itemsTransform));
}
}
public override int GetProcessInventoryItemCapacity(IInventory inventory, int slotIndex, int value)
{
int num = Terrain.ExtractContents(value);
MusketBlock.LoadState loadState = MusketBlock.GetLoadState(Terrain.ExtractData(inventory.GetSlotValue(slotIndex)));
if (loadState == MusketBlock.LoadState.Empty && num == 109)
{
return(1);
}
if (loadState == MusketBlock.LoadState.Gunpowder && num == 205)
{
return(1);
}
if (loadState == MusketBlock.LoadState.Wad && num == 214)
{
return(1);
}
return(0);
}
public override bool OnEditInventoryItem(IInventory inventory, int slotIndex, ComponentPlayer componentPlayer)
{
int value = inventory.GetSlotValue(slotIndex);
int count = inventory.GetSlotCount(slotIndex);
int data = Terrain.ExtractData(value);
int delay = AdjustableDelayGateBlock.GetDelay(data);
DialogsManager.ShowDialog(componentPlayer.GuiWidget, new EditAdjustableDelayGateDialog(delay, delegate(int newDelay)
{
int data2 = AdjustableDelayGateBlock.SetDelay(data, newDelay);
int num = Terrain.ReplaceData(value, data2);
if (num != value)
{
inventory.RemoveSlotItems(slotIndex, count);
inventory.AddSlotItems(slotIndex, num, 1);
}
}));
return(true);
}
public void CrossInventoryExchange(IItemStackSlot @from, IItemStackSlot to)
{
IInventory fromInventory = from.Inventory;
IInventory toInventory = to.Inventory;
ItemStack fromStack = fromInventory.RemoveStackAtSlot(from.InventoryIndex);
if (to.ItemStack.IsEmpty)
{
toInventory.AddStackAtSlot(fromStack, to.InventoryIndex);
}
else
{
ItemStack toStack = toInventory.RemoveStackAtSlot(to.InventoryIndex);
fromInventory.AddItemStacks(new[] { toInventory.AddStackAtSlot(fromStack, to.InventoryIndex) });
toInventory.AddItemStacks(new[] { fromInventory.AddStackAtSlot(toStack, from.InventoryIndex) });
}
}
public bool TryTransferItemsToInventory(IItemInstance item, IInventory oldInventory, IInventory newInventory, int count)
{
if (!CanTransferItemsToInventory(item, oldInventory, newInventory, count))
{
return(false);
}
var fullStack = item.Count == count;
var existingItem = newInventory.GetAllHeldItems().Where(x => x.IsSame(item)).SingleOrDefault();
if (existingItem == null) // No matching item in new inventory
{
if (fullStack)
{
(oldInventory as BaseInventory).RemoveItemInstance(item);
(newInventory as BaseInventory).AddItemInstance(item);
(item as BaseItem).SetCurrentInventory(newInventory);
return(true);
}
else
{
var newItem = CreateNewInstanceLike(item, newInventory, count);
(item as BaseItem).SetCount(item.Count - count);
return(true);
}
}
else
{
if (fullStack)
{
(oldInventory as BaseInventory).RemoveItemInstance(item);
(existingItem as BaseItem).SetCount(existingItem.Count + item.Count);
DeleteItem(item.Id);
return(true);
}
else
{
TransferBetweenInstances(existingItem, item, count);
return(true);
}
}
}
public void InventoryBarChanged(IInventory inventory)
{
var stackIndex = inventory.Slots - 1;
foreach (var stack in inventory.ItemStacks.Reverse())
{
stackIndex--;
if (stack.IsEmpty())
{
ClearBarSlotData(stackIndex + 1);;
continue;
}
SetBarSlotData(ContentChest.ItemTextures[stack.Item.ItemId], stack.Count, stackIndex + 1);
}
SelectedItemSlotChanged?.Invoke(_currentSelection);
}
public bool HandleMoveItem(IInventory sourceInventory, int sourceSlotIndex, IInventory targetInventory, int targetSlotIndex, int count)
{
int slotValue = sourceInventory.GetSlotValue(sourceSlotIndex);
int slotValue2 = targetInventory.GetSlotValue(targetSlotIndex);
int slotCount = sourceInventory.GetSlotCount(sourceSlotIndex);
int slotCount2 = targetInventory.GetSlotCount(targetSlotIndex);
if (slotCount2 == 0 || slotValue == slotValue2)
{
int num = MathUtils.Min(targetInventory.GetSlotCapacity(targetSlotIndex, slotValue) - slotCount2, slotCount, count);
if (num > 0)
{
int count2 = sourceInventory.RemoveSlotItems(sourceSlotIndex, num);
targetInventory.AddSlotItems(targetSlotIndex, slotValue, count2);
return(true);
}
}
return(false);
}
public override bool OnEditInventoryItem(IInventory inventory, int slotIndex, ComponentPlayer componentPlayer)
{
int value = inventory.GetSlotValue(slotIndex);
int count = inventory.GetSlotCount(slotIndex);
int data = Terrain.ExtractData(value);
int voltageLevel = BatteryBlock.GetVoltageLevel(data);
DialogsManager.ShowDialog(componentPlayer.GuiWidget, new EditBatteryDialog(voltageLevel, delegate(int newVoltageLevel)
{
int data2 = BatteryBlock.SetVoltageLevel(data, newVoltageLevel);
int num = Terrain.ReplaceData(value, data2);
if (num != value)
{
inventory.RemoveSlotItems(slotIndex, count);
inventory.AddSlotItems(slotIndex, num, 1);
}
}));
return(true);
}
private static void HandleAddCatalyst(GameSession session, PacketReader packet)
{
long itemUid = packet.ReadLong();
int itemId = packet.ReadInt();
packet.ReadInt();
int amount = packet.ReadInt();
IInventory inventory = session.Player.Inventory;
Item item = inventory.GetByUid(itemUid);
if (item == null || item.Amount < amount)
{
return;
}
// GMS2 Always 100% success rate
session.Send(LapenshardPacket.Select(10000));
}
public override void Init(IInventory p_inventory)
{
base.Init(p_inventory);
AddItemSlot(m_bodySlot, 4);
AddItemSlot(m_feetSlot, 6);
AddItemSlot(m_finger1Slot, 8);
AddItemSlot(m_finger2Slot, 9);
AddItemSlot(m_handsSlot, 5);
AddItemSlot(m_headSlot, 3);
AddItemSlot(m_mainHandSlot, 0);
AddItemSlot(m_neckSlot, 7);
AddItemSlot(m_offHandSlot, 1);
AddItemSlot(m_rangeWeaponSlot, 2);
InitStartItems();
DragDropManager.Instance.ShortcutRightclickEvent += OnShortcutRightclick;
DragDropManager.Instance.DragEvent += OnDragEvent;
DragDropManager.Instance.DropEvent += OnDropEvent;
LegacyLogic.Instance.EventManager.RegisterEvent(EEventType.INVENTORY_ITEM_REPAIR_STATUS_CHANGED, new EventHandler(OnItemRepairStatusChanged));
}
public void MineBlock(float hit, out bool destroyed, out IInventory loot, out int xp)
{
destroyed = true;
loot = null;
xp = 0;
if (structure != null && structure is Block)
{
Block b = (Block)structure;
b.Mine(hit, out destroyed);
if (destroyed)
{
loot = b.getLoot();
//Debug.Log("Loot: " + loot);
xp = b.getXpOnMine();
Structure = null;
}
}
}
protected void registerSlotModified(bool callModified = true)
{
eagent.GearInventory.SlotModified += gearSlotModified;
gearInv = eagent.GearInventory;
if (entity is EntityPlayer eplr)
{
IInventory inv = eplr.Player?.InventoryManager.GetOwnInventory(GlobalConstants.backpackInvClassName);
if (inv != null)
{
inv.SlotModified += backPackSlotModified;
}
}
if (callModified)
{
MarkShapeModified();
}
}
public void Setup()
{
EmptyInventory = new InventoryType();
OneItemInventory = new InventoryType();
TwoUniqueItemsInventory = new InventoryType();
TwoNonUniqueItemsInventory = new InventoryType();
TestItem = Substitute.For <Item>(new object[] { "Test Item", "TestItems" });
TestItem.CanUse(Arg.Any <IUsageContext>()).ReturnsForAnyArgs(false);
TestItem2 = Substitute.For <Item>(new object[] { "Test2 Item", "Test2 Items" });
TestItem2.CanUse(Arg.Any <IUsageContext>()).ReturnsForAnyArgs(false);
OneItemInventory.Add(TestItem);
TwoUniqueItemsInventory.Add(TestItem);
TwoUniqueItemsInventory.Add(TestItem2);
TwoNonUniqueItemsInventory.Add(TestItem);
TwoNonUniqueItemsInventory.Add(TestItem);
}
public override void Init(IInventory p_inventory)
{
base.Init(p_inventory);
Single num = m_itemSlotSpace.x * (m_width - 1) / 2f;
Single num2 = m_itemSlotSpace.y * (m_height - 1) / 2f;
for (Int32 i = 0; i < m_height; i++)
{
for (Int32 j = 0; j < m_width; j++)
{
Single x = -num + j * m_itemSlotSpace.x;
Single y = num2 - i * m_itemSlotSpace.y;
GameObject gameObject = NGUITools.AddChild(this.gameObject, m_itemSlotPrefab);
AddItemSlot(gameObject.GetComponent <ItemSlot>(), j + i * m_width);
gameObject.transform.localPosition = new Vector3(x, y, 0f);
}
}
InitStartItems();
}
public ElectricFurnaceWidget(IInventory inventory, ComponentElectricFurnace componentFurnace)
{
m_componentFurnace = componentFurnace;
WidgetsManager.LoadWidgetContents(this, this, ContentManager.Get <XElement>("Widgets/ElectricFurnaceWidget"));
m_inventoryGrid = Children.Find <GridPanelWidget>("InventoryGrid");
m_furnaceGrid = Children.Find <GridPanelWidget>("FurnaceGrid");
m_fire = Children.Find <FireWidget>("Fire");
m_progress = Children.Find <ValueBarWidget>("Progress");
m_resultSlot = Children.Find <InventorySlotWidget>("ResultSlot");
m_remainsSlot = Children.Find <InventorySlotWidget>("RemainsSlot");
m_circuitSlot = Children.Find <InventorySlotWidget>("CircuitSlot");
m_acceptsDropsBox = Children.Find <CheckboxWidget>("AcceptsElectBox");
m_circuit2Slot = Children.Find <InventorySlotWidget>("Circuit2Slot");
int num = 6, y, x;
InventorySlotWidget inventorySlotWidget;
for (y = 0; y < m_inventoryGrid.RowsCount; y++)
{
for (x = 0; x < m_inventoryGrid.ColumnsCount; x++)
{
inventorySlotWidget = new InventorySlotWidget();
inventorySlotWidget.AssignInventorySlot(inventory, num++);
m_inventoryGrid.Children.Add(inventorySlotWidget);
m_inventoryGrid.SetWidgetCell(inventorySlotWidget, new Point2(x, y));
}
}
num = 0;
for (y = 0; y < m_furnaceGrid.RowsCount; y++)
{
for (x = 0; x < m_furnaceGrid.ColumnsCount; x++)
{
inventorySlotWidget = new InventorySlotWidget();
inventorySlotWidget.AssignInventorySlot(componentFurnace, num++);
m_furnaceGrid.Children.Add(inventorySlotWidget);
m_furnaceGrid.SetWidgetCell(inventorySlotWidget, new Point2(x, y));
}
}
m_resultSlot.AssignInventorySlot(componentFurnace, componentFurnace.ResultSlotIndex);
m_remainsSlot.AssignInventorySlot(componentFurnace, componentFurnace.RemainsSlotIndex);
m_circuitSlot.AssignInventorySlot(componentFurnace, componentFurnace.Cir1SlotIndex);
m_circuit2Slot.AssignInventorySlot(componentFurnace, componentFurnace.Cir2SlotIndex);
}
private void LocalNode_InventoryReceived(object sender, IInventory inventory)
{
ConsensusPayload payload = inventory as ConsensusPayload;
if (payload != null)
{
lock (context)
{
if (payload.ValidatorIndex == context.MyIndex)
{
return;
}
if (payload.Version != ConsensusContext.Version || payload.PrevHash != context.PrevHash || payload.BlockIndex != context.BlockIndex)
{
return;
}
if (payload.ValidatorIndex >= context.Validators.Length)
{
return;
}
ConsensusMessage message = ConsensusMessage.DeserializeFrom(payload.Data);
if (message.ViewNumber != context.ViewNumber && message.Type != ConsensusMessageType.ChangeView)
{
return;
}
switch (message.Type)
{
case ConsensusMessageType.ChangeView:
OnChangeViewReceived(payload, (ChangeView)message);
break;
case ConsensusMessageType.PerpareRequest:
OnPerpareRequestReceived(payload, (PerpareRequest)message);
break;
case ConsensusMessageType.PerpareResponse:
OnPerpareResponseReceived(payload, (PerpareResponse)message);
break;
}
}
}
}
public bool WieldItem(IItem item, IInventory inventory) {
bool wielded = false;
if (!equipped.ContainsKey(Wearable.WIELD_RIGHT)) {
item.WornOn = Wearable.WIELD_RIGHT;
wielded = true;
}
else if (!equipped.ContainsKey(Wearable.WIELD_LEFT)) {
item.WornOn = Wearable.WIELD_LEFT;
wielded = true;
}
if (wielded) {
equipped.Add(item.WornOn, item);
inventory.inventory.RemoveWhere(i => i.Id == item.Id);
return true;
}
return false;
}
public static Commitment MergeCommitmentsOfThisType(ItemType itemType, IInventory committer,
IInventory committedTo)
{
List <Commitment> commitments = committer.GetAllOutgoingCommits().FindAll(commitment =>
commitment.itemType == itemType &&
commitment.committer == committer &&
commitment.committedTo == committedTo);
if (commitments.Count == 0)
{
return(null);
}
var merged = new Commitment(commitments.Sum(a => a.amount), itemType, committedTo, committer);
committer.RemoveCommitments(commitments);
committedTo.RemoveCommitments(commitments);
merged.CommitToComitterAndComitee();
return(merged);
}
public Client(IFactory factory)
{
if (factory == null)
throw new ArgumentNullException("factory");
_factory = factory;
_actionQueue = factory.CreateActionQueue();
_clients = new List<ClientData>();
_gameClients = new List<ClientData>();
_games = new List<GameData>();
_pieceBag = factory.CreatePieceBag(32);
_inventory = factory.CreateInventory(10);
Assembly entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
{
Version version = entryAssembly.GetName().Version;
Version = new Versioning
{
Major = version.Major,
Minor = version.Minor,
};
}// else, we suppose SetVersion will be called later, before connecting
_state = States.Created;
_clientId = Guid.Empty;
_lastActionFromServer = DateTime.Now;
_timeoutCount = 0;
_pieceIndex = 0;
_gameTimer = new System.Timers.Timer
{
Interval = GameTimerIntervalStartValue
};
_gameTimer.Elapsed += GameTimerOnElapsed;
_cancellationTokenSource = new CancellationTokenSource();
_timeoutTask = Task.Factory.StartNew(TimeoutTask, _cancellationTokenSource.Token);
_actionQueue.Start(_cancellationTokenSource);
}
public CraftingInventoryFurnaceCb(IInventory iinventory, TileEntityFurnace tileentityfurnace)
{
lastCookTime = 0;
lastBurnTime = 0;
lastItemBurnTime = 0;
furnace = tileentityfurnace;
addSlot(new Slot(tileentityfurnace, 0, 56, 17));
addSlot(new Slot(tileentityfurnace, 1, 56, 53));
addSlot(new Slot(tileentityfurnace, 2, 116, 35));
for (int i = 0; i < 3; i++)
{
for (int k = 0; k < 9; k++)
{
addSlot(new Slot(iinventory, k + i*9 + 9, 8 + k*18, 84 + i*18));
}
}
for (int j = 0; j < 9; j++)
{
addSlot(new Slot(iinventory, j, 8 + j*18, 142));
}
}
public TradeScreen(ScreenComponent manager, IInventory trader, IInventory player)
: base(manager, new Point(400, 300))
{
this.trader = trader;
this.player = player;
Controls.Add(new Panel(manager) { Position = new Rectangle(20, 20, 360, 40) });
Controls.Add(new Label(manager) { Text = "Shop", Position = new Rectangle(40, 30, 0, 0) });
// Verkaufbare Items des Trader-Inventars auf die Liste setzen
list = new TraderList(manager) { Position = new Rectangle(20, 70, 360, 210) };
list.OnInteract += OnInteract;
foreach (var item in trader.Inventory.Where(i => i.Value.HasValue).OrderBy(i => i.Value))
list.Items.Add(new TradingItem()
{
Tag = item,
Text = item.Name,
Icon = item.Icon,
Value = item.Value.Value
});
Controls.Add(list);
CheckAvailability();
}
public CraftingInventoryPlayerCB(InventoryPlayer inventoryplayer, bool flag)
{
craftMatrix = new InventoryCrafting(this, 2, 2);
craftResult = new InventoryCraftResult();
isMP = false;
isMP = flag;
addSlot(new SlotCrafting(craftMatrix, craftResult, 0, 144, 36));
for (int i = 0; i < 2; i++)
{
for (int i1 = 0; i1 < 2; i1++)
{
addSlot(new Slot(craftMatrix, i1 + i*2, 88 + i1*18, 26 + i*18));
}
}
for (int j = 0; j < 4; j++)
{
int j1 = j;
addSlot(new SlotArmor(this, inventoryplayer, inventoryplayer.getSizeInventory() - 1 - j, 8, 8 + j*18, j1));
}
for (int k = 0; k < 3; k++)
{
for (int k1 = 0; k1 < 9; k1++)
{
addSlot(new Slot(inventoryplayer, k1 + (k + 1)*9, 8 + k1*18, 84 + k*18));
}
}
for (int l = 0; l < 9; l++)
{
addSlot(new Slot(inventoryplayer, l, 8 + l*18, 142));
}
onCraftMatrixChanged(craftMatrix);
}
public CraftingInventoryDispenserCB(IInventory iinventory, TileEntityDispenser tileentitydispenser)
{
field_21133_a = tileentitydispenser;
for (int i = 0; i < 3; i++)
{
for (int l = 0; l < 3; l++)
{
addSlot(new Slot(tileentitydispenser, l + i*3, 61 + l*18, 17 + i*18));
}
}
for (int j = 0; j < 3; j++)
{
for (int i1 = 0; i1 < 9; i1++)
{
addSlot(new Slot(iinventory, i1 + j*9 + 9, 8 + i1*18, 84 + j*18));
}
}
for (int k = 0; k < 9; k++)
{
addSlot(new Slot(iinventory, k, 8 + k*18, 142));
}
}
public async Task<string> Run()
{
IGameFactory factory = _game.Factory;
float panelWidth = _game.Settings.VirtualResolution.Width * 3 / 4f;
float panelHeight = _game.Settings.VirtualResolution.Height * 3 / 4f;
const float labelHeight = 20f;
const float textBoxHeight = 20f;
const float buttonHeight = 20f;
const float itemHeight = 20f;
const float itemPaddingX = 5f;
const float itemPaddingY = 5f;
const float scrollButtonWidth = 20f;
const float scrollButtonHeight = 20f;
const float scrollButtonOffsetX = 5f;
const float scrollButtonOffsetY = 5f;
const float okButtonWidth = 50f;
const float okButtonHeight = 20f;
const float okButtonPaddingX = 20f;
const float okButtonPaddingY = 20f;
float okCancelWidth = okButtonWidth * 2 + okButtonPaddingX;
float okButtonX = panelWidth / 2f - okCancelWidth / 2f;
float cancelButtonX = okButtonX + okButtonWidth + okButtonPaddingX;
float panelX = _game.Settings.VirtualResolution.Width / 2f - panelWidth / 2f;
float panelY = _game.Settings.VirtualResolution.Height / 2f - panelHeight / 2f;
ITextConfig textBoxConfig = new AGSTextConfig(alignment: Alignment.BottomLeft,
autoFit: AutoFit.TextShouldCrop, font: Hooks.FontLoader.LoadFont(null, 10f));
IPanel panel = factory.UI.GetPanel("SelectFilePanel", panelWidth, panelHeight, panelX, panelY);
panel.SkinTags.Add(AGSSkin.DialogBoxTag);
panel.Skin.Apply(panel);
ILabel titleLabel = factory.UI.GetLabel("SelectFileTitle", _title, panelWidth, labelHeight, 0f, panelHeight - labelHeight, _buttonsTextConfig);
_fileTextBox = factory.UI.GetTextBox("SelectFileTextBox", 0f, panelHeight - labelHeight - textBoxHeight, _startPath, textBoxConfig, width: panelWidth, height: textBoxHeight);
_inventory = new AGSInventory();
IInventoryWindow invWindow = factory.Inventory.GetInventoryWindow("SelectFileInventory", panelWidth - scrollButtonWidth - scrollButtonOffsetX * 2,
panelHeight - labelHeight - buttonHeight - textBoxHeight - okButtonPaddingY, ITEM_WIDTH + itemPaddingX, itemHeight + itemPaddingY, 0f, okButtonPaddingY + okButtonHeight, _inventory);
invWindow.Z = 1;
IButton okButton = factory.UI.GetButton("SelectFileOkButton", (string)null, null, null, okButtonX, okButtonPaddingY, "OK", _buttonsTextConfig, width: okButtonWidth, height: okButtonHeight);
IButton cancelButton = factory.UI.GetButton("SelectFileCancelButton", (string)null, null, null, cancelButtonX, okButtonPaddingY, "Cancel", _buttonsTextConfig, width: okButtonWidth, height: okButtonHeight);
IButton scrollDownButton = factory.UI.GetButton("SelectFileScrollDown", (string)null, null, null, panelWidth - scrollButtonWidth - scrollButtonOffsetX, okButton.Y + okButtonHeight + scrollButtonOffsetY, "", _buttonsTextConfig, width: scrollButtonWidth, height: scrollButtonHeight);
IButton scrollUpButton = factory.UI.GetButton("SelectFileScrollUp", (string)null, null, null, panelWidth - scrollButtonWidth - scrollButtonOffsetX, panelHeight - labelHeight - textBoxHeight - scrollButtonHeight - scrollButtonOffsetY, "", _buttonsTextConfig, width: scrollButtonWidth, height: scrollButtonHeight);
titleLabel.TreeNode.SetParent(panel.TreeNode);
_fileTextBox.TreeNode.SetParent(panel.TreeNode);
invWindow.TreeNode.SetParent(panel.TreeNode);
okButton.TreeNode.SetParent(panel.TreeNode);
cancelButton.TreeNode.SetParent(panel.TreeNode);
scrollDownButton.TreeNode.SetParent(panel.TreeNode);
scrollUpButton.TreeNode.SetParent(panel.TreeNode);
cancelButton.MouseClicked.Subscribe(onCancelClicked);
okButton.MouseClicked.Subscribe(onOkClicked);
scrollDownButton.MouseClicked.Subscribe((sender, args) => invWindow.ScrollDown());
scrollUpButton.MouseClicked.Subscribe((sender, args) => invWindow.ScrollUp());
_fileIcon = new FileIcon(_glUtils);
_fileIconSelected = new FileIcon(_glUtils) { IsSelected = true };
_folderIcon = new FolderIcon(_glUtils);
_folderIconSelected = new FolderIcon(_glUtils) { IsSelected = true };
var arrowDownIcon = getIcon("ArrowDown", factory, scrollButtonWidth, scrollButtonHeight,
new ArrowIcon(_glUtils) { Direction = ArrowIcon.ArrowDirection.Down });
arrowDownIcon.Anchor = new PointF();
arrowDownIcon.Enabled = false;
arrowDownIcon.TreeNode.SetParent(scrollDownButton.TreeNode);
_game.State.UI.Add(arrowDownIcon);
var arrowUpIcon = getIcon("ArrowUp", factory, scrollButtonWidth, scrollButtonHeight,
new ArrowIcon(_glUtils) { Direction = ArrowIcon.ArrowDirection.Up });
arrowUpIcon.Anchor = new PointF();
arrowUpIcon.Enabled = false;
arrowUpIcon.TreeNode.SetParent(scrollUpButton.TreeNode);
_game.State.UI.Add(arrowUpIcon);
_fileGraphics = getIcon("FileGraphics", factory, ITEM_WIDTH, itemHeight, _fileIcon);
_folderGraphics = getIcon("FolderGraphics", factory, ITEM_WIDTH, itemHeight, _folderIcon);
fillAllFiles(_startPath);
_fileTextBox.OnPressingKey.Subscribe(onTextBoxKeyPressed);
bool okGiven = await _tcs.Task;
removeAllUI(panel);
if (!okGiven) return null;
return _fileTextBox.Text;
}
/// <summary>
/// Verarbeitet den Zustandsabgleich eines Items.
/// </summary>
/// <param name="item">Item referenz</param>
/// <param name="area">Area in der das Item liegt (oder null, falls Inventar)</param>
/// <param name="inventory">Inventar in dem sich das Item befindet (oder null, falls Area)</param>
private void HandleItem(Item item, Area area, IInventory inventory)
{
ItemCacheEntry entity;
if (items.TryGetValue(item.Id, out entity))
{
// Frame Update
entity.LastUpdate = currentFrame;
// Item move
if (entity.Area != area || entity.Inventory != inventory)
{
foreach (var client in clients.ToArray())
client.SendMove(entity.Item, entity.Area, area, entity.Inventory, inventory);
entity.Area = area;
entity.Inventory = inventory;
}
// Updates
if (currentFrame % KEYFRAME == 0)
{
// Großes Update
foreach (var client in clients.ToArray())
client.SendKeyUpdate(item);
}
else if (currentFrame % UPDATEFRAME == 0)
{
// Kleines Update
foreach (var client in clients.ToArray())
client.SendUpdate(item);
}
}
else
{
// Item fehlt -> Insert
items.Add(item.Id, new ItemCacheEntry()
{
Item = item,
Area = area,
Inventory = inventory,
LastUpdate = currentFrame
});
foreach (var client in clients.ToArray())
client.SendInsert(item, area, inventory);
}
}
public InventoryWorker(string name, WaitHandle waitForIt, IInventory inventory)
: base(name, waitForIt)
{
_inventory = inventory;
}
public override void onCraftMatrixChanged(IInventory iinventory)
{
craftResult.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(craftMatrix));
}
/// <summary>
/// Sendet einen Insert-Auftrag an den Client.
/// </summary>
/// <param name="item">Item.</param>
/// <param name="area">Area.</param>
/// <param name="inventory">Inventory.</param>
public void SendInsert(Item item, Area area, IInventory inventory)
{
try
{
if (area != null)
{
// Area[string];Type[string];Id[int];Payload[byte[]]
writer.Write((byte)MessageType.ServerInsertItemToArea);
writer.Write((short)0);
writer.Write(area.Name);
}
else
{
// InventoryId[int];Type[string];Id[int];Payload[byte[]]
writer.Write((byte)MessageType.ServerInsertItemToArea);
writer.Write((short)0);
writer.Write((inventory as Item).Id);
}
// Type ermitteln
writer.Write(item.GetType().FullName);
writer.Write(item.Id);
// Payload ermitteln und erstellen
item.SerializeInsert(writer);
int contentend = (int)writerStream.Position;
// Content Länge eintragen
writerStream.Seek(1, SeekOrigin.Begin);
writer.Write((short)(contentend - 3));
writerStream.Seek(contentend, SeekOrigin.Begin);
Flush();
}
catch (Exception ex)
{
Close(ex, false);
}
}
public SlotCrafting(IInventory iinventory, IInventory iinventory1, int i, int j, int k)
: base(iinventory1, i, j, k)
{
craftMatrix = iinventory;
}
/// <summary>
/// Sendet einen Area/Inventar-Transfer des angegebenen Items an diesen Client.
/// </summary>
/// <param name="item">Item.</param>
/// <param name="oldArea">Old area.</param>
/// <param name="newArea">New area.</param>
/// <param name="oldInventory">Old inventory.</param>
/// <param name="newInventory">New inventory.</param>
public void SendMove(Item item, Area oldArea, Area newArea, IInventory oldInventory, IInventory newInventory)
{
if (oldArea != null)
{
if (newArea != null)
{
// Area to Area
// ItemId[int];OldArea[string];NewArea[string]
writer.Write((byte)MessageType.ServerMoveAreaToArea);
writer.Write((short)0);
writer.Write(item.Id);
writer.Write(oldArea.Name);
writer.Write(newArea.Name);
}
else
{
// Area to Inventory
// ItemId[int];OldArea[string];InventoryId[int]
writer.Write((byte)MessageType.ServerMoveAreaToInventory);
writer.Write((short)0);
writer.Write(item.Id);
writer.Write(oldArea.Name);
writer.Write((newInventory as Item).Id);
}
}
else
{
if (newArea != null)
{
// Inventory To Area
// ItemId[int];InventoryId[int];NewArea[string]
writer.Write((byte)MessageType.ServerMoveInventoryToArea);
writer.Write((short)0);
writer.Write(item.Id);
writer.Write((oldInventory as Item).Id);
writer.Write(newArea.Name);
}
else
{
// Inventory To Inventory
// ItemId[int];OldInventoryId[int];NewInventoryId[int]
writer.Write((byte)MessageType.ServerMoveInventoryToInventory);
writer.Write((short)0);
writer.Write(item.Id);
writer.Write((oldInventory as Item).Id);
writer.Write((newInventory as Item).Id);
}
}
int contentend = (int)writerStream.Position;
writerStream.Seek(1, SeekOrigin.Begin);
writer.Write((short)(contentend - 3));
writerStream.Seek(contentend, SeekOrigin.Begin);
Flush();
}
public OrderProcessor(IInventory inventory)
{
_inventory = inventory;
}
public void PrintCost(IPlayer player, IInventory inventory)
{
string text = "";
foreach (var pair in cost)
{
text += pair.Key + ": " + inventory.GetItemCount(pair.Key) + "/" + pair.Value + ", ";
}
player.Reply(text);
}
public virtual void displayGUIChest(IInventory iinventory)
{
}
public ValidatingOrderProcessor(IValidator<Order> validator, IInventory inventory, IPublisher publisher)
: base(inventory, publisher)
{
_validator = validator;
}
