/// <summary>
/// Remove given blob from this group if it matches, returns true if able to match and clean-up.
/// </summary>
public bool RemoveBlob(Blob blob)
{
if (blobOpLeft == blob || blobOpRight == blob)
{
Clear();
return(true);
}
else if (blobEq == blob)
{
if (connectEq)
{
if (!connectEq.isReleasing)
{
connectEq.state = BlobConnect.State.Releasing;
}
connectEq = null;
}
blobEq = null;
return(true);
}
return(false);
}
public void SetOp(Blob left, Blob right, BlobConnect connect)
{
Clear(); //fail-safe
blobOpLeft = left;
blobOpRight = right;
connectOp = connect;
}
public void ReleaseDragging()
{
if (mCurConnectDragging)
{
mCurConnectDragging.Release();
mCurConnectDragging = null;
}
curBlobDragging = null;
curGroupDragging = null;
}
public void SetEq(Blob eq, BlobConnect connect)
{
if (connectEq && !connectEq.isReleasing)
{
connectEq.state = BlobConnect.State.Releasing;
}
blobEq = eq;
connectEq = connect;
}
public void ClearEq()
{
if (connectEq)
{
if (!connectEq.isReleasing)
{
connectEq.state = BlobConnect.State.Releasing;
}
connectEq = null;
}
blobEq = null;
}
public void Clear()
{
if (connectOp)
{
if (!connectOp.isReleasing)
{
connectOp.state = BlobConnect.State.Releasing;
}
connectOp = null;
}
blobOpLeft = null;
blobOpRight = null;
ClearEq();
}
void OnBlobConnectDelete(BlobConnect blobConnect)
{
//check which connects need to be purged.
for (int i = mGroupActives.Count - 1; i >= 0; i--)
{
var grp = mGroupActives[i];
if (grp.connectOp == blobConnect)
{
grp.Clear();
}
else if (grp.connectEq == blobConnect)
{
grp.ClearEq();
}
if (grp.isEmpty)
{
mGroupActives.RemoveAt(i);
mGroupCache.Add(grp);
}
}
}
void OnBlobDragBegin(Blob blob)
{
if (!mCurConnectDragging)
{
mConnectSpawnParms.Clear();
//params?
mCurConnectDragging = mPool.Spawn <BlobConnect>(connectTemplate.name, "", null, mConnectSpawnParms);
}
curBlobDragging = blob;
var toOp = mCurOp;
//determine what the operator is based on blob's current connect state
mCurConnectDragging.op = toOp;
mCurConnectDragging.state = BlobConnect.State.Connecting;
if (mCurConnectDragging.connectingSpriteRender)
{
mCurConnectDragging.connectingSpriteRender.color = curBlobDragging.color;
}
//determine if this is in a group
curGroupDragging = GetGroup(blob);
if (curGroupDragging != null)
{
//highlight entire group
//flip operand order based if it's the first operand
if (blob == curGroupDragging.blobOpLeft)
{
curGroupDragging.blobOpLeft = curGroupDragging.blobOpRight;
curGroupDragging.blobOpRight = blob;
}
}
}
void OnGroupEval(BlobConnectController.Group grp)
{
//check if correct
float op1, op2, eq;
grp.GetNumbers(out op1, out op2, out eq);
bool isCorrect = false;
switch (grp.connectOp.op)
{
case OperatorType.Multiply:
isCorrect = op1 * op2 == eq;
break;
case OperatorType.Divide:
isCorrect = op1 / op2 == eq;
break;
}
Blob blobLeft = grp.blobOpLeft, blobRight = grp.blobOpRight, blobEq = grp.blobEq;
BlobConnect connectOp = grp.connectOp, connectEq = grp.connectEq;
if (isCorrect)
{
//do sparkly thing for blobs
blobLeft.state = Blob.State.Correct;
blobRight.state = Blob.State.Correct;
blobEq.state = Blob.State.Correct;
//clean out op
connectOp.state = BlobConnect.State.Correct;
connectEq.state = BlobConnect.State.Correct;
if (mDragIndicatorRout != null)
{
HideDrag();
}
}
else
{
//do error thing for blobs
blobLeft.state = Blob.State.Error;
blobRight.state = Blob.State.Error;
blobEq.state = Blob.State.Error;
//clean out op
connectOp.state = BlobConnect.State.Error;
connectEq.state = BlobConnect.State.Error;
//restart drag show
if (mDragIndicatorRout != null)
{
OnSignalDragShow();
}
}
connectControl.ClearGroup(grp);
if (isCorrect && signalInvokeCorrect)
{
signalInvokeCorrect.Invoke();
}
}
void OnBlobDragEnd(Blob blob)
{
SetCurGroupDraggingOtherBlobHighlight(false);
//determine if we can connect to a new blob
var blobRefPt = blob.dragPointerJellySpriteRefPt;
if (blobRefPt != null && blobRefPt.ParentJellySprite != blob.gameObject)
{
Group evalGroup = null;
var endBlob = blobRefPt.ParentJellySprite.GetComponent <Blob>();
//determine op
var toOp = mCurOp;
if (curGroupDragging != null)
{
if (curGroupDragging.IsBlobOp(curBlobDragging))
{
//cancel if dragging to the same group as ops
if (curGroupDragging.IsBlobOp(endBlob))
{
toOp = OperatorType.None;
}
else
{
toOp = OperatorType.Equal;
}
}
}
//update link groups
if (toOp != OperatorType.None)
{
//remove endBlob from its group
var endGroup = GetGroup(endBlob);
if (endGroup != null && endGroup != curGroupDragging)
{
//if we are dragging to apply equal op, then remove it from end group and move to drag group
if (toOp == OperatorType.Equal)
{
RemoveBlobFromGroup(endGroup, endBlob);
curGroupDragging.SetEq(endBlob, mCurConnectDragging);
evalGroup = curGroupDragging;
}
else
{
//if dragging to one of the operands of end group, then move blob to this group
if (endGroup.IsBlobOp(endBlob))
{
toOp = OperatorType.Equal;
//move blob to end group as the equal
endGroup.SetEq(blob, mCurConnectDragging);
evalGroup = endGroup;
//remove from dragging group
if (curGroupDragging != null)
{
RemoveBlobFromGroup(curGroupDragging, blob);
}
}
else
{
//remove blobs from its group, and create new group together
if (curGroupDragging != null)
{
RemoveBlobFromGroup(curGroupDragging, blob);
}
RemoveBlobFromGroup(endGroup, endBlob);
var newGrp = NewGroup();
newGrp.SetOp(blob, endBlob, mCurConnectDragging);
groupAddedCallback?.Invoke(newGrp);
}
}
}
else if (curGroupDragging != null)
{
if (toOp == OperatorType.Equal)
{
//refresh equal
curGroupDragging.SetEq(endBlob, mCurConnectDragging);
evalGroup = curGroupDragging;
}
else //re-establish group
{
curGroupDragging.SetOp(blob, endBlob, mCurConnectDragging);
}
}
else
{
//create new group
var newGrp = NewGroup();
newGrp.SetOp(blob, endBlob, mCurConnectDragging);
groupAddedCallback?.Invoke(newGrp);
}
//setup link
mCurConnectDragging.op = toOp;
mCurConnectDragging.ApplyLink(blob, endBlob);
}
else //cancel
{
mCurConnectDragging.Release();
}
mCurConnectDragging = null;
curBlobDragging = null;
curGroupDragging = null;
//send call to evaluate a group
if (evalGroup != null && evalGroup.isComplete)
{
evaluateCallback?.Invoke(evalGroup);
}
}
else
{
ReleaseDragging();
}
}
void OnGroupEval(BlobConnectController.Group grp)
{
float op1, op2, eq;
grp.GetNumbers(out op1, out op2, out eq);
var op = grp.connectOp.op;
bool isCorrect = false;
switch (op)
{
case OperatorType.Multiply:
isCorrect = op1 * op2 == eq;
break;
case OperatorType.Divide:
isCorrect = op1 / op2 == eq;
break;
}
Blob blobLeft = grp.blobOpLeft, blobRight = grp.blobOpRight, blobEq = grp.blobEq;
BlobConnect connectOp = grp.connectOp, connectEq = grp.connectEq;
if (isCorrect)
{
//do sparkly thing for blobs
blobLeft.state = Blob.State.Correct;
blobRight.state = Blob.State.Correct;
blobEq.state = Blob.State.Correct;
blobSpawner.RemoveFromActive(blobLeft);
blobSpawner.RemoveFromActive(blobRight);
blobSpawner.RemoveFromActive(blobEq);
//clean out op
connectOp.state = BlobConnect.State.Correct;
connectEq.state = BlobConnect.State.Correct;
//increment and refresh combo
if (mComboRout == null)
{
mComboRout = StartCoroutine(DoComboUpdate());
}
comboCurTime = 0f;
comboCount++;
//add score
if (isHintShown)
{
curScore += GameData.instance.correctDecayPoints;
}
else
{
curScore += GameData.instance.correctPoints * comboCount;
}
//go to next round
mIsAnswerCorrectWait = false;
}
else
{
//do error thing for blobs
blobLeft.state = Blob.State.Error;
blobRight.state = Blob.State.Error;
blobEq.state = Blob.State.Error;
//clean out op
connectOp.state = BlobConnect.State.Error;
connectEq.state = BlobConnect.State.Error;
//decrement combo count
if (mComboRout != null)
{
if (comboCount > 0)
{
comboCount--;
}
if (comboCount == 0)
{
StopCoroutine(mComboRout);
mComboRout = null;
}
comboCurTime = 0f;
}
mistakeCount++;
mMistakeRoundCount++;
}
connectControl.ClearGroup(grp);
groupEvalCallback?.Invoke(new Operation {
operand1 = (int)op1, operand2 = (int)op2, op = op
}, (int)eq, isCorrect);
}
