void Awake()
{
baseObject = GetComponent <DungeonObject>();
tickable = GetComponent <Tickable>();
baseObject.onMove += OnMove;
baseObject.onPickedUpObject += OnPickedUpObject;
}
public void DeregisterEntity(Tickable tickable)
{
lock (mutex)
{
Tickables.Remove(tickable);
}
}
public void RegisterEntity(Tickable tickable)
{
lock (mutex)
{
Tickables.Add(tickable);
}
}
/// Remove a manual tickable object.
/// A manual tickable object must be add/remove by AddTickable/RemoveTickable.
public void RemoveTickable(Tickable pTickable)
{
pTickable.Stop();
pTickable.DecRef();
_nManualTickersCount--;
Debugger.Assert(_nManualTickersCount >= 0);
}
//public int ID { get { return tickable.ID; } }
void Start()
{
tickable = new Tickable(Name);
if (GameStateManager.Instance != null) {
tickable.ID = GameStateManager.Instance.Tickables.Count;
GameStateManager.Instance.Tickables.Add (tickable);
}
}
private void evalSubscribed()
{
for (int i = 0; i < subscribed.Count; i += 1)
{
Tickable subscriber = subscribed [i];
subscriber.discreteUpdate();
}
/*foreach(Tickable subscriber in subscribed ){
* subscriber.discreteUpdate();
* }*/
}
/// Internal publics
public void _PlayTickable(Tickable tickable)
{
// push tween into list.
if (!tickable._InQueue)
{
Debugger.Assert(!_arrInQueueTickers.Contains(tickable));
/// if (__bInUpdateing) __bNewAddedWhenUpdate = true;
tickable._InQueue = true;
_arrInQueueTickers.Add(tickable);
}
Debugger.ConditionalAssert(tickable._InQueue, _arrInQueueTickers.Contains(tickable));
}
///------------ Implementation ------------------
private void _updateTickables(float fTime, float fRealTime)
{
int iLastDeadIndex = -1;
int nCount = _arrInQueueTickers.Count;
Tickable[] arrTickers = _arrInQueueTickers._Buffer;
__AliveTickableCount = 0;
for (int i = 0; i < nCount; ++i)
{
Tickable pTicker = arrTickers[i];
if (pTicker._IsDead)
{
iLastDeadIndex = i;
continue;
}
__AliveTickableCount++;
if (pTicker.status == TickerStatus.PUASED)
{
continue;
}
pTicker._Tick(pTicker._Scalable ? fTime : fRealTime);
}
if (iLastDeadIndex != -1)
{
Tickable lastDeadTicker = _arrInQueueTickers[iLastDeadIndex];
lastDeadTicker._InQueue = false;
if (iLastDeadIndex != _arrInQueueTickers.Count - 1)
{
_arrInQueueTickers[iLastDeadIndex] = _arrInQueueTickers.Pop();
}
else
{
_arrInQueueTickers.Pop();
}
}
}
IEnumerator Tick()
{
tickableIndex = tickableObjects.Count - 1;
while (true)
{
bool isDone = true;
if (currentAction != null)
{
if (!isInterrupted)
{
isDone = currentAction.ContinueAction();
if (!isDone)
{
yield return(new WaitForEndOfFrame());
continue;
}
}
if (isInterrupted || isDone)
{
//bool isOnCamera =
// currentAction.owner.transform.position.x > mapCamera.transform.position.x - mapCamera.orthographicSize * mapCamera.aspect &&
// currentAction.owner.transform.position.x < mapCamera.transform.position.x + mapCamera.orthographicSize * mapCamera.aspect &&
// currentAction.owner.transform.position.y > mapCamera.transform.position.y - mapCamera.orthographicSize &&
// currentAction.owner.transform.position.y < mapCamera.transform.position.y + mapCamera.orthographicSize;
//if (!isInterrupted && currentAction.owner.tile.isInView && currentAction.owner.tile.isLit && isOnCamera)
//{
// bool isNextTickablePlayer = tickableObjects[tickableIndex] == Player.instance.identity.GetComponent<Tickable>();
// isWaitingBetweenActions = !isPlayerAction && !isNextTickablePlayer;
// startWaitBetweenActionsTime = Time.time;
//}
currentAction.FinishAction();
currentAction = null;
isPlayerAction = false;
}
}
//if (isWaitingBetweenActions)
//{
// if (isInterrupted)
// {
// isWaitingBetweenActions = false;
// }
// else
// {
// if (Time.time - startWaitBetweenActionsTime < timeBetweenActions)
// {
// yield return new WaitForEndOfFrame();
// continue;
// }
// else
// {
// isWaitingBetweenActions = false;
// }
// }
//}
if (isDone || isInterrupted)
{
for (; tickableIndex >= 0; tickableIndex--)
{
var ob = tickableObjects[tickableIndex];
if (ob.markedForRemoval)
{
continue;
}
if (time >= ob.nextActionTime)
{
if (Player.instance.identity.GetComponent <Tickable>() == ob)
{
if (Player.instance.hasReceivedInput)
{
isPlayerAction = true;
isInterrupted = false;
Player.instance.hasReceivedInput = false;
Player.instance.isWaitingForPlayerInput = false;
}
else
{
Player.instance.isWaitingForPlayerInput = true;
currentAction = null;
break;
}
}
ulong actionDuration = 1;
bool finishImmediately = ob.StartNewAction(out actionDuration);
ob.nextActionTime = time + actionDuration;
bool wasPlayerAction = isPlayerAction;
bool isOnCamera =
ob.owner.transform.position.x > mapCamera.transform.position.x - mapCamera.orthographicSize * mapCamera.aspect &&
ob.owner.transform.position.x <mapCamera.transform.position.x + mapCamera.orthographicSize *mapCamera.aspect &&
ob.owner.transform.position.y> mapCamera.transform.position.y - mapCamera.orthographicSize &&
ob.owner.transform.position.y < mapCamera.transform.position.y + mapCamera.orthographicSize;
if (!isInterrupted && ob.owner.tile.isInView && ob.owner.tile.isLit && isOnCamera)
{
int nextTickableIndex = tickableIndex - 1;
if (nextTickableIndex <= 0)
{
nextTickableIndex = tickableObjects.Count - 1;
}
bool isNextTickablePlayer = tickableObjects[nextTickableIndex] == Player.instance.identity.GetComponent <Tickable>();
isWaitingBetweenActions = !wasPlayerAction && !isNextTickablePlayer && !finishImmediately;
startWaitBetweenActionsTime = Time.time;
if (isWaitingBetweenActions)
{
yield return(new WaitForSeconds(timeBetweenActions));
}
//tickableIndex--;
//break;
}
if (finishImmediately || !ob.owner.tile.isInView || !ob.owner.tile.isLit || isInterrupted || !isOnCamera)
{
ob.FinishAction();
currentAction = null;
isPlayerAction = false;
//tickableIndex--;
}
else
{
currentAction = ob;
}
if (isInterrupted && ob == interruptingTickable)
{
isInterrupted = false;
interruptingTickable = null;
}
if (currentAction != null)
{
tickableIndex--;
break;
}
}
}
if (tickableIndex == -1)
{
for (int ri = tickableObjects.Count - 1; ri >= 0; ri--)
{
var ob = tickableObjects[ri];
if (ob.markedForRemoval)
{
tickableObjects.RemoveAt(ri);
}
}
time++;
tickableIndex = tickableObjects.Count - 1;
}
}
if (currentAction == null)
{
yield return(new WaitForEndOfFrame());
}
}
}
public void Interrupt(Tickable interruptingTickable)
{
this.interruptingTickable = interruptingTickable;
isInterrupted = true;
}
/// <summary>
/// Unregister an ticked element.
/// Used because it's impossible to delete an array element during array iteration.
/// </summary>
/// <param name="child">Element to unregister</param>
public void clockUnregister(Tickable child)
{
this.clocksOld.Add(child);
}
/// <summary>
/// Register an element to be ticked every 1/30 sec
/// </summary>
/// <param name="child">Element to register</param>
public void clockRegister(Tickable child)
{
this.clocksNew.Add(child);
}
public void unsubscribe(Tickable subscriber)
{
subscribed.Remove(subscriber);
}
public void subscribe(Tickable subscriber)
{
subscribed.Add(subscriber);
}
