// update specific private void priorityIn(List <tListEntry> list, SelectorProtocol target, int nPriority, bool bPaused) { tListEntry listElement = new tListEntry(); listElement.target = target; listElement.priority = nPriority; listElement.paused = bPaused; listElement.markedForDeletion = false; // list will not be empty, because it is new in init() int index = 0; foreach (tListEntry element in list) { if (nPriority < element.priority) { break; } ++index; } // Can not throw exception, because index in [0, count] list.Insert(index, listElement); // update hash entry for quick access tHashUpdateEntry hashElement = new tHashUpdateEntry(); hashElement.target = target; hashElement.list = list; hashElement.entry = listElement; m_pHashForUpdates.Add(target, hashElement); }
private void priorityIn(List <tListEntry> list, SelectorProtocol target, int nPriority, bool bPaused) { tListEntry item = new tListEntry { target = target, priority = nPriority, paused = bPaused, markedForDeletion = false }; int index = 0; foreach (tListEntry entry2 in list) { if (nPriority < entry2.priority) { break; } index++; } list.Insert(index, item); tHashUpdateEntry entry3 = new tHashUpdateEntry { target = target, list = list, entry = item }; this.m_pHashForUpdates.Add(target, entry3); }
/** Schedules the 'update' selector for a given target with a given priority. * The 'update' selector will be called every frame. * The lower the priority, the earlier it is called. * @since v0.99.3 */ public void scheduleUpdateForTarget(SelectorProtocol targt, int nPriority, bool bPaused) { tHashUpdateEntry hashElement = null; if (m_pHashForUpdates.ContainsKey(targt)) { // TODO: check if priority has changed! hashElement = m_pHashForUpdates[targt]; hashElement.entry.markedForDeletion = false; } // most of the updates are going to be 0, that's way there // is an special list for updates with priority 0 if (nPriority == 0) { appendIn(m_pUpdates0List, targt, bPaused); } else if (nPriority < 0) { priorityIn(m_pUpdatesNegList, targt, nPriority, bPaused); } else { priorityIn(m_pUpdatesPosList, targt, nPriority, bPaused); } }
public void unscheduleUpdateForTarget(SelectorProtocol target) { if ((target != null) && this.m_pHashForUpdates.ContainsKey(target)) { tHashUpdateEntry entry = this.m_pHashForUpdates[target]; if (this.m_bUpdateHashLocked) { entry.entry.markedForDeletion = true; } else { this.removeUpdateFromHash(entry.entry); } } }
public void resumeTarget(SelectorProtocol target) { if (target != null) { if (this.m_pHashForSelectors.ContainsKey(target)) { this.m_pHashForSelectors[target].paused = false; } if (this.m_pHashForUpdates.ContainsKey(target)) { tHashUpdateEntry entry = this.m_pHashForUpdates[target]; entry.entry.paused = false; } } }
private void appendIn(List <tListEntry> list, SelectorProtocol target, bool bPaused) { tListEntry listElement = new tListEntry(); listElement.target = target; listElement.paused = bPaused; listElement.markedForDeletion = false; list.Add(listElement); // update hash entry for quicker access tHashUpdateEntry hashElement = new tHashUpdateEntry(); hashElement.target = target; hashElement.list = list; hashElement.entry = listElement; m_pHashForUpdates.Add(target, hashElement); }
private void appendIn(List <tListEntry> list, SelectorProtocol target, bool bPaused) { tListEntry item = new tListEntry { target = target, paused = bPaused, markedForDeletion = false }; list.Add(item); tHashUpdateEntry entry2 = new tHashUpdateEntry { target = target, list = list, entry = item }; this.m_pHashForUpdates.Add(target, entry2); }
private void removeUpdateFromHash(tListEntry entry) { if (this.m_pHashForUpdates.ContainsKey(entry.target)) { tHashUpdateEntry entry2 = this.m_pHashForUpdates[entry.target]; entry2.list.Remove(entry); entry2.entry = null; entry2.target = null; SelectorProtocol key = null; foreach (KeyValuePair <SelectorProtocol, tHashUpdateEntry> pair in this.m_pHashForUpdates) { if (entry2 == pair.Value) { key = pair.Key; break; } } this.m_pHashForUpdates.Remove(key); } }
/** Unschedules the update selector for a given target * @since v0.99.3 */ public void unscheduleUpdateForTarget(SelectorProtocol target) { if (target == null) { return; } if (m_pHashForUpdates.ContainsKey(target)) { tHashUpdateEntry element = m_pHashForUpdates[target]; if (m_bUpdateHashLocked) { element.entry.markedForDeletion = true; } else { removeUpdateFromHash(element.entry); } } }
/** Resumes the target. * The 'target' will be unpaused, so all schedule selectors/update will be 'ticked' again. * If the target is not present, nothing happens. * @since v0.99.3 */ public void resumeTarget(SelectorProtocol target) { if (target == null) { return; } // custom selectors if (m_pHashForSelectors.ContainsKey(target)) { m_pHashForSelectors[target].paused = false; } // Update selector if (m_pHashForUpdates.ContainsKey(target)) { tHashUpdateEntry element = m_pHashForUpdates[target]; Debug.Assert(element != null); element.entry.paused = false; } }
public void scheduleUpdateForTarget(SelectorProtocol targt, int nPriority, bool bPaused) { tHashUpdateEntry entry = null; if (this.m_pHashForUpdates.ContainsKey(targt)) { entry = this.m_pHashForUpdates[targt]; entry.entry.markedForDeletion = false; } if (nPriority == 0) { this.appendIn(this.m_pUpdates0List, targt, bPaused); } else if (nPriority < 0) { this.priorityIn(this.m_pUpdatesNegList, targt, nPriority, bPaused); } else { this.priorityIn(this.m_pUpdatesPosList, targt, nPriority, bPaused); } }
private void removeUpdateFromHash(tListEntry entry) { if (m_pHashForUpdates.ContainsKey(entry.target)) { // list entry tHashUpdateEntry element = m_pHashForUpdates[entry.target]; element.list.Remove(entry); element.entry = null; // hash entry element.target = null; SelectorProtocol target = null; foreach (KeyValuePair <SelectorProtocol, tHashUpdateEntry> kvp in m_pHashForUpdates) { if (element == kvp.Value) { target = kvp.Key; break; } } m_pHashForUpdates.Remove(target); } }
/** Pauses the target. * All scheduled selectors/update for a given target won't be 'ticked' until the target is resumed. * If the target is not present, nothing happens. * @since v0.99.3 */ public void pauseTarget(SelectorProtocol target) { if (target == null) { return; } // custom selectors if (m_pHashForSelectors.ContainsKey(target)) { m_pHashForSelectors[target].paused = true; } // Update selector if (m_pHashForUpdates.ContainsKey(target)) { tHashUpdateEntry element = m_pHashForUpdates[target]; if (element != null) { element.entry.paused = true; } } }
// update specific private void priorityIn(List<tListEntry> list, SelectorProtocol target, int nPriority, bool bPaused) { tListEntry listElement = new tListEntry(); listElement.target = target; listElement.priority = nPriority; listElement.paused = bPaused; listElement.markedForDeletion = false; // list will not be empty, because it is new in init() int index = 0; foreach (tListEntry element in list) { if (nPriority < element.priority) { break; } ++index; } // Can not throw exception, because index in [0, count] list.Insert(index, listElement); // update hash entry for quick access tHashUpdateEntry hashElement = new tHashUpdateEntry(); hashElement.target = target; hashElement.list = list; hashElement.entry = listElement; m_pHashForUpdates.Add(target, hashElement); }
private void appendIn(List<tListEntry> list, SelectorProtocol target, bool bPaused) { tListEntry listElement = new tListEntry(); listElement.target = target; listElement.paused = bPaused; listElement.markedForDeletion = false; list.Add(listElement); // update hash entry for quicker access tHashUpdateEntry hashElement = new tHashUpdateEntry(); hashElement.target = target; hashElement.list = list; hashElement.entry = listElement; m_pHashForUpdates.Add(target, hashElement); }