public override void Transfer(ref PointerItem otherpitem, string Button) { if (otherpitem.Item == AcceptedItem.Item || otherpitem.Item == null) { QuickSwap(ref otherpitem); } }
/// <summary> /// Loads the results for the current page. /// </summary> private void LoadScanResults() { Snapshot snapshot = SnapshotManager.GetSnapshot(Snapshot.SnapshotRetrievalMode.FromActiveSnapshot, this.ActiveType); IList <ScanResult> newAddresses = new List <ScanResult>(); if (snapshot != null) { UInt64 startIndex = Math.Min(ScanResultsViewModel.PageSize * this.CurrentPage, snapshot.ElementCount); UInt64 endIndex = Math.Min((ScanResultsViewModel.PageSize * this.CurrentPage) + ScanResultsViewModel.PageSize, snapshot.ElementCount); for (UInt64 index = startIndex; index < endIndex; index++) { SnapshotElementIndexer element = snapshot[index]; String label = element.GetElementLabel() != null?element.GetElementLabel().ToString() : String.Empty; Object currentValue = element.HasCurrentValue() ? element.LoadCurrentValue() : null; Object previousValue = element.HasPreviousValue() ? element.LoadPreviousValue() : null; String moduleName = String.Empty; UInt64 address = Query.Default.AddressToModule(element.BaseAddress, out moduleName); PointerItem pointerItem = new PointerItem(baseAddress: address, dataType: this.ActiveType, moduleName: moduleName, value: currentValue); newAddresses.Add(new ScanResult(new PointerItemView(pointerItem), previousValue, label)); } } this.Addresses = new FullyObservableCollection <ScanResult>(newAddresses); // Ensure results are visible this.IsVisible = true; this.IsSelected = true; this.IsActive = true; }
/// <summary> /// Loads the results for the current page. /// </summary> private void LoadPointerScanResults() { IList <PointerItem> newAddresses = new List <PointerItem>(); UInt64 count = this.DiscoveredPointers.Count; UInt64 startIndex = Math.Min(PointerScanResultsViewModel.PageSize * this.CurrentPage, count); UInt64 endIndex = Math.Min((PointerScanResultsViewModel.PageSize * this.CurrentPage) + PointerScanResultsViewModel.PageSize, count); for (UInt64 index = startIndex; index < endIndex; index++) { PointerItem pointerItem = this.DiscoveredPointers[index]; if (pointerItem != null) { newAddresses.Add(pointerItem); } } this.Addresses = new ObservableCollection <PointerItem>(newAddresses); // Ensure results are visible this.IsVisible = true; this.IsSelected = true; this.IsActive = true; }
public virtual bool AddItem(PointerItem ToBeAdded) { if (ToBeAdded.Item != null) { if (!CheckIfIsFull()) { for (int i = 0; i < Slots.Length; i++) { if (Slots[i].Pitem.Item == ToBeAdded.Item) { if (Slots[i].Pitem.Amount + ToBeAdded.Amount < Slots[i].Pitem.Item.MaxStackAmount) { Slots[i].SetSlotItem(new PointerItem(ToBeAdded.Item, Slots[i].Pitem.Amount + ToBeAdded.Amount)); return(true); } } else if (Slots[i].Pitem.IsEmpty()) { Slots[i].SetSlotItem(ToBeAdded); return(true); } } } } return(false); }
public void Initialize() { if (StartingItemList != null) { PointerItem[] PItems = new PointerItem[Size]; for (int i = 0; i < Size; i++) { if (i < StartingItemList.List.Length) { PItems[i] = StartingItemList.List[i]; } else { PItems[i] = new PointerItem(); } } MainInventory = new Inventory(PItems); for (int i = 0; i < Size; i++) { GameObject G = Instantiate(UISlot, gameObject.transform); G.GetComponent <UISlot>().Initialize(MainInventory.Slots[i]); } } else { Debug.LogError("set the list of starting items for this level on the InventoryUIManager!"); } }
private void StartScan(int index, Int64 searchAddress, bool validatingProcess = false) { if (index > 0) { SnapshotManager.ClearSnapshots(); } ConstraintNode scanConstraints = new ScanConstraint(ScanConstraint.ConstraintType.Equal, searchAddress, dataType); TrackableTask <Snapshot> valueCollectorTask = ValueCollector.CollectValues( SnapshotManager.GetSnapshot(Snapshot.SnapshotRetrievalMode.FromActiveSnapshotOrPrefilter, dataType), TrackableTask.UniversalIdentifier); valueCollectorTask.OnCompletedEvent += ((completedValueCollectionTask) => { Snapshot snapshot = valueCollectorTask.Result; TrackableTask <Snapshot> scanTask = ManualScanner.Scan( snapshot, scanConstraints, TrackableTask.UniversalIdentifier); SnapshotManager.SaveSnapshot(scanTask.Result); snapshot = scanTask.Result; scannedAddresses.Add(new List <Int64>()); if (snapshot != null) { for (UInt64 i = 0; i < snapshot.ElementCount; ++i) { SnapshotElementIndexer element = snapshot[i]; Object currentValue = element.HasCurrentValue() ? element.LoadCurrentValue() : null; Object previousValue = element.HasPreviousValue() ? element.LoadPreviousValue() : null; String moduleName = String.Empty; UInt64 address = Query.Default.AddressToModule(element.BaseAddress, out moduleName); PointerItem pointerItem = new PointerItem(baseAddress: address, dataType: dataType, moduleName: moduleName, value: currentValue); pointerItem.ForceResolveAddress(); scannedAddresses[index].Add(Int64.Parse(pointerItem.AddressSpecifier, NumberStyles.HexNumber, CultureInfo.CurrentCulture)); } } int nextIteration = index + 1; if (nextIteration < addressesToFind.Count) { StartScan(nextIteration, addressesToFind[nextIteration], validatingProcess); } else { SearchLogic(validatingProcess); } }); }
private PointerItem CorrectValue(StructureInfo structureInfo, PointerItem fieldValue) { if (fieldValue is PointerPageItem pointerPageItem) { pointerPageItem.ChannelSystemId = structureInfo.Id(pointerPageItem.ChannelSystemId); } fieldValue.EntitySystemId = structureInfo.Id(fieldValue.EntitySystemId); return(fieldValue); }
/// <summary> /// Initializes a new instance of the <see cref="ScanResult" /> class. /// </summary> /// <param name="pointerItem">The inner pointer item.</param> /// <param name="dataType">The data type of the value at this address.</param> /// <param name="value">The initial value of this result.</param> /// <param name="previousValue">The previous scan value.</param> /// <param name="label">The label of this result.</param> public ScanResult(PointerItem pointerItem, Object previousValue, String label) { this.PointerItem = pointerItem; this.PreviousValue = previousValue; this.Label = label; PropertyChangedEventHandler eventHandler = new PropertyChangedEventHandler(PointerItemChanged); this.PointerItem.PropertyChanged += eventHandler; }
protected virtual void UpdateUI(PointerItem Pitem) { if (Pitem != null) { ItemImage.sprite = Pitem.Item?.DisplayImage; ItemImage.color = Pitem.Item == null ? Color.clear : Color.white; ItemAmountText.text = Pitem.Amount.ToString(); ItemAmountText.color = Pitem.Amount < 1 ? Color.clear : Color.white; } }
private void ExtractPointer(Int32 levelIndex) { Pointer pointer = this.DiscoveredPointers.GetRandomPointer(levelIndex); if (pointer != null) { PointerItem pointerItem = new PointerItem(pointer.BaseAddress, this.ActiveType, "New Pointer", null, pointer.Offsets); ProjectExplorerViewModel.GetInstance().AddProjectItems(pointerItem); } }
public override void Transfer(ref PointerItem otherpitem, string Button) { if (otherpitem.Item == null) { QuickSwap(ref otherpitem); } else if (otherpitem.Item == Pitem.Item) { otherpitem = new PointerItem(Pitem.Item, otherpitem.Amount + Pitem.Amount); SetSlotItem(new PointerItem()); } }
public void SetOutputSihlouette(PointerItem PItem) { if (PItem != null) { TradePItem = PItem; if (ReferenceSlot.Pitem.IsEmpty()) { Sihlouette.sprite = PItem.Item?.DisplayImage; ItemAmountText.text = PItem.Amount.ToString(); ItemImage.color = Color.clear; } } }
protected override void UpdateUI(PointerItem Pitem) { if (Pitem != null) { if (Pitem.Item != null) { base.UpdateUI(Pitem); } else { SetOutputSihlouette(TradePItem); } } }
/// <summary> /// Enumerates the pointers of the specified pointer branch. /// </summary> /// <param name="baseAddress">The current base address.</param> /// <param name="offsets">The offsets leading to this branch.</param> /// <param name="branch">The current branch.</param> /// <param name="pointerIndicies">The indicies at which to return non-null values.</param> /// <returns>The full pointer path to the branch.</returns> private IEnumerable <PointerItem> EnumerateBranches(UInt64 baseAddress, Stack <Int32> offsets, PointerBranch branch, PointerIndicies pointerIndicies) { offsets.Push(branch.Offset); // End index reached if (pointerIndicies.Finished) { yield break; } if (branch.Branches.Count <= 0) { PointerItem pointerItem; // Only create pointer items when in the range of the selection indicies. This is an optimization to prevent creating unneeded objects. if (pointerIndicies.IterateNext()) { String moduleName; UInt64 address = AddressResolver.GetInstance().AddressToModule(baseAddress, out moduleName); pointerItem = new PointerItem(address.ToIntPtr(), DataTypes.Int32, "New Pointer", moduleName, offsets.ToArray().Reverse()); } else { pointerItem = null; } yield return(pointerItem); } else { foreach (PointerBranch childBranch in branch) { foreach (PointerItem pointerItem in this.EnumerateBranches(baseAddress, offsets, childBranch, pointerIndicies)) { yield return(pointerItem); } } } offsets.Pop(); }
/// <summary> /// Enumerates the pointers of the specified pointer branch. /// </summary> /// <param name="baseAddress">The current base address.</param> /// <param name="offsets">The offsets leading to this branch.</param> /// <param name="branch">The current branch.</param> /// <returns>The full pointer path to the branch.</returns> private IEnumerable <PointerItem> EnumerateBranches(UInt64 baseAddress, Stack <Int32> offsets, PointerBranch branch) { offsets.Push(branch.Offset); if (branch.Branches.Count <= 0) { PointerItem pointerItem = new PointerItem(baseAddress.ToIntPtr(), typeof(Int32), "New Pointer", null, offsets.ToArray().Reverse()); yield return(pointerItem); } else { foreach (PointerBranch childBranch in branch) { foreach (PointerItem pointerItem in this.EnumerateBranches(baseAddress, offsets, childBranch)) { yield return(pointerItem); } } } offsets.Pop(); }
public MaininventorySlot(PointerItem pitem) => Pitem = pitem;
public PointerItemView(PointerItem pointerItem) { this.PointerItem = pointerItem; }
public PointerItemView(PointerItem pointerItem) { this.PointerItem = pointerItem; this.PointerItem.PropertyChanged += PointerItemPropertyChanged; }
/// <summary> /// Adds the given scan result address to the project explorer. /// </summary> /// <param name="scanResult">The scan result to add to the project explorer.</param> private void AddAddress(PointerItem scanResult) { ProjectExplorerViewModel.GetInstance().AddNewProjectItems(addToSelected: false, projectItems: scanResult); }
public Slot(PointerItem pitem) => Pitem = pitem;