void Update()
{
var activeCount = mPlantActives.Count;
if (activeCount > mCurCount)
{
int count = activeCount - mCurCount;
for (int i = 0; i < count; i++)
{
var pdc = mPlantActives.RemoveLast();
mSpawnPts.Add(pdc.transform.parent);
pdc.Release();
}
}
else if (activeCount < mCurCount)
{
int count = mCurCount - activeCount;
for (int i = 0; i < count; i++)
{
int spawnToInd = Random.Range(0, mSpawnPts.Count);
var spawnToTrans = mSpawnPts[spawnToInd];
mSpawnPts.RemoveAt(spawnToInd);
var parms = new M8.GenericParams();
parms[Plant.parmSourceSun] = sourceSun;
var pdc = mPoolCtrl.Spawn(template.name, "plant", spawnToTrans, parms);
pdc.transform.localPosition = Vector3.zero;
pdc.transform.localScale = Vector3.one;
mPlantActives.Add(pdc);
}
}
}
/// <summary>
/// This will group up entities with the same data if they are neighboring each other
/// </summary>
public List <List <GridEntity> > GenerateEntityGroups()
{
var entGroups = new List <List <GridEntity> >();
var ents = new M8.CacheList <GridEntity>(entities);
while (ents.Count > 0)
{
var entList = new List <GridEntity>();
var ent = ents.RemoveLast();
if (ent.data == _doodadEntityData) //exclude doodads
{
continue;
}
entList.Add(ent);
//check neighbors
GroupAddEntities(ent, ents, entList);
entGroups.Add(entList);
}
return(entGroups);
}
public void Clear()
{
while (mDisplayActives.Count > 0)
{
var go = mDisplayActives.RemoveLast();
go.SetActive(false);
mDisplayInactives.Add(go);
}
}
private AudioSourceProxy GetAvailable()
{
if (mSourceCache == null)
{
SetupSourceRoot(null);
}
if (mSourceCache.Count > 0)
{
var src = mSourceCache.RemoveLast();
src.gameObject.SetActive(true);
return(src);
}
else
{
Debug.LogWarning("No available source.");
return(null);
}
}
void FixedUpdate()
{
//check and update surfaces
bool isNeedUpdate = false;
bool isComputeSurfaceSort = false;
for (int i = mSurfaceCache.Count - 1; i >= 0; i--)
{
var surface = mSurfaceCache[i];
//for some reason it's disabled? assume it got released
if (surface.coll == null || !surface.coll.gameObject.activeSelf)
{
mSurfaceCache.RemoveLast();
isNeedUpdate = true;
}
else if (surface.CheckAndUpdateTelemetry())
{
isNeedUpdate = true;
isComputeSurfaceSort = true;
}
}
if (isNeedUpdate)
{
ComputeSurface(isComputeSurfaceSort);
}
//check if killables have reached the surface height
for (int i = mKillableCache.Count - 1; i >= 0; i--)
{
var killable = mKillableCache[i];
if (killable.IsKillable(this))
{
mKillableCache.RemoveLast();
killable.Kill();
}
}
}
public void Init(CriteriaWidget template, int count, List <InfoData> dataList)
{
mItems = dataList;
//clear previous
if (mWidgets.Count > 0)
{
for (int i = 0; i < mWidgets.Count; i++)
{
var widget = mWidgets[i];
widget.gameObject.SetActive(false);
mWidgetCache.Add(widget);
}
mWidgets.Clear();
}
//add based on count
for (int i = 0; i < count; i++)
{
CriteriaWidget newWidget;
if (mWidgetCache.Count > 0)
{
newWidget = mWidgetCache.RemoveLast();
}
else
{
newWidget = Instantiate(template, root);
}
newWidget.gameObject.SetActive(true);
mWidgets.Add(newWidget);
}
Refresh();
}
public void Evaluate(Vector2 pos, float mass, Vector2 force, float collisionRadius, float forceDuration, float duration)
{
Clear();
float prevTime = 0f;
Vector2 curAccel = Vector2.zero;
Vector2 curVel = Vector2.zero;
Vector2 curPos = pos;
Vector2 forceGravity = Physics2D.gravity * mass;
//Vector2 dir = force.normalized;
for (float curTime = 0f; curTime <= duration; curTime += timeInterval)
{
if (mDisplayInactives.Count == 0) //no more displays
{
break;
}
var newPos = curPos + curVel * timeInterval;
var dpos = newPos - curPos;
Vector2 dir;
float dist;
if (curVel.x != 0f || curVel.y != 0f)
{
//move current pos
dist = dpos.magnitude;
dir = dpos / dist;
}
else
{
//just grab current area to see if we are in contact with anything
dist = 0f;
dir = Vector2.zero;
}
mCastHitCount = Physics2D.CircleCastNonAlloc(curPos, collisionRadius, dir, mCasts, dist, collisionLayerMask);
if (mCastHitCount > 0 && collisionEndOnContact)
{
break;
}
var netForce = forceGravity;
if (curTime <= forceDuration)
{
netForce += force;
}
Vector2 forceNormals = Vector2.zero;
if (mCastHitCount > 0f)
{
bool isEnd = false;
//newPos = curPos;
//bool newPosIsApplied = dist == 0f;
for (int i = 0; i < mCastHitCount; i++)
{
var hit = mCasts[i];
//check to see if we need to end based on tag
if (!string.IsNullOrEmpty(collisionEndTagFilter) && hit.collider.CompareTag(collisionEndTagFilter))
{
isEnd = true;
break;
}
//TODO: only do the first hit to determine displacement
//if(!newPosIsApplied) {
//newPos = curPos + dir * hit.distance;
//newPosIsApplied = true;
//}
//TODO: proper math
forceNormals += new Vector2(hit.normal.x * Mathf.Abs(netForce.x), hit.normal.y * Mathf.Abs(netForce.y));
}
if (isEnd)
{
break;
}
//dpos = newPos - curPos;
}
netForce += forceNormals;
curAccel = netForce / mass;
float deltaTime = curTime - prevTime;
if (deltaTime == 0f)
{
if (forceDuration == 0f || forceDuration < Time.fixedDeltaTime)
{
curTime = deltaTime = Time.fixedDeltaTime;
}
else if (forceDuration < timeInterval)
{
curTime = deltaTime = forceDuration;
}
}
if (curAccel != Vector2.zero)
{
curVel += curAccel * deltaTime;
}
else
{
curVel = dpos / deltaTime;
}
curPos = newPos;
//add point
if (dpos != Vector2.zero)
{
var go = mDisplayInactives.RemoveLast();
go.SetActive(true);
go.transform.position = curPos;
mDisplayActives.Add(go);
}
prevTime = curTime;
}
}
public void Plot(float x, float y)
{
Init();
if (mDots.IsFull)
{
return;
}
if (xDecimalIsRounded)
{
x = (float)System.Math.Round(x, xDecimalRound);
}
if (yDecimalIsRounded)
{
y = (float)System.Math.Round(y, yDecimalRound);
}
float xLen = Mathf.Abs(mXMax - mXMin);
float nX = xLen != 0f ? (x - mXMin) / xLen : 0f;
float yLen = Mathf.Abs(mYMax - mYMin);
float nY = yLen != 0f ? (y - mYMin) / yLen : 0f;
Transform lastDotTrans = mDots.Count > 0 ? mDots[mDots.Count - 1].t : null;
//add dot
var dotAreaSize = dotArea.rect.size;
var dotTrans = mDotsCache.RemoveLast();
// hover detail
var sb = new System.Text.StringBuilder();
if (!string.IsNullOrEmpty(dotLabelYFormat))
{
sb.AppendFormat(dotLabelYFormat, y);
}
if (!string.IsNullOrEmpty(dotLabelXFormat))
{
sb.AppendLine().AppendFormat(dotLabelXFormat, x);
}
dotTrans.ApplyText(sb.ToString());
//
dotTrans.t.localPosition = new Vector2(nX * dotAreaSize.x, nY * dotAreaSize.y);
dotTrans.t.SetAsFirstSibling();
dotTrans.t.gameObject.SetActive(true);
mDots.Add(dotTrans);
//add line
if (!mLines.IsFull && lastDotTrans)
{
Vector2 dPos = dotTrans.t.localPosition - lastDotTrans.localPosition;
float len = dPos.magnitude;
if (len > 0f)
{
var dir = dPos / len;
switch (lineMode)
{
case LineMode.Connect:
var lineAreaSize = lineArea.rect.size;
var lineRectTrans = mLinesCache.RemoveLast();
lineRectTrans.localPosition = lastDotTrans.localPosition;
lineRectTrans.up = dir;
var lineSize = lineRectTrans.sizeDelta;
lineSize.y = len;
lineRectTrans.sizeDelta = lineSize;
lineRectTrans.gameObject.SetActive(true);
mLines.Add(lineRectTrans);
break;
case LineMode.Delta:
if (dPos.y == 0f)
{
var lineRectTransX = mLinesCache.RemoveLast();
lineRectTransX.localPosition = lastDotTrans.localPosition;
lineRectTransX.up = new Vector2(1f, 0f);
var lineSizeX = lineRectTransX.sizeDelta;
lineSizeX.y = Mathf.Abs(dPos.x);
lineRectTransX.sizeDelta = lineSizeX;
lineRectTransX.gameObject.SetActive(true);
mLines.Add(lineRectTransX);
}
else if (dPos.y > 0f)
{
//x
var lineRectTransX = mLinesCache.RemoveLast();
lineRectTransX.localPosition = lastDotTrans.localPosition;
lineRectTransX.up = new Vector2(1f, 0f);
var lineSizeX = lineRectTransX.sizeDelta;
lineSizeX.y = Mathf.Abs(dPos.x);
lineRectTransX.sizeDelta = lineSizeX;
lineRectTransX.gameObject.SetActive(true);
mLines.Add(lineRectTransX);
//y
var lineRectTransY = mLinesCache.RemoveLast();
lineRectTransY.localPosition = new Vector2(dotTrans.t.localPosition.x, lastDotTrans.localPosition.y);
lineRectTransY.up = new Vector2(0f, 1f);
var lineSizeY = lineRectTransY.sizeDelta;
lineSizeY.y = Mathf.Abs(dPos.y);
lineRectTransY.sizeDelta = lineSizeY;
lineRectTransY.gameObject.SetActive(true);
mLines.Add(lineRectTransY);
}
else
{
//x
var lineRectTransX = mLinesCache.RemoveLast();
lineRectTransX.localPosition = new Vector2(lastDotTrans.localPosition.x, dotTrans.t.localPosition.y);
lineRectTransX.up = new Vector2(1f, 0f);
var lineSizeX = lineRectTransX.sizeDelta;
lineSizeX.y = Mathf.Abs(dPos.x);
lineRectTransX.sizeDelta = lineSizeX;
lineRectTransX.gameObject.SetActive(true);
mLines.Add(lineRectTransX);
//y
var lineRectTransY = mLinesCache.RemoveLast();
lineRectTransY.localPosition = lastDotTrans.localPosition;
lineRectTransY.up = new Vector2(0f, -1f);
var lineSizeY = lineRectTransY.sizeDelta;
lineSizeY.y = Mathf.Abs(dPos.y);
lineRectTransY.sizeDelta = lineSizeY;
lineRectTransY.gameObject.SetActive(true);
mLines.Add(lineRectTransY);
}
break;
}
}
}
}
IEnumerator DoGoblins()
{
var knightSpawner = (EntitySpawnerWidget)unitSpawnerWidget;
int lastKnightActiveCount = 0;
for (int i = goblinPts.Length - 1; i >= 0; i--)
{
var t = goblinPts[i];
var goblin = mGoblinPoolCtrl.Spawn <UnitEntity>(goblinTemplate.name, "", null, t.position, null);
mGoblins.Add(goblin);
yield return(new WaitForSeconds(Random.Range(0.3f, 0.6f)));
}
bool isFirst = true;
while (mGoblins.Count > 0)
{
var goblin = mGoblins.RemoveLast();
while (!goblin.body.simulated) //wait for it to be physically active
{
yield return(null);
}
//wait for knight to be spawned
while (knightSpawner.activeUnitCount == lastKnightActiveCount)
{
yield return(null);
}
lastKnightActiveCount = knightSpawner.activeUnitCount;
//wait for block to be moving to the right
while (block1.body.velocity.x <= block1VelocityXThreshold)
{
yield return(null);
}
//wait a bit
if (isFirst)
{
isFirst = false;
yield return(new WaitForSeconds(2f));
}
//move goblin
goblin.bodyMoveCtrl.moveHorizontal = -1f;
//activate goblin force display once it touches
if (!block1ForceGoblinGO.activeSelf)
{
while ((goblin.bodyMoveCtrl.collisionFlags & CollisionFlags.CollidedSides) == CollisionFlags.None)
{
yield return(null);
}
block1ForceGoblinGO.SetActive(true);
}
}
}
void M8.IModalPush.Push(M8.GenericParams parms)
{
//grab data
int datIndex = 0;
if (parms != null)
{
int minInd = 0, maxInd = 0;
if (parms.ContainsKey(parmDataIndexMin))
{
minInd = parms.GetValue <int>(parmDataIndexMin);
}
if (parms.ContainsKey(parmDataIndexMax))
{
maxInd = parms.GetValue <int>(parmDataIndexMax);
}
if (minInd == maxInd)
{
datIndex = minInd;
}
else
{
datIndex = Random.Range(minInd, maxInd + 1);
}
}
datIndex = Mathf.Clamp(datIndex, 0, data.Length - 1);
var dat = data[datIndex];
ClearSlots();
//fill up itemSlots based on the amount to fill
for (int i = 0; i < fillSlots.Length; i++)
{
SlotWidget slot;
if (mItemSlotCache.Count > 0)
{
slot = mItemSlotCache.RemoveLast();
slot.transform.SetParent(itemSlotRoot);
}
else
{
slot = Instantiate(templateItemSlot, itemSlotRoot);
}
mItemSlotActives.Add(slot);
}
mItemSlotActives.Shuffle();
//fill slot items
for (int i = 0; i < fillSlots.Length; i++)
{
var slot = mItemSlotActives[i];
var fillSlot = fillSlots[i];
var number = dat.slotNumbers[i];
SlotItemWidget item;
if (mItemCache.Count > 0)
{
item = mItemCache.RemoveLast();
}
else
{
item = Instantiate(templateItem);
}
item.Init(number, slot, fillSlot, dragAreaRoot);
mItemActives.Add(item);
}
//setup fixed numbers
for (int i = 0; i < numberTexts.Length; i++)
{
var number = dat.numbers[i];
numberTexts[i].text = number.ToString();
}
//setup bonus score display
var textFormat = M8.Localize.Get(bonusScoreTextFormatRef);
bonusScoreText.text = string.Format(textFormat, GameData.instance.bonusRoundScore);
//init bottom display
incorrectGO.SetActive(false);
timeExpireGO.SetActive(false);
bonusScoreGO.SetActive(false);
finishGO.SetActive(false);
}
private void ApplyShape()
{
if (!mShapeProfile)
{
return;
}
shapeSolid.gameObject.SetActive(mShapeUseSolid);
shapeOutline.gameObject.SetActive(!mShapeUseSolid);
var shape = mShapeUseSolid ? shapeSolid : shapeOutline;
//set the proper aspect ratio
var s = mShapeProfile.scale;
if (s.x > s.y)
{
var hRatio = s.y / s.x;
var rTrans = shape.transform as RectTransform;
var size = rTrans.sizeDelta;
size.x = shapeSizeMax;
size.y = shapeSizeMax * hRatio;
rTrans.sizeDelta = size;
}
else
{
var vRatio = s.x / s.y;
var rTrans = shape.transform as RectTransform;
var size = rTrans.sizeDelta;
size.x = shapeSizeMax * vRatio;
size.y = shapeSizeMax;
rTrans.sizeDelta = size;
}
//copy points
var settings = shape.settings;
settings.polyVertices = mShapeProfile.shape.settings.polyVertices;
if (mMeasureDisplayFlags != MeasureDisplayFlag.None)
{
var vtxPts = shape.GetPolygonWorldVertices();
//show angle displays
if ((mMeasureDisplayFlags & MeasureDisplayFlag.Angle) != MeasureDisplayFlag.None)
{
var angles = mShapeProfile.angles;
var dirs = mShapeProfile.sideDirs;
for (int i = 0; i < angles.Length; i++)
{
Vector2 pt0 = i > 0 ? vtxPts[i - 1] : vtxPts[vtxPts.Length - 1];
Vector2 pt1 = vtxPts[i];
Vector2 pt2 = i < vtxPts.Length - 1 ? vtxPts[i + 1] : vtxPts[0];
Vector2 dir0 = (pt0 - pt1).normalized;
Vector2 dir1 = dirs[i];
//angle
if (mAngleWidgetCache.Count > 0)
{
var angleWidget = mAngleWidgetCache.RemoveLast();
angleWidget.transform.SetParent(shapeMeasureRoot, false);
mAngleWidgetActives.Add(angleWidget);
angleWidget.transform.position = vtxPts[i];
angleWidget.transform.up = dir1;
var a = angleWidget.transform.eulerAngles; //prevent gimbal lock
a.x = a.y = 0f;
angleWidget.transform.eulerAngles = a;
angleWidget.fillAmount = angles[i] / 360f;
}
//text
if (mTextCache.Count > 0)
{
var textWidget = mTextCache.RemoveLast();
textWidget.transform.SetParent(shapeMeasureDetailRoot, false);
mTextActives.Add(textWidget);
textWidget.text = Mathf.RoundToInt(angles[i]).ToString() + '°';
textWidget.transform.position = pt1 + Vector2.Lerp(dir0, dir1, 0.5f).normalized *angleTextOfs;
}
}
}
//show length displays
if ((mMeasureDisplayFlags & MeasureDisplayFlag.Length) != MeasureDisplayFlag.None)
{
var lens = mShapeProfile.sideLengths;
var dirs = mShapeProfile.sideDirs;
for (int i = 0; i < lens.Length; i++)
{
Vector2 pt1 = vtxPts[i];
Vector2 pt2 = i < vtxPts.Length - 1 ? vtxPts[i + 1] : vtxPts[0];
var dir = dirs[i];
var up = new Vector2(dir.y, -dir.x);
var midPt = Vector2.Lerp(pt1, pt2, 0.5f);
//length
if (mLengthWidgetCache.Count > 0)
{
var lenRect = mLengthWidgetCache.RemoveLast();
lenRect.SetParent(shapeMeasureRoot, false);
mLengthWidgetActives.Add(lenRect);
lenRect.up = up;
var a = lenRect.eulerAngles; //prevent gimbal lock
a.x = a.y = 0f;
lenRect.eulerAngles = a;
lenRect.position = midPt + up * measureLengthDisplayOfs;
var size = lenRect.sizeDelta;
size.x = (pt2 - pt1).magnitude;
lenRect.sizeDelta = size;
}
if (mTextCache.Count > 0)
{
var textWidget = mTextCache.RemoveLast();
textWidget.transform.SetParent(shapeMeasureDetailRoot, false);
mTextActives.Add(textWidget);
textWidget.text = Mathf.RoundToInt(lens[i]).ToString() + GameData.instance.measureLengthType;
textWidget.transform.position = midPt + up * lengthTextOfs;
}
}
}
}
}
void M8.IModalPush.Push(M8.GenericParams parms)
{
mShapeUseSolid = false;
mMeasureDisplayFlags = MeasureDisplayFlag.None;
mShapeProfile = null;
mIsDragInstruct = false;
bool showHierarchy = false;
mShapeCategories.Clear();
mShapeAttributes.Clear();
//clear placements
ClearCategoryPicks();
ClearMeasureDisplays();
ClearCategoryPlaced();
ShapeCategoryData[] shapes = null;
if (parms != null)
{
if (parms.ContainsKey(parmUseSolid))
{
mShapeUseSolid = parms.GetValue <bool>(parmUseSolid);
}
if (parms.ContainsKey(parmMeasureDisplayFlags))
{
mMeasureDisplayFlags = parms.GetValue <MeasureDisplayFlag>(parmMeasureDisplayFlags);
}
if (!mIsDragInstructApplied) //only show drag instruction once
{
if (parms.ContainsKey(parmIsDragInstruct))
{
mIsDragInstruct = parms.GetValue <bool>(parmIsDragInstruct);
}
}
if (parms.ContainsKey(parmShapeProfile))
{
mShapeProfile = parms.GetValue <ShapeProfile>(parmShapeProfile);
}
if (parms.ContainsKey(parmShapes))
{
shapes = parms.GetValue <ShapeCategoryData[]>(parmShapes);
}
if (parms.ContainsKey(parmShowHierarchy))
{
showHierarchy = parms.GetValue <bool>(parmShowHierarchy);
}
}
//determine which categories fit the shape profile
if (mShapeProfile != null && shapes != null)
{
for (int i = 0; i < shapes.Length; i++)
{
if (shapes[i].Evaluate(mShapeProfile))
{
mShapeCategories.Add(shapes[i]);
}
}
}
//generate categories
if (shapes != null)
{
for (int i = 0; i < shapes.Length; i++)
{
var category = shapes[i];
//add category to pick area
if (mShapeCategoryWidgetCache.Count > 0)
{
var widget = mShapeCategoryWidgetCache.RemoveLast();
widget.Setup(category);
widget.isDragEnabled = true;
widget.transform.SetParent(categoryPickContainer, false);
mShapeCategoryWidgetActivePicks.Add(widget);
//pick a target for drag instruct
if (mIsDragInstruct && !mDragInstructTarget)
{
if (mShapeCategories.Exists(category))
{
mDragInstructTarget = widget;
}
}
}
}
}
//fill up attributes
for (int i = 0; i < mShapeCategories.Count; i++)
{
var category = mShapeCategories[i];
for (int j = 0; j < category.attributes.Length; j++)
{
var attr = category.attributes[j];
if (!mShapeAttributes.Exists(attr))
{
mShapeAttributes.Add(attr);
}
}
}
//generate description
mDescStrBuff.Clear();
for (int i = 0; i < mShapeAttributes.Count; i++)
{
var attr = mShapeAttributes[i];
mDescStrBuff.Append("· ");
mDescStrBuff.Append(M8.Localize.Get(attr.textRef));
if (i < mShapeAttributes.Count - 1)
{
mDescStrBuff.Append('\n');
}
}
descText.text = mDescStrBuff.ToString();
DefaultActiveDisplay();
ApplyShape();
categoryPickBase.gameObject.SetActive(true);
categoryPickBase.PlayEnter();
hierarchyGO.SetActive(showHierarchy);
mCurMode = Mode.PickCategories;
M8.SoundPlaylist.instance.Play(sfxEnter, false);
}
void Update()
{
if (mCurTime >= delay)
{
mCurTime = 0f;
int count = PopulateCollisions(mColls);
//remove some actives
for (int i = mActives.Count - 1; i >= 0; i--)
{
var active = mActives[i];
//no longer valid?
if (active.collider == null || !ArrayUtil.Contains(mColls, 0, count, active.collider))
{
if (active.activator)
{
active.activator.Deactivate();
}
mActives.RemoveLast();
}
}
//add new actives
int activeCount = mActives.Count;
for (int i = 0; i < count; i++)
{
var coll = mColls[i];
//ignore if tag not match
if (tagFilters.Length > 0)
{
bool isTagMatch = false;
for (int t = 0; t < tagFilters.Length; t++)
{
if (coll.CompareTag(tagFilters[t]))
{
isTagMatch = true;
break;
}
}
if (!isTagMatch)
{
continue;
}
}
//check if it already exists
int activeInd = -1;
for (int j = 0; j < activeCount; j++)
{
var active = mActives[j];
if (active.collider == coll)
{
activeInd = j;
break;
}
}
//add
if (activeInd == -1)
{
var activator = coll.GetComponent <GOActivator>();
if (activator)
{
activator.Activate();
mActives.Add(new ActiveData {
collider = coll, activator = activator
});
}
}
}
}
else
{
mCurTime += Time.deltaTime;
}
}
void RefreshLogs()
{
//refresh activate logs, add new log, remove leftover logs
var consoleLogs = console.logs;
int addInd = 0;
for (int consoleInd = 0; consoleInd < consoleLogs.Count; consoleInd++)
{
var consoleLog = consoleLogs[consoleInd];
bool canAdd;
switch (consoleLog.type)
{
case LogType.Assert:
case LogType.Error:
case LogType.Exception:
canAdd = _showLogError;
break;
case LogType.Log:
canAdd = _showLogInfo;
break;
case LogType.Warning:
canAdd = _showLogWarning;
break;
default:
canAdd = false;
break;
}
if (canAdd)
{
if (addInd == mLogWidgets.Count)
{
ConsoleDisplayUnityUILogWidget itm;
//add new log
if (mLogCacheWidgets.Count > 0) //add from cache
{
itm = mLogCacheWidgets.RemoveLast();
}
else //create new log
{
itm = Instantiate(template, logRoot);
}
itm.gameObject.SetActive(true);
itm.transform.SetAsLastSibling();
mLogWidgets.Add(itm);
}
ApplyLog(mLogWidgets[addInd], consoleLog);
addInd++;
}
}
int deltaCount = mLogWidgets.Count - addInd;
//remove excess
if (deltaCount > 0)
{
for (int i = 0; i < deltaCount; i++)
{
var itm = mLogWidgets.RemoveLast();
itm.gameObject.SetActive(false);
mLogCacheWidgets.Add(itm);
}
}
//preserve scroll position
}
/// <summary>
/// downSelect is optional for navigation
/// </summary>
public void Init(List <InfoData> data, Selectable downSelect)
{
//clear out actives
for (int i = 0; i < mItemActives.Count; i++)
{
var item = mItemActives[i];
if (item)
{
item.gameObject.SetActive(false);
mItemCache.Add(item);
}
}
mItemActives.Clear();
//
//add items
InfoDataWidget prevItem = null;
for (int i = 0; i < data.Count; i++)
{
InfoDataWidget newItem = null;
if (mItemCache.Count > 0)
{
newItem = mItemCache.RemoveLast();
if (newItem)
{
newItem.gameObject.SetActive(true);
}
}
else if (!mItemActives.IsFull)
{
newItem = Instantiate(template);
newItem.transform.SetParent(template.transform.parent, false);
newItem.gameObject.SetActive(true);
}
if (!newItem)
{
continue;
}
newItem.Init(data[i]);
if (navigationAuto)
{
var nav = newItem.navigation;
nav.mode = Navigation.Mode.Automatic;
newItem.navigation = nav;
}
else
{
if (prevItem)
{
var prevNav = prevItem.navigation;
prevNav.mode = Navigation.Mode.Explicit;
prevNav.selectOnRight = newItem;
prevItem.navigation = prevNav;
}
var nav = newItem.navigation;
nav.mode = Navigation.Mode.Explicit;
nav.selectOnLeft = prevItem;
nav.selectOnDown = downSelect;
newItem.navigation = nav;
}
mItemActives.Add(newItem);
}
}
