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; }