public void Add(string name, DateTime time)
{
var to = new TimedObject(name, time);
to.passed += (ab, n) => echo(to);
tos.Add(to);
}
/// <summary>
/// Deactivates an active object if one is available
/// </summary>
/// <param name="a_object">The object to deactivate</param>
/// <returns>True if the object passed in was deactivated, false if the object is not in the active objects list</returns>
public bool DeactivateObject(GameObject a_object)
{
TimedObject objectToDeactivate = null;
for (int i = 0; i < m_activeObjects.Count; ++i)
{
if (m_activeObjects[i].m_obj == a_object)
{
objectToDeactivate = m_activeObjects[i];
break;
}
}
if (objectToDeactivate == null)
{
return(false);
}
ObjectPooler objectPooler = objectToDeactivate.m_obj.GetComponent <ObjectPooler>();
if (objectPooler != null)
{
objectPooler.DeactivateAll();
}
a_object.SetActive(false);
m_activeObjects.Remove(objectToDeactivate);
m_inactiveObjects.Add(objectToDeactivate);
return(true);
}
/// <summary>
/// Creates all the gameobjects to pool and deactivates them for later, also initiaises pooling lists
/// </summary>
/// <param name="a_prefab">The prefab of the objects to create</param>
/// <param name="a_objectParent">The transform to parent created objects to</param>
private void SetupObjects()
{
if (m_prefab == null)
{
return;
}
m_inactiveObjects = new List <TimedObject>(m_maxObjects);
m_activeObjects = new List <TimedObject>();
for (int i = 0; i < m_maxObjects; ++i)
{
GameObject newObj = GameObject.Instantiate(m_prefab, m_objectParent);
newObj.name = "Pooled Object";
newObj.tag = m_objectTag;
PooledObject pooledObjectScript = newObj.GetComponent <PooledObject>();
if (pooledObjectScript != null)
{
pooledObjectScript.SetPooler(this);
}
newObj.SetActive(false);
TimedObject newTimeObject = new TimedObject(newObj);
m_inactiveObjects.Add(newTimeObject);
}
}
public NetworkResponse SendRequestBlocking([NotNull] TimedObject <NetworkRequest> request, long additionalTimeout = 1, TimeUnit additionalTimeoutUnit = TimeUnit.Seconds)
{
if (additionalTimeout >= 0)
{
return(SendRequestBlocking(request, TimeUtils.TimeUnitToTimeSpan(additionalTimeout, additionalTimeoutUnit)));
}
return(SendRequestBlocking(request, null));
}
public void CompleteRequest(TimedObject <NetworkRequest> request, NetworkResponse response)
{
lock (timedRequestManager.timedObjects)
{
timedRequestManager.FinishTimedObject(request);
}
request.obj.ExecuteResponseHandlers(response);
}
public void SendRequest([NotNull] TimedObject <NetworkRequest> request)
{
lock (timedRequestManager.timedObjects)
{
timedRequestManager.timedObjects.Add(request);
}
SendMessage(request.obj);
}
public NetworkResponseFuture SendRequestWaitable([NotNull] TimedObject <NetworkRequest> request)
{
NetworkResponseFuture future = new NetworkResponseFuture();
request.obj.AddResponseListener(future);
SendRequest(request);
return(future);
}
public NetworkResponse SendRequestBlocking([NotNull] TimedObject <NetworkRequest> request, TimeSpan?additionalTimeout)
{
if (additionalTimeout.HasValue)
{
TimeSpan timeout = request.Timeout + additionalTimeout.Value;
return(WaitOnRequest(SendRequestWaitable(request), timeout));
}
return(WaitOnRequest(SendRequestWaitable(request), request.Timeout));
}
public void OnClientResponse(ClientController controller, NetworkResponse response)
{
Debug($"Response ({response.id}): \"{response.content}\"");
TimedObject <NetworkRequest> request = controller.GetRequest(response.id);
if (request != null)
{
controller.CompleteRequest(request, response);
}
}
public static void OnNetworkRequestExpire([NotNull] TimedObject <NetworkRequest> request)
{
Write("NetworkRequest expired...");
lock (Client.timedRequestManager.timedObjects)
{
Write("Finishing remaining NetworkRequests...");
foreach (TimedObject <NetworkRequest> timedObject in Client.timedRequestManager.timedObjects)
{
timedObject.finished = true;
}
}
}
//[ArgumentInfo(0, "OBJ_ID_SOME")]
//[ArgumentInfo(1, "PART_VALUE_SOME")]
//[return: ResultInfo(0, "AGGREGATED_VALUE_SOME")]
//[return: ResultInfo(1, "OBJ_ID_SOME")]
public static object SolverAggFirst2([CanBeVector] object arg)
{
var res = SolverAggImpl(((IList)arg).Cast <IIndexedDict>(),
(key, timeRange, values) =>
{
var val = values.FirstOrDefault(d => !Utils.IsEmpty(d.ValuesList[1]));
if (val == null)
{
return(null);
}
return(new object[2] {
TimedObject.Timed(timeRange.time, timeRange.endTime, val.ValuesList[1]), key
});
}).ToArray();
return(res);
}
public static object WithTime(object x, object y, object r)
{
var tx = x as ITimedObject;
var ty = y as ITimedObject;
if (tx == null && ty == null)
{
return(r);
}
tx = tx ?? TimedObject.FullRangeI;
ty = ty ?? TimedObject.FullRangeI;
var time = (tx.Time < ty.Time) ? ty.Time : tx.Time;
var endTime = (tx.EndTime < ty.EndTime) ? tx.EndTime : ty.EndTime;
var tr = TimedObject.Timed(time, endTime, r);
return(tr);
}
public static object SolverTimedObjects(IList args)
{
var times = (IList)args[0];
var values = (IList)args[1];
var res = new ITimedObject[times.Count];
for (int i = 0; i < res.Length; i++)
{
var vi = values[i] as ITimedObject;
if (vi != null)
{
res[i] = vi;
}
else
{
var to = times[i] as ITimedObject;
res[i] = TimedObject.Timed(to.Time, to.EndTime, values[i]);
}
}
return(res);
}
/// <summary>
/// Activates an inactive object if one is available
/// </summary>
/// <param name="a_timerAmount">The amount of time before the object is deactivated</param>
/// <returns>an activated object from the pool</returns>
public GameObject ActivateObject(float a_timerAmount = 0f)
{
if (m_inactiveObjects.Count == 0)
{
return(null);
}
TimedObject objectToActivate = m_inactiveObjects[m_inactiveObjects.Count - 1];
m_inactiveObjects.RemoveAt(m_inactiveObjects.Count - 1);
objectToActivate.m_obj.SetActive(true);
m_activeObjects.Add(objectToActivate);
if (a_timerAmount > 0f)
{
objectToActivate.m_timeCreated = Time.time;
objectToActivate.m_timerAmount = a_timerAmount;
}
return(objectToActivate.m_obj);
}
// Use this for initialization
void Start()
{
if (oilSound == null)
{
oilSoundSource = new GameObject();
oilSoundSource.name = "oilSoundSource";
ss = oilSoundSource.AddComponent <AudioSource>();
oilSound = Resources.Load("Sounds/PickupOil") as AudioClip;
ss.clip = oilSound;
ss.loop = false;
ss.rolloffMode = AudioRolloffMode.Linear;
ss.volume = Util.SFXVolume;
}
ss.Play();
startTime = Time.time;
tarScale = gameObject.transform.localScale * scaleFactor;
startScale = gameObject.transform.localScale;
to = gameObject.GetComponent <TimedObject>();
srend1 = gameObject.GetComponent <SpriteRenderer>();
srend2 = gameObject.transform.GetChild(0).gameObject.GetComponent <SpriteRenderer>();
}
/// <summary>
/// Deactivates an active object if the index is valid
/// </summary>
/// <param name="a_index">The index of the object to deactivate</param>
/// <returns>True if the object passed in was deactivated, false if the object is not in the active objects list</returns>
public bool DeactivateObject(int a_index)
{
if (a_index < 0 || a_index > m_activeObjects.Count - 1)
{
return(false);
}
TimedObject objectToDeactivate = m_activeObjects[a_index];
ObjectPooler objectPooler = objectToDeactivate.m_obj.GetComponent <ObjectPooler>();
if (objectPooler != null)
{
objectPooler.DeactivateAll();
}
objectToDeactivate.m_obj.SetActive(false);
m_activeObjects.Remove(objectToDeactivate);
m_inactiveObjects.Add(objectToDeactivate);
return(true);
}
private static object ReadRows(DbDataReader rdr)
{
int nFields = rdr.FieldCount;
var key2ndx = new Dictionary <string, int>(StringComparer.OrdinalIgnoreCase);
var lstUsedFields = new List <int>(nFields);
int iStartTimeField = -1;
int iEndTimeField = -1;
for (int i = 0; i < nFields; i++)
{
var key = rdr.GetName(i);
if (string.Compare(key, nameof(START_TIME), StringComparison.InvariantCultureIgnoreCase) == 0)
{
iStartTimeField = i; continue;
}
else if (iStartTimeField >= 0 && (
string.Compare(key, "end_time__dt", StringComparison.InvariantCultureIgnoreCase) == 0 ||
string.Compare(key, nameof(END_TIME), StringComparison.InvariantCultureIgnoreCase) == 0
))
{
iEndTimeField = i; continue;
}
key2ndx.Add(key, lstUsedFields.Count);
lstUsedFields.Add(i);
}
var usedFields = lstUsedFields.ToArray();
int nUsedFields = usedFields.Length;
var lst = new OPs.ListOf <IIndexedDict>();
if (iEndTimeField >= 0)
{
var values = new object[nFields];
while (rdr.Read())
{
rdr.GetValues(values);
var endTime = values[iEndTimeField];
var vals = new object[nUsedFields];
var dtBeg = (DateTime)values[iStartTimeField];
var dtEnd = (endTime == DBNull.Value) ? DateTime.MaxValue : (DateTime)endTime;
if (dtBeg == dtEnd)
{
dtBeg = dtEnd;
}
//vals[0] = TimedObject.Timed(dtBeg, dtEnd, values[0]);
for (int i = 0; i < nUsedFields; i++)
{
vals[i] = TimedObject.Timed(dtBeg, dtEnd, values[usedFields[i]]);
}
lst.Add(new ValuesDictionary(vals, key2ndx, dtBeg, dtEnd));
}
}
else if (iStartTimeField >= 0)
{
var values = new object[nFields];
object[] prevs = null;
var prevTime = DateTime.MinValue;
while (rdr.Read())
{
rdr.GetValues(values);
var time = (DateTime)values[iStartTimeField];
if (prevs != null)
{
var dtBeg = prevTime;
var dtEnd = (Cmp.CmpKeys(prevs[0], values[0]) == 0) ? time : DateTime.MaxValue;
if (dtBeg == dtEnd)
{
continue;
}
for (int i = 0; i < nUsedFields; i++)
{
prevs[i] = TimedObject.Timed(dtBeg, dtEnd, prevs[i]);
}
lst.Add(new ValuesDictionary(prevs, key2ndx, dtBeg, dtEnd));
}
prevTime = time;
var vals = new object[nUsedFields];
for (int i = 0; i < nUsedFields; i++)
{
vals[i] = values[usedFields[i]];
}
prevs = vals;
}
if (prevs != null)
{
for (int i = 0; i < nUsedFields; i++)
{
prevs[i] = TimedObject.Timed(prevTime, DateTime.MaxValue, prevs[i]);
}
lst.Add(new ValuesDictionary(prevs, key2ndx, prevTime, DateTime.MaxValue));
}
}
else
{
System.Diagnostics.Trace.Assert(nFields == nUsedFields);
while (rdr.Read())
{
var values = new object[nFields];
rdr.GetValues(values);
for (int i = values.Length - 1; i >= 0; i--)
{
values[i] = Minimize(values[i]);
}
lst.Add(ValuesDictionary.New(values, key2ndx));
}
}
#if OCP_LOG
using (var writer = System.IO.File.AppendText("OraConnPool.log"))
{
writer.WriteLine(string.Join("\t", key2ndx.Keys));
foreach (var vals in lst)
{
writer.WriteLine(string.Join("\t", vals.ValuesList));
}
writer.Flush();
}
#endif
return(lst.ToArray());
}
public static void OnNetworkRequestFinish([NotNull] TimedObject <NetworkRequest> request)
{
Write("Finished NetworkRequest!");
}
IEnumerable <object[]> EnumerateTimed(ColumnStack[] colInfos, int iSrc, ITimedObject prevRange)
{
if (iSrc == srcInfos.Length)
#region Return result of enumeration
{ // only return one result
if (prevRange.EndTime < prevRange.Time)
{
yield break;
}
var res = new object[resColumns.Length];
bool allValNulls = true;
bool firstKey = true;
for (int i = 0; i < res.Length; i++)
{
int j = resColumns[i];
int ndx = (j < 0) ? -j - 1 : j;
var cd = colInfos[ndx].First().Value;
object ri;
if (Utils.IsEmpty(cd))
{
ri = cd;
}
else if (j >= 0) // nonnegative j for data field (output value)
{
allValNulls = false;
ri = TimedObject.TryAsTimed(cd, prevRange.Time, prevRange.EndTime);
}
else // negative j for key field (not output value)
{
var to = cd as ITimedObject;
if (to != null)
{
ri = TimedObject.ValueInRange(to, prevRange);
if (firstKey && ri == null)
{
yield break;
}
}
else
{
ri = TimedObject.Timed(prevRange.Time, prevRange.EndTime, cd); // keys
}
firstKey = false;
}
res[i] = ri;
}
if (!allValNulls)
{
if (res[0] == null)
{
yield return(res);
}
else
{
yield return(res);
}
yield break;
}
else
{
yield break;
}
}
#endregion
var si = srcInfos[iSrc];
#region Skip inactive source
if (!si.active)
{
// values of iSrc-th source don't affects results
// just process remaining sources
foreach (var res in EnumerateTimed(colInfos, iSrc + 1, prevRange))
{
yield return(res);
}
yield break;
}
#endregion
// values of iSrc-th source affects results
IEnumerable <int> rows;
int[] outNdxs = null;
int nRowsFound = 0;
var keysTimeRange = new TimedInt64(DateTime.MinValue, DateTime.MaxValue, 0);
if (iSrc == 0)
#region Rows of first source (not filtered)
{
rows = Enumerable.Range(0, si.data.Count);
outNdxs = si.outputs;
}
#endregion
else if (si.inOuts.Length > 0)
#region like SelectMany
{ // rows filtered by key field ( 'SelectMany'-like function)
outNdxs = si.pureOuts;
var inOuts = si.inOuts;
var keyVals = new object[inOuts.Length];
bool withUnknown = false, withKnown = false;
for (int i = 0; i < inOuts.Length; i++)
{
int iGlb = si.loc2glb[inOuts[i]];
var ci = colInfos[iGlb];
if (ci.Empty)
{
withUnknown = true;
continue;
}
else
{
withKnown = true;
var val = ci.Peek().Value;
keyVals[i] = val;
var to = val as ITimedObject;
if (to != null)
{
if (to.Time > keysTimeRange.time)
{
keysTimeRange.time = to.Time;
}
if (to.EndTime < keysTimeRange.endTime)
{
keysTimeRange.endTime = to.EndTime;
}
}
}
}
if (withKnown && withUnknown)
//if (withUnknown)
{
//yield break;
throw new Exception("Solver.ResultEnumerator: part of key values is undefined ("
+ string.Join(",", inOuts.Select(i => colInfos[si.loc2glb[i]]).Where(c => c.Empty).Select(c => c.name))
+ ")");
}
else if (withKnown)
{
rows = si.data.BinarySearchAllWithTimeRange(inOuts, keyVals, prevRange);
}
else
{
rows = Enumerable.Range(0, si.data.Count);
}
}
#endregion
else if (si.pureInsGlb.Length > 0)
#region like Select
{ // row is result of 'Select'-like function ( one result for one input)
var iMax = -1;
foreach (int glb in si.pureInsGlb)
{
var ci = colInfos[glb];
if (ci.Empty)
{
continue;
}
var cd = ci.Peek();
if (cd.iRow > iMax)
{
iMax = cd.iRow;
}
else if (cd.iRow < 0)
{
iMax = -1; break;
}
}
if (iMax >= 0)
{
rows = Enumerable.Range(iMax, 1);
}
else
{
rows = null;
}
outNdxs = si.pureOuts;
}
#endregion
else
{ // "Input" function = independent value(s)
rows = Enumerable.Range(0, si.data.Count);
outNdxs = si.outputs;
}
var prevEndTime = prevRange.Time;
if (rows != null)
{
//var dataRange = new TimedObject() { time = prevRange.Time, endTime = prevRange.EndTime };
foreach (var iRow in rows)
{
nRowsFound++;
var rowVals = si.data[iRow].ValuesList;
var dataTimeRange = new TimedInt64(DateTime.MinValue, DateTime.MaxValue, 0);
// determine time range
foreach (int i in si.inOuts)
{
var to = rowVals[i] as ITimedObject;
if (to == null)
{
continue;
}
if (to.Time > dataTimeRange.time)
{
dataTimeRange.time = to.Time;
}
if (to.EndTime < dataTimeRange.endTime)
{
dataTimeRange.endTime = to.EndTime;
}
}
ITimedObject nextRange;
if (dataTimeRange.time > DateTime.MinValue)
{
nextRange = TimedObject.ValueInRange(dataTimeRange, prevRange);
}
else if (keysTimeRange.time > DateTime.MinValue)
{
dataTimeRange = keysTimeRange;
nextRange = TimedObject.ValueInRange(dataTimeRange, prevRange);
}
else
{
nextRange = prevRange;
}
if (nextRange == null)
{
yield break;
}
if (DateTime.MinValue < prevEndTime && prevEndTime < nextRange.Time) // todo: nextRange == null
{ // emulate empty values of current source
foreach (int i in outNdxs)
{
colInfos[si.loc2glb[i]].Push(-1, null);
}
foreach (var res in EnumerateTimed(colInfos, iSrc + 1, new TimeRange(prevEndTime, nextRange.Time)))
{
yield return(res);
}
foreach (int i in outNdxs)
{
colInfos[si.loc2glb[i]].values.Pop();
}
}
// push found values
foreach (int i in outNdxs)
{
var rv = rowVals[i];
var col = colInfos[si.loc2glb[i]];
//col.Push(iRow, rv);
var to = rv as ITimedObject;
if (to != null)
{
col.Push(iRow, to);
}
else if (Utils.IsEmpty(rv))
{
//col.Push(iRow, TimedObject.EmptyI);
col.Push(iRow, null);
}
else if (dataTimeRange.time > DateTime.MinValue)
{
col.Push(iRow, TimedObject.Timed(dataTimeRange.time, dataTimeRange.endTime, rv));
}
else
{
col.Push(iRow, rv);
}
}
// process remained sources
foreach (var res in EnumerateTimed(colInfos, iSrc + 1, nextRange))
{
yield return(res);
}
// restore values
foreach (int i in outNdxs)
{
colInfos[si.loc2glb[i]].values.Pop();
}
prevEndTime = nextRange.EndTime;
}
}
if (prevEndTime < prevRange.EndTime) //.AddMilliseconds(-1))
{ // emulate ending empty value of current source, if needed
var lastRange = new TimeRange(prevEndTime, prevRange.EndTime); // TimedObject.Timed(prevEndTime, prevRange.EndTime, prevRange);
// push null values
foreach (int i in outNdxs)
{
colInfos[si.loc2glb[i]].Push(-1, null);
}
// process remained sources
foreach (var res in EnumerateTimed(colInfos, iSrc + 1, lastRange))
{
yield return(res);
}
// restore values
foreach (int i in outNdxs)
{
colInfos[si.loc2glb[i]].values.Pop();
}
}
}
public void Add(TimedObject timedobject)
{
tos.Add(timedobject);
}
IEnumerator SpawnCicle()
{
Cursor.visible = false;
activeWave = 0;
Queue <TimedObject> q = new Queue <TimedObject>();
int waveDelayTime;
while (activeWave < waves.Count)
{
if (activeWave == 0)
{
cooldownText.text = ("Certo se prepare que eu vou atrair eles pra esse lado !");
}
else
{
cooldownText.text = ("Se prepare que tem mais vindo !");
}
yield return(new WaitForSeconds(2f));
Debug.Log("Spawning wave: " + (activeWave + 1) + " in " + delayTime.ToString() + " seconds.");
waveDelayTime = delayTime;
q.Clear();
foreach (TimedObject t in waves[activeWave].toBeSpawned)
{
q.Enqueue(t);
}
TimedObject obj = new TimedObject();
while (waveDelayTime > 0)
{
cooldownText.text = (waveDelayTime.ToString());
yield return(new WaitForSeconds(1));
waveDelayTime--;
}
cooldownText.text = ("");
yield return(new WaitForSeconds(2));
// yield return new WaitForSeconds(delayTime);
while (q.Count > 0)
{
obj = q.Dequeue();
yield return(new WaitForSeconds(obj.time + Random.Range(-randomFactor, randomFactor)));
Vector3 t = obj.spawnPositon.position;
Quaternion r = this.transform.rotation;
while (manager.Idle)
{
yield return(new WaitForEndOfFrame());
}
aSource.pitch = Random.Range(0.9f, 1.1f);
aSource.Play();
yield return(new WaitForSecondsRealtime(0.02f));
Instantiate(obj.objectToSpawn, t, r);
}
activeWave++;
yield return(new WaitForSeconds(delayTime + 3));
}
ended = true;
}
void echo(TimedObject to)
{
Console.WriteLine($"{to.name} has passed");
}
public static async Task <object> CalcAsync(AsyncExprCtx ae, object arg, int nIns, int nOuts, AsyncFn calc, params int[] indexesOfNotNullableArgs)
{
var dict = (W.Common.IIndexedDict)arg;
try
{
var data = dict.ValuesList;
if (data.NotNullsAt(indexesOfNotNullableArgs) == false)
{
return(null);
}
var maxTime = DateTime.MinValue;
foreach (ITimedObject to in data)
{
if (to != null && !to.IsEmpty && maxTime < to.Time)
{
maxTime = to.Time;
}
}
var res = await calc(ae, data);
if (res == null)
{
return(null);
}
int n = data.Length;
if (maxTime > DateTime.MinValue)
{
var lst = res as IList;
if (lst != null)
{
for (int i = lst.Count - 1; i >= 0; i--)
{
lst[i] = TimedObject.TryAsTimed(lst[i], maxTime, DateTime.MaxValue);
}
}
else
{
res = TimedObject.TryAsTimed(res, maxTime, DateTime.MaxValue);
}
}
if (n == nIns)
{
return(res);
}
else
{
var outs = new object[nOuts + n - nIns];
var lst = res as IList;
if (lst != null)
{
lst.CopyTo(outs, 0);
}
else
{
outs[0] = res;
}
for (int i = n - 1; i >= nIns; i--)
{
outs[nOuts + i - nIns] = data[i];
}
return(outs);
}
}
catch (Exception ex)
{
Utils.ToLog(ex.Message, dict);
return(ex.Wrap());
}
}
