What is the correct way to c#- wait for the moveto operation to complete?
•
Android
I used cocossharp to create an application that is essentially obsessed with candy. This is the first time I really use it, the same as c# and xamarin. In order to execute the animation, I used the moveto method provided, but I'm not sure how to wait for the animation to complete before continuing to execute the code. At present, I'm using await task. Delay() combined with the while loop to complete this operation, But this "feeling" doesn't look "dirty". I wonder what's the right way to wait for the animation to complete?
Here are some code I wrote:
// Checks to see if a swap is possible, if it is then it will do so
// otherwise it will call for a Failed swap animation
public async void trySwap(int horzDelta, int vertDelta, int fromRow, int fromCol)
{
//debugLabel.Text = "checking to see if a swap is possible.";
int toRow = fromRow + vertDelta;
int toCol = fromCol + horzDelta;
// Make sure that the user didn't swipe out of the grid as there isn't any candies to swap with out there
if (toRow < 0 || toRow >= gridRows)
{
return;
}
if (toCol < 0 || toCol >= gridColumns)
{
return;
}
candy toCandy = candyAt(toRow, toCol);
candy fromCandy = candyAt(fromRow, fromCol);
//debugLabel.Text = "Switching candy at [" + fromRow + ", " + fromCol + "] with candy at [" + toRow + ", " + toCol + "].";
Swap swap = new Swap();
swap.candyA = fromCandy;
swap.candyB = toCandy;
if (isSwapPossible(swap))
{
// Swap them
animateSwap(swap);
await Task.Delay(300); // Wait for the swap animation to finish before continuing
dropped = false; // Sets dropped to false, it will be used to check if the game finished dropping all of the candies
filledAgain = false;
finishedRemoving = false;
do
{
// My reason to add the while loops with the awaits is that the App seems to come back to this do while even before the
// the method completely finish running. I'm guessing that awaits in the methods is forcing the App to continue running while it's awaiting
// to continue within the method. It's possible that the called methods are running on a separate threads from the thread that is running this
// method, so while those threads are put on hold, the App jumps back to this thread. After putting in while loops the app does seems to work like
// I want it to so I'm probably on the right track, thought there must be a better way to accomplish as the current way looks ugly.
removeMatches(); // Remove the matches
while (!finishedRemoving)
{
await Task.Delay(50);
}
dropCandies(); // Move the candies down
while (!dropped) // As long as the dropCandies method isn't finished it will keep adding an await
{
await Task.Delay(50);
}
fillUpColumns(); // Fill the grid back up
while (!filledAgain)
{
await Task.Delay(50);
}
detectPossibleSwap(); // Need to update the list of possible swaps
await Task.Delay(300);
}
while (deleteChains.Count != 0);
decrementMoves();
// In the case that grid ends up with no possible swaps, we need to refill the grid new candies
if (possibleSwaps.Count == 0 && movesLeft != 0)
{
reshuffle();
while (!doneShuffling)
{
await Task.Delay(50);
}
}
}
else
{
// FailedSwapAnimation only needs to run if there's valid candies
if (swap.candyA != null && swap.candyB != null)
{
// Swap is not possible so run the Failed swap animation
FailedSwapAnimation(swap);
// Waiting to make sure the animation has been completed
await Task.Delay(300);
}
else
{
// The method enables the user interaction again and returns the call point without any type of animation
// as the user tried to do a swap with an empty location
enableListeners();
return;
}
}
// Turn user interaction back on as all of the matches were removed and the grid filled back up
if (movesLeft != 0)
{
enableListeners();
}
}
This is the method that actually calls the moveto method:
// Visually animates the swap using the CCMoveTo function provided by CocosSharp,
// also updates the grid location of the candies
private void animateSwap(Swap swap)
{
const float timeToTake = 0.3f; // in seconds
CCFiniteTimeAction coreAction = null;
// Store the positions of the candies to be used to swap them
CCPoint positionA = new CCPoint(swap.candyA.Position);
CCPoint positionB = new CCPoint(swap.candyB.Position);
// Animate the swapping of the candies
coreAction = new CCMoveTo(timeToTake, positionB);
swap.candyA.AddAction(coreAction);
coreAction = new CCMoveTo(timeToTake, positionA);
swap.candyB.AddAction(coreAction);
// Update the row and column positions for each candy
swap.candyA.setPosition(convertYToRow(positionB.Y), convertXToColumn(positionB.X));
swap.candyB.setPosition(convertYToRow(positionA.Y), convertXToColumn(positionA.X));
// Update the position of the candies within the grid
grid[swap.candyA.getRow(), swap.candyA.getColumn()] = swap.candyA;
grid[swap.candyB.getRow(), swap.candyB.getColumn()] = swap.candyB;
}
// Animation for a Failed swap
private async void FailedSwapAnimation(Swap swap)
{
const float timeToTake = 0.1f; // in seconds
CCFiniteTimeAction coreAction = null;
CCFiniteTimeAction secondAction = null;
// Store the positions of the candies to be used to swap them
CCPoint positionA = new CCPoint(swap.candyA.Position);
CCPoint positionB = new CCPoint(swap.candyB.Position);
// Animate moving the candies back and forth
coreAction = new CCMoveTo(timeToTake, positionB);
secondAction = new CCMoveTo(timeToTake, positionA);
swap.candyA.RunActions(coreAction, secondAction);
coreAction = new CCMoveTo(timeToTake, positionA);
secondAction = new CCMoveTo(timeToTake, positionB);
swap.candyB.RunActions(coreAction, secondAction);
// Wait for the animation to complete before moving on
await Task.Delay(300);
}
// Method to find all chains in the grid
private void removeMatches()
{
List<Chain> horizontalChains = detectHorizontalMatches();
List<Chain> verticalChains = detectVerticalMatches();
// Logic to remove the candies from the grid goes here, possibly call a method that takes the list of chains to work with
// Don't forget that candies have to be removed from the grid and then afterwards the sprites need to be removed from the screen separately
// which can be handle by another method
foreach (Chain item in verticalChains)
{
horizontalChains.Add(item);
}
deleteChains = horizontalChains;
removeCandies(horizontalChains);
}
// Remove the candy objects from the screen and the grid
private async void removeCandies(List<Chain> chains)
{
if (finishedRemoving != false)
{
finishedRemoving = false;
}
foreach (Chain chain in chains)
{
foreach (candy candy in chain.candies)
{
// Remove the candy from the grid
grid[candy.getRow(), candy.getColumn()] = null;
CCSprite removeCandy = candy.getSprite();
if (removeCandy != null)
{
const float timeToTake = 0.3f; // in seconds
CCFiniteTimeAction coreAction = null;
CCAction easing = null;
coreAction = new CCScaleTo(timeToTake, 0.3f);
easing = new CCEaSEOut(coreAction, 0.1f);
removeCandy.RunAction(coreAction);
await Task.Delay(50); // Wait for the scaling animation to show a bit before continuing on to remove the candy
//pointGone = false;
//pointLabel(candy.getRow(), candy.getColumn());
//while (!pointGone)
//{
// await Task.Delay(1);
//}
removeCandy.RemoveFromParent(); // This should remove the candy from the screen
handlePoints();
}
}
// Wait for all of the candies to be removed before moving on to the next chain in the list of chains
await Task.Delay(300);
}
// Since the method is finished removing all of chains, needed to set the finishedRemoving bool variable to true
// so the calling method can get out of it's await loop
finishedRemoving = true;
}
// Drops the candies down
private async void dropCandies()
{
// Makes sure that dropped bool variable is set false before continuing
if (dropped != false)
{
dropped = false;
}
for (int col = 0; col < gridColumns; coL++)
{
for (int row = 8; row > 0; row--)
{
if (level.tiles[row, col] == 1)
{
candy Candy = candyAt(row, col);
if (Candy == null)
{
// Find which row number to drop the candy from
int tempRow = row - 1;
while (tempRow >= 0 && grid[tempRow, col] == null)
{
tempRow--;
}
// Only runs if there's a row that has a candy in it
if (tempRow >= 0)
{
CCPoint position = new CCPoint(70 + (62 * col), 810 - (70 * row));
Candy = candyAt(tempRow, col);
Candy.AddAction(new CCEaSEOut(new CCMoveTo(0.3f, position), 0.3f));
Candy.setPosition(row, col); // Update the row and column of the candy
grid[row, col] = Candy; // Update the position of the candy within the grid
grid[tempRow, col] = null;
// Wait for the candy to drop before moving to on the next candy
await Task.Delay(50);
}
}
}
}
}
// Since the method should have gone through the entire grid and finished dropping the candies
// need to set dropped to true so the calling method can get out of the await loop
dropped = true;
}
// Fill the holes at the top of the of each column
private void fillUpColumns()
{
int candyType = 0;
if (filledAgain != false)
{
filledAgain = false;
}
for (int col = 0; col < gridColumns; coL++)
{
// Starting at the top and working downwards, add a new candy where it's needed
for (int row = 0; row < gridRows && grid[row, col] == null; row++)
{
if (level.tiles[row, col] == 1)
{
int newCandyType = 0;
// Have to first create a new candy outside of the while loop or otherwise the IDE won't let me use the variable newCandy
// as it will be seen as using an unassigned variable, even though it will be assigned a new candy in the while loop
candy newCandy = new candy(rand, row, col);
newCandyType = newCandy.getType();
// Make sure that each candy that is being added isn't the same as the one that was added prevIoUsly
while (newCandyType == candyType)
{
newCandy = new candy(rand, row, col);
newCandyType = newCandy.getType();
}
candyType = newCandyType;
grid[row, col] = newCandy;
// Once all of the candy is created to fill the grid back up
// Use an animation to add it to the screen
animateAddingNewCandies(row, col);
}
}
}
// Since the entire grid was filled back up with candies, need to set the filledAgain bool variable to true
// so the calling method can get out the await loop
filledAgain = true;
}
For those who want to see the full code to better understand the problem, I can post a GitHub link here. I don't include it now because I'm not sure if I'm really allowed to do so. I'm sorry for some comments, because some of them are just the ideas I wrote down at that time
resolvent:
I'll use the sequences of ccmoveto and cccallfunc
var moveAction = new CCMoveTo(1.0f, someplace);
var moveCompletedAction = new CCCallFunc(this.FunctionToCallWhenMoveIsComplete);
CCSequence mySequence = new CCSequence(moveAction, moveCompletedAction);
mysprite.RunAction(mySequence);
....
void FunctionToCallWhenMoveIsComplete ()
{
// run your post move code here
}
The content of this article comes from the network collection of netizens. It is used as a learning reference. The copyright belongs to the original author.
THE END
二维码