public TLDocumentHeaderListView() { // isolatedStorageProvider = new IsolatedStorageProvider(); InitializeComponent(); Loaded += (s, ea) => { _accessUtility = SmObjectFactory.Container.GetInstance <AccessUtility>(); _viewModel = DataContext as TLDocumentHeaderListViewModel; RadGridView1.SelectedItem = null; _viewModel.Error += OnError; _viewModel.Information += OnInformation; _viewModel.Deleting += OnDeleting; _viewModel.Deleted += OnDeleted; // isolatedStorageProvider.LoadFromStorage(); }; Unloaded += (s, ea) => { _viewModel.Error -= OnError; _viewModel.Information -= OnInformation; _viewModel.Deleting -= OnDeleting; _viewModel.Deleted -= OnDeleted; // isolatedStorageProvider.SaveToStorage(); }; }
/// <summary> /// On menu item select. /// </summary> static void Skill() { DadCell res = null; if (Selection.activeGameObject != null) { res = AccessUtility.GetComponentInParent <DadCell>(Selection.activeGameObject.transform); } if (res != null) { // Create skill from prefab string prefabName = "Demo/Skill"; GameObject prefab = Resources.Load <GameObject>(prefabName); if (prefab != null) { GameObject go = Instantiate(prefab, res.transform); go.name = prefab.name; go.transform.SetAsFirstSibling(); } else { Debug.Log("Can't find needed prefab in Resources folder: " + prefabName); } } else { Debug.Log("Please choose any DaD cell on scene before add this element"); } }
/// <summary> /// Updates stack's condition. /// </summary> private void UpdateCondition() { int stack = GetStack(); if (stack > 1) { ShowStack(); } else if (stack == 1) { // Hide stack text if stack == 0 HideStack(); } else { // Stack <= 0 DadCell dadCell = AccessUtility.GetComponentInParent <DadCell>(transform); if (dadCell != null) { dadCell.RemoveItem(); } else { Destroy(gameObject); } } }
public override bool IsAuthorized(AuthFilterContext context) { if (DomainUtility.IsTestEnvironment) { return(true); } using (APIAccessService apiAccessService = new APIAccessService()) { //when a client is calling main api ,they have to put token,which is password, in header named token if (context.ActionContext.Request.Headers.Contains("token")) { return(apiAccessService.HasAccess(ApiUtility.GetIPAddress(), context.ActionContext.Request.Headers.GetValues("token").FirstOrDefault())); } else { if (AccessUtility.CalledByLocalSA(HttpContext.Current.Request)) { //it is called from single action module in same server with same ip. return(true); } else { //when bpms user panel is calling engine api,every request should have formToken in its parameters. string formToken = context.ActionContext.RequestContext.Url.Request.GetHttpContext().Request.QueryString[FormTokenUtility.FormToken]; return(FormTokenUtility.ValidateFormToken(formToken, HttpContext.Current.Session.SessionID)); } } } }
void Start() { this.AddResourcesToInventory ( "Inventory/Resources/res_cloth", "Inventory/Resources/res_cloth", "Inventory/Resources/res_cotton", "Inventory/Resources/res_cotton", "Inventory/Resources/res_cotton" ); // Crea el inventario con el número de casillas especificado for (int i = 1; i <= maxSlots; i++) { Instantiate(slotPrefab, slotsContainer.transform).name = "Slot " + i; } // Llena el inventario de objetos foreach (KeyValuePair <string, int> entry in inventory) { // Aquí se debe comprobar el número máximo de recursos agrupables. // Si por ejemplo hay 78 unidades de tela y se pueden agrupar máximo en grupos de 30, // se deberán agrupar en 3 casillas diferentes así: tela x30, tela x30 y tela x18 Debug.Log(this.AddResource(entry.Key, entry.Value)); } // Init existing items's internal state on scene start foreach (StackItem stackItem in AccessUtility.FindObjectsOfType <StackItem>()) { stackItem.Init(); } this.AddRecipe("Inventory/Recipes/rec_shirt"); }
/// <summary> /// Adds existing item. /// </summary> /// <returns>The item.</returns> /// <param name="stackItem">Stack item.</param> /// <param name="limit">Limit.</param> public int AddExistingItem(StackItem stackItem, int limit) { int res = 0; if (stackItem != null) { // Init internal state (just in case it was not initted before) stackItem.Init(); StackGroup sourceStackGroup = AccessUtility.GetComponentInParent <StackGroup>(stackItem.transform); StackCell sourceStackCell = stackItem.GetStackCell(); StackGroupEventDescriptor desc = new StackGroupEventDescriptor(); // Try to distribute item inside group's items and cells DistributeResults distributeResults = DistributeAnywhere(stackItem, limit, null); res += distributeResults.amount; // Send stack event notification if (res > 0) { PlaySound(stackItem.sound); desc.sourceGroup = sourceStackGroup; desc.destinationGroup = this; desc.sourceCell = sourceStackCell; desc.destinationCells = distributeResults.cells; SendNotification(desc); } } return(res); }
// private ICompanyInformationsService companyInformationsService; public GLListView() { isolateStorageProvider = new IsolatedStorageProvider(); _gLsService = SmObjectFactory.Container.GetInstance <IGLsService>(); // companyInformationsService = SmObjectFactory.Container.GetInstance<ICompanyInformationsService>(); InitializeComponent(); Loaded += (s, ea) => { _accessUtility = SmObjectFactory.Container.GetInstance <AccessUtility>(); _viewModel = DataContext as GLListViewModel; _viewModel.Failed += OnFailed; _viewModel.Error += OnError; _viewModel.LoadGLs(); GLDataForm.CommandProvider = new CustomCommandProvider(); // //GLDataForm.AddNewItem(); GLRadGridView.SelectedItem = null; detailRadTabItem.IsSelected = true; // isolateStorageProvider.LoadFromStorage(); }; Unloaded += (s, ea) => { _viewModel.Failed -= OnFailed; _viewModel.Error -= OnError; // isolateStorageProvider.SaveToStorage(); }; }
/// <summary> /// This item is dropped. /// </summary> /// <param name="eventData"></param> public void OnEndDrag(PointerEventData eventData) { ResetConditions(); // Check for cells under cursor bool emptyDrop = true; PointerEventData pointerData = new PointerEventData(EventSystem.current); pointerData.position = Input.mousePosition; List <RaycastResult> hits = new List <RaycastResult>(); EventSystem.current.RaycastAll(pointerData, hits); if (hits.Count > 0) { foreach (RaycastResult hit in hits) { DadCell dadCell = hit.gameObject.GetComponent <DadCell>(); if (dadCell != null) { emptyDrop = false; break; } } } if (emptyDrop == true) { DadCell.DadEventDescriptor desc = new DadCell.DadEventDescriptor(); desc.sourceCell = GetCell(); desc.triggerType = DadCell.TriggerType.EmptyDrop; AccessUtility.SendMessageUpwards(transform, "OnDadGroupEvent", desc); } }
public TLListView() { isolatedStorageProvider = new IsolatedStorageProvider(); _tLsService = SmObjectFactory.Container.GetInstance <ITLsService>(); InitializeComponent(); Loaded += (s, ea) => { _accessUtility = SmObjectFactory.Container.GetInstance <AccessUtility>(); _viewModel = DataContext as TLListViewModel; _viewModel.Error += OnError; _viewModel.LoadTLs(); // RaiseCanExecuteChanged(); //NavStateFalse(); //var addNewTLCommand = RadDataFormCommands.AddNew as RoutedUICommand; TLDataForm.CommandProvider = new CustomCommandProvider(); //addNewTLCommand.Execute(null, TLDataForm); TLRadGridView.SelectedItem = null; detailRadTabItem.IsSelected = true; // DataContext = _viewModel; isolatedStorageProvider.LoadFromStorage(); }; Unloaded += (s, ea) => { _viewModel.Error -= OnError; isolatedStorageProvider.SaveToStorage(); }; }
public TLDocumentItemListView() { InitializeComponent(); Loaded += (s, ea) => { _accessUtility = SmObjectFactory.Container.GetInstance <AccessUtility>(); _viewModel = DataContext as TLDocumentItemListViewModel; RadGridView1.SelectedItem = null; }; }
private PriceGroup priceGroup; // Player's price group /// <summary> /// Start this instance. /// </summary> void Start() { // Init existing items's internal state on scene start foreach (StackItem stackItem in AccessUtility.FindObjectsOfType <StackItem>()) { stackItem.Init(); } priceGroup = GetComponent <PriceGroup>(); Debug.Assert(equipment && inventory && vendor && skills && inventoryStackGroup && equipmentStackGroup && vendorStackGroup && clickEquipInventory && priceGroup, "Wrong settings"); priceGroup.ShowPrices(vendor.activeSelf); }
// GET: Audits public ActionResult Index(int?id) { var audits = from s in db.Audits select s; if (id != null) { audits = audits.Where(audit => audit.ProjectId == id); } ViewBag.IsCreateEnable = AccessUtility.IsCreateEnable(db, User.Identity.Name); return(View(audits.Include(a => a.Project).ToList())); }
/// <summary> /// Distribute destination item in source group than place source item in just vacated cell. /// </summary> /// <returns><c>true</c>, if item was replaced, <c>false</c> otherwise.</returns> /// <param name="sourceStackItem">Source stack item.</param> /// <param name="destinationStackItem">Destination stack item.</param> public bool ReplaceItems(StackItem sourceStackItem, StackItem destinationStackItem) { bool res = false; StackCell sourceStackCell = sourceStackItem.GetStackCell(); StackCell destinationStackCell = destinationStackItem.GetStackCell(); StackGroup sourceStackGroup = AccessUtility.GetComponentInParent <StackGroup>(sourceStackItem.transform); if (sourceStackItem != null && destinationStackItem != null && sourceStackCell != null && destinationStackCell != null && sourceStackGroup != null) { StackGroupEventDescriptor distributeDesc = new StackGroupEventDescriptor(); StackGroupEventDescriptor swapDesc = new StackGroupEventDescriptor(); // Try distribute item from destination cell into source group DistributeResults distributeResults = sourceStackGroup.DistributeAnywhere(destinationStackItem, destinationStackItem.GetStack(), null); if (distributeResults.amount > 0) { distributeDesc.sourceGroup = this; distributeDesc.destinationGroup = sourceStackGroup; distributeDesc.sourceCell = destinationStackCell; distributeDesc.destinationCells = distributeResults.cells; // If destination cell is empty now if (destinationStackCell.GetStackItem() == null) { // Place source item into it if (destinationStackCell.UniteStack(sourceStackItem, sourceStackItem.GetStack()) > 0) { PlaySound(sourceStackItem.sound); swapDesc.sourceGroup = sourceStackGroup; swapDesc.destinationGroup = this; swapDesc.sourceCell = sourceStackCell; swapDesc.destinationCells.Add(destinationStackCell); res = true; } } } if (distributeResults.amount > 0) { // Send distribute stack event notification SendNotification(distributeDesc); if (res == true) { // Send swap stack item event notification SendNotification(swapDesc); } } } return(res); }
/// <summary> /// Remove quick item. /// </summary> public void Remove() { DadCell dadCell = AccessUtility.GetComponentInParent <DadCell>(transform); if (dadCell != null) { dadCell.RemoveItem(); } else { Destroy(gameObject); } }
public TreeAccountListView() { _systemAccountingSettingsService = SmObjectFactory.Container.GetInstance <ISystemAccountingSettingsService>(); _gLsService = SmObjectFactory.Container.GetInstance <IGLsService>(); InitializeComponent(); Loaded += (s, ea) => { _accessUtility = SmObjectFactory.Container.GetInstance <AccessUtility>(); _vm = DataContext as TreeAccountListViewModel; _vm.Load(); }; }
/// <summary> /// Unites item in stack with this cell. /// </summary> /// <returns>The stack.</returns> /// <param name="stackItem">Stack item.</param> /// <param name="limit">Stack limit.</param> public int UniteStack(StackItem stackItem, int limit) { int res = 0; if (stackItem != null) { int allowedSpace = GetAllowedSpace(); StackItem myStackItem = GetStackItem(); if (myStackItem == null) // Cell has no item { if (SortCell.IsSortAllowed(gameObject, stackItem.gameObject) == true) // Item type is allowed for this cell { if (stackItem.GetStack() == limit && allowedSpace >= limit) // Cell has anough space for all item's stack { // Totaly place item in new cell DadCell sourceDadCell = AccessUtility.GetComponentInParent <DadCell>(stackItem.transform); if (sourceDadCell != null) { DadCell.SwapItems(gameObject, sourceDadCell.gameObject); } else { DadCell.AddItem(gameObject, stackItem.gameObject); } res = limit; } else // Only part of item stack will be placed into new cell { // Create new stack item to put it into this cell StackItem newStackItem = Instantiate(stackItem); newStackItem.name = stackItem.name; DadCell.AddItem(gameObject, newStackItem.gameObject); // Check the correct amout of united item int stackDelta = Mathf.Min(stackItem.GetStack(), allowedSpace, limit); newStackItem.SetStack(stackDelta); stackItem.ReduceStack(stackDelta); res = stackDelta; } } } else if (HasSameItem(stackItem) == true) // Cell has same item { int stackDelta = Mathf.Min(stackItem.GetStack(), allowedSpace, limit); myStackItem.AddStack(stackDelta); stackItem.ReduceStack(stackDelta); res = stackDelta; } } return(res); }
/// <summary> /// Awake this instance. /// </summary> void Awake() { foreach (GameObject source in permittedSources) { StackGroup stackGroup = AccessUtility.GetComponentInParent <StackGroup>(source.transform); if (stackGroup == null) { stackGroup = source.GetComponentInChildren <StackGroup>(true); } if (stackGroup != null && stackGroup.eventAdditionalReceivers.Contains(gameObject) == false) { // Add quick slot group as stack events receiver stackGroup.eventAdditionalReceivers.Add(gameObject); } } }
// GET: Projects/Details/5 public ActionResult Details(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } var project = db.Projects.Find(id); if (project == null) { return(HttpNotFound()); } ViewBag.IsEditEnable = AccessUtility.IsEditEnable(db, User.Identity.Name); ViewBag.IsDeleteEnable = AccessUtility.IsDeleteEnable(db, User.Identity.Name); return(View(project)); }
/// <summary> /// Uses the item. /// </summary> public void UseItem() { bool res = true; CooldownItem cooldown = GetComponent <CooldownItem>(); if (cooldown != null && cooldown.timeLeft > 0f) { res = false; } // Use item if there is no active cooldown if (res == true) { // Notify application about item use AccessUtility.SendMessageUpwards(transform, "OnItemUse", gameObject); } }
// GET: Audits/Details/5 public ActionResult Details(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } var audit = db.Audits.Include(s => s.Project).Include(s => s.Files).SingleOrDefault(s => s.AuditId == id); if (audit == null) { return(HttpNotFound()); } ViewBag.IsAddResultEnable = AccessUtility.IsAddResultEnable(db, User.Identity.Name) && (audit.Status == AuditStatuses.Planned || audit.Status == AuditStatuses.InProgress); ViewBag.IsEditEnable = AccessUtility.IsEditEnable(db, User.Identity.Name); ViewBag.IsDeleteEnable = AccessUtility.IsDeleteEnable(db, User.Identity.Name); return(View(audit)); }
public UserListView() { InitializeComponent(); Loaded += (s, ea) => { _accessUtility = SmObjectFactory.Container.GetInstance <AccessUtility>(); _viewModel = DataContext as UserListViewModel; radGridView.SelectedItem = null; _viewModel.Deleting += OnDeleting; _viewModel.Deleted += OnDeleted; _viewModel.Failed += OnFailed; }; Unloaded += (s, ea) => { _viewModel.Deleting -= OnDeleting; _viewModel.Deleted -= OnDeleted; _viewModel.Failed -= OnFailed; }; }
/// <summary> /// Removes quick slot items if they have no source or source is not in permitted groups /// </summary> public void RemoveUnresolvedItems() { foreach (QuickItem quickItem in GetComponentsInChildren <QuickItem>(true)) { bool hit = false; // Chek if item source is child of this GO foreach (Transform parentTransform in AccessUtility.GetComponentsInParent <Transform>(quickItem.itemSource.transform)) { if (permittedSources.Contains(parentTransform.gameObject) == true) { hit = true; break; } } if (hit == false) { // If item source was moved outside or deleted - remove quick item quickItem.Remove(); } } }
/// <summary> /// Raises the DaD group event. /// </summary> /// <param name="desc">Desc.</param> public void OnDadGroupEvent(DadCell.DadEventDescriptor desc) { switch (desc.triggerType) { case DadCell.TriggerType.DragGroupRequest: case DadCell.TriggerType.DropGroupRequest: if (myState == MyState.WaitForRequest) { // Disable standard DaD logic desc.groupPermission = false; myState = MyState.WaitForEvent; } break; case DadCell.TriggerType.DragEnd: if (myState == MyState.WaitForEvent) { StackGroup sourceStackControl = AccessUtility.GetComponentInParent <StackGroup>(desc.sourceCell.transform); StackGroup destStackControl = AccessUtility.GetComponentInParent <StackGroup>(desc.destinationCell.transform); if (sourceStackControl != destStackControl) { // If this group is source group - do nothing myState = MyState.WaitForRequest; } } break; case DadCell.TriggerType.DropEnd: if (myState == MyState.WaitForEvent) { // If this group is destination group myState = MyState.Busy; // Operate item's drop eventHandkerCoroutine = coroutineContainer.StartCoroutine(EventHandler(desc)); } break; } }
/// <summary> /// Sends the stack event notification. /// </summary> /// <param name="desc">Event descriptor.</param> private void SendNotification(StackGroupEventDescriptor desc) { if (desc.sourceGroup != null) { // Send notification to source GO AccessUtility.SendMessageUpwards(desc.sourceGroup.transform, "OnStackGroupEvent", desc); foreach (GameObject receiver in desc.sourceGroup.eventAdditionalReceivers) { // Send notification to additionaly specified GOs AccessUtility.SendMessage(receiver.transform, "OnStackGroupEvent", desc); } } if (desc.destinationGroup != null && desc.sourceGroup != desc.destinationGroup && desc.destinationGroup.trashBinMode == false) { // Send notification to destination GO AccessUtility.SendMessageUpwards(desc.destinationGroup.transform, "OnStackGroupEvent", desc); foreach (GameObject receiver in desc.destinationGroup.eventAdditionalReceivers) { // Send notification to additionaly specified GOs AccessUtility.SendMessage(receiver.transform, "OnStackGroupEvent", desc); } } }
public CloseProfitLossAccountListView() { isolatedStorageProvider = new IsolatedStorageProvider(); InitializeComponent(); Loaded += (s, ea) => { _accessUtility = SmObjectFactory.Container.GetInstance <AccessUtility>(); _viewModel = DataContext as CloseProfitLossAccountListViewModel; RadGridView1.SelectedItem = null; _viewModel.Error += OnError; _viewModel.Information += OnInformation; isolatedStorageProvider.LoadFromStorage(); }; Unloaded += (s, ea) => { _viewModel.Error -= OnError; _viewModel.Information -= OnInformation; isolatedStorageProvider.SaveToStorage(); }; }
// GET: Projects public ActionResult Index(string sortOrder, string searchString) { ViewBag.NameSortParm = string.IsNullOrEmpty(sortOrder) ? "name_desc" : ""; ViewBag.DateSortParm = sortOrder == "Date" ? "date_desc" : "Date"; var projects = from s in db.Projects select s; if (!string.IsNullOrEmpty(searchString)) { projects = projects.Where(s => s.Name.Contains(searchString)); } var audits = from s in db.Audits select s; var projectView = HelperForProject.CreateProjectView(projects.ToList(), audits.ToList()); switch (sortOrder) { case "name_desc": projectView = projectView.OrderByDescending(s => s.Project.Name); break; //case "Date": // projects = projects.OrderBy(s => s.PlannedDate); // break; //case "date_desc": // projects = projects.OrderByDescending(s => s.PlannedDate); // break; default: projectView = projectView.OrderBy(s => s.Project.Name); break; } ViewBag.IsCreateEnable = AccessUtility.IsCreateEnable(db, User.Identity.Name); return(View(projectView.ToList())); }
/// <summary> /// Stack event handler. /// </summary> /// <returns>The handler.</returns> /// <param name="desc">Desc.</param> private IEnumerator EventHandler(DadCell.DadEventDescriptor dadDesc) { StackGroup sourceStackGroup = AccessUtility.GetComponentInParent <StackGroup>(dadDesc.sourceCell.transform); StackGroup destStackGroup = AccessUtility.GetComponentInParent <StackGroup>(dadDesc.destinationCell.transform); if (sourceStackGroup == null || destStackGroup == null) { dadDesc.groupPermission = false; myState = MyState.WaitForRequest; yield break; } StackCell destStackCell = dadDesc.destinationCell.GetComponent <StackCell>(); StackCell sourceStackCell = dadDesc.sourceCell.GetComponent <StackCell>(); if (destStackCell == null || sourceStackCell == null) { dadDesc.groupPermission = false; myState = MyState.WaitForRequest; yield break; } StackItem destStackItem = destStackCell.GetStackItem(); StackItem sourceStackItem = sourceStackCell.GetStackItem(); StackGroupEventDescriptor stackDescPrimary = new StackGroupEventDescriptor(); // Stack event info stackDescPrimary.sourceGroup = sourceStackGroup; stackDescPrimary.destinationGroup = destStackGroup; stackDescPrimary.sourceCell = sourceStackCell; StackGroupEventDescriptor stackDescSecondary = new StackGroupEventDescriptor(); // One more stack event info in case if destination cell is not empty and items were swapped stackDescSecondary.sourceGroup = destStackGroup; stackDescSecondary.destinationGroup = sourceStackGroup; stackDescSecondary.sourceCell = destStackCell; DistributeResults distributeResults = new DistributeResults(); // Info with results of stack item distribution in stack group PriceItem priceItem = sourceStackItem.GetComponent <PriceItem>(); PriceGroup buyer = AccessUtility.GetComponentInParent <PriceGroup>(dadDesc.destinationCell.transform); PriceGroup seller = AccessUtility.GetComponentInParent <PriceGroup>(dadDesc.sourceCell.transform); AudioClip itemSound = sourceStackItem.sound; // Item's SFX int amount = sourceStackItem.GetStack(); // Item's stack amount if (amount > 1) { // If item's stack > 1 try to use split interface if ((globalSplit == true) || (sourceStackGroup != destStackGroup && (sourceStackGroup.splitOuter == true || destStackGroup.splitOuter == true))) { // Need to use split interface if (splitInterface != null) { if (priceItem != null && buyer != null && seller != null && buyer != seller) { // Split with prices splitInterface.ShowSplitter(sourceStackItem, priceItem); } else { // Split without prices splitInterface.ShowSplitter(sourceStackItem, null); } // Show split interface and wait while it is active while (splitInterface.gameObject.activeSelf == true) { yield return(new WaitForEndOfFrame()); } // Get splitted stack amount amount = splitInterface.GetRightAmount(); } } } if (amount > 0) { if (sourceStackGroup != destStackGroup && (destStackGroup.arrangeMode == true || sourceStackGroup.arrangeMode == true)) { // Split in arrange mode between different stack groups if (priceItem != null && buyer != null && seller != null && buyer != seller) { // Different price groups if ((long)buyer.GetCash() >= (long)priceItem.GetPrice() * amount) { // Has anough cash distributeResults = DistributeAnywhere(sourceStackItem, amount, null); if (distributeResults.amount > 0) { stackDescPrimary.destinationCells = distributeResults.cells; int totalPrice = priceItem.GetPrice() * distributeResults.amount; seller.AddCash(totalPrice); buyer.SpendCash(totalPrice); buyer.UpdatePrices(); } } } else { // Same price group distributeResults = DistributeAnywhere(sourceStackItem, amount, null); if (distributeResults.amount > 0) { stackDescPrimary.destinationCells = distributeResults.cells; } } } else { // Inside same stack group transactions disabled in arrange mode if (arrangeMode == false) { if (destStackItem != null) { // Check if items allowed for destination cell if (SortCell.IsSortAllowed(destStackCell.gameObject, sourceStackItem.gameObject) == true) { // Destination cell already has same item if (destStackCell.HasSameItem(sourceStackItem) == true) { if (destStackCell.UniteStack(sourceStackItem, amount) > 0) { stackDescPrimary.destinationCells.Add(destStackCell); } } // Check if items allowed for source cell else if (SortCell.IsSortAllowed(sourceStackCell.gameObject, destStackItem.gameObject) == true) { // Different items. Try to swap items between cells if (destStackCell.SwapStacks(sourceStackCell) == true) { // Swap successful stackDescSecondary.destinationCells.Add(sourceStackCell); sourceStackItem = sourceStackCell.GetStackItem(); if (sourceStackItem != null) { // Distribute item after swap distributeResults = DistributeInItems(sourceStackItem, sourceStackItem.GetStack(), destStackCell); if (distributeResults.amount > 0) { stackDescPrimary.destinationCells = distributeResults.cells; } if (destStackCell.GetStackItem() != null) { // If stack item (or part of it) in destination cell stackDescPrimary.destinationCells.Add(destStackCell); } } } else { // Swap unsuccessful. // Try to distribute item between other cells to make cell free distributeResults = DistributeAnywhere(destStackItem, destStackItem.GetStack(), destStackCell); if (distributeResults.amount > 0) { stackDescSecondary.destinationCells = distributeResults.cells; } destStackItem = destStackCell.GetStackItem(); if (destStackItem != null) { // Item still in cell. Try to place item in other group's cells distributeResults = sourceStackGroup.DistributeAnywhere(destStackItem, destStackItem.GetStack(), null); if (distributeResults.amount > 0) { stackDescSecondary.destinationCells.AddRange(distributeResults.cells); } destStackItem = destStackCell.GetStackItem(); if (destStackItem == null) { // Item was placed into other cell and now this cell is free // Place item into destination cell if (destStackCell.UniteStack(sourceStackItem, amount) > 0) { stackDescPrimary.destinationCells.Add(destStackCell); } } } else { // Item was placed into other cell and now this cell is free // Place item into destination cell if (destStackCell.UniteStack(sourceStackItem, amount) > 0) { stackDescPrimary.destinationCells.Add(destStackCell); } } } } } } else { // Destination cell has no item // Place item into destination cell if (destStackCell.UniteStack(sourceStackItem, amount) > 0) { stackDescPrimary.destinationCells.Add(destStackCell); } } } } } // Send stack event notifications if (stackDescSecondary.destinationCells.Count > 0) { SendNotification(stackDescSecondary); } if (stackDescPrimary.destinationCells.Count > 0) { SendNotification(stackDescPrimary); if (trashBinMode == true) { // In trash bin mode just destroy item dadDesc.destinationCell.RemoveItem(); PlaySound(trashBinSound); } else { PlaySound(itemSound); } } myState = MyState.WaitForRequest; eventHandkerCoroutine = null; }
/// <summary> /// Gets the stack cell of this item. /// </summary> /// <returns>The stack cell.</returns> public StackCell GetStackCell() { return(AccessUtility.GetComponentInParent <StackCell>(transform)); }
/// <summary> /// Gets DaD cell which contains this item. /// </summary> /// <returns>The cell.</returns> public DadCell GetCell() { return(AccessUtility.GetComponentInParent <DadCell>(transform)); }