Exploring transitions
This presentation is the property of its rightful owner.
Sponsored Links
1 / 11

Exploring Transitions PowerPoint PPT Presentation


  • 50 Views
  • Uploaded on
  • Presentation posted in: General

Exploring Transitions. Chapter 10. Processing Auxiliary Objects. function ProcessObject ( newState : int ) { processing = true; // turn on flag to block picks // tell the GameManager to suppress the cursor controlCenter.GetComponent ( GameManager ). suppressPointer = true;

Download Presentation

Exploring Transitions

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Exploring transitions

Exploring Transitions

Chapter 10


Processing auxiliary objects

Processing Auxiliary Objects

function ProcessObject (newState : int) {

processing = true; // turn on flag to block picks

// tell the GameManager to suppress the cursor

controlCenter.GetComponent(GameManager).suppressPointer = true;

// start timer

pickTimerTime = Time.time + 0.5; // set the timer to go for 0.5 seconds

pickTimer = true; // turn on the flag to check the timer

currentState = newState; // update the object's current state

// update more of the data with the new state

currentObjectName = objectName[currentState];

currentObjectDescription = description[currentState];

currentLocation = location[currentState];

currentVisibility = visibility[currentState];

// assign the current clip and delay and audio for the new state

if (animates) currentAnimationClip = animationClip[currentState];

if (animates) currentAnimationDelay = animationDelay[currentState];

// if there is a clip, add its length and delay together

if(currentAnimationClip) aniLength = currentAnimationClip.length + currentAnimationDelay;

else aniLength = 0.0; // there is no animation for this state

currentSound = soundClip[currentState];

currentAudioDelay = audioDelay[currentState];

// send it off for handling in case it has a visibility state that is processed at the start

HandleVisibility();

// block player input while action plays out

if (aniLength != 0.0) {gameObject.Find("First Person Controller").

SendMessage("ManageInput",aniLength);

}

if(animates && animationClip[currentState] != null) {

// find out if a alternate animation object was assigned, if not, assign the object itself

if (aniObject == null) aniObject = gameObject;

//pause before playing the animation

yield new WaitForSeconds(currentAnimationDelay);

// play the animation

aniObject.animation.Play(currentAnimationClip.name);

ProcessAudio (currentSound); // send audio clip off for processing

// wait the length of primary animation clip

yield new WaitForSeconds(currentAnimationClip.length);

// check for a looping animation to follow the primary animation

if(postLoop) { // if postLoop is checked/ true, there is a looping animation to trigger

aniObject.animation.Play(loopAnimation[currentState].name);

// play the looping animation

ProcessAudio (loopSoundFX[currentState]); // send loop audio clip off for processing

}

processing = false; // turn off flag to block picks

}

else {

ProcessAudio (currentSound); // send loop audio clip off for processing

//print (currentSound );

yield new WaitForSeconds(1.0);// give a short pause if there was no animation

processing = false; // turn off flag to block picks

}

}


Handling object visibility

Handling Object Visibility

  • If you turn off the renderer then you should turn off the collider also

  • There are multiple types of renderers that must be dealt with individually

  • All components of a hierarchical structure must be dealt with individually

  • You could deactivate the whole object but then it cannot be “found”.

  • Techniques used is to create an array of gameobjects in the scene


Using tags

Using Tags

  • One or more gameObjects can be labeled with a tag

    function Awake () {

    Screen.SetResolution (1280, 800, false);

    //get a list of the gameObjects with the ActionObject tag

    varaObjects = GameObject.FindGameObjectsWithTag("ActionObject");

    // redefine the ActionObject array with the number of elements in the list

    actionObjects = new GameObject[aObjects.length];

    //save the action objects into the array for easy access when deactivated

    for (vari : int = 0;i < aObjects.length;i++) {

    actionObjects[i] = aObjects[i];

    //print (actionObjects[i].name);

    }

    }


Using tags1

Using Tags

function CheckForActive (name : String) {

// check to see if the object is active before assigning it to auxObject

if(gameObject.Find(name)) varauxObject = gameObject.Find(name);

else { // if no match was found, it must need to be activated

//load the actionObject array from the GameManager script

varactionObjects : GameObject[] = controlCenter.GetComponent(GameManager).actionObjects;

for (var y : int = 0; y < actionObjects.length; y++) { // iterate through the array

if (actionObjects[y].gameObject.name == name) { // if there is a match for the name

actionObjects[y].gameObject.SetActive(true); // activate the matched object from the array

auxObject = gameObject.Find(name); // assign the newly activated object

} // close the if

} // close the for loop

} // close the else

return auxObject; // return the gameObject to where the function was called

}


Visibility

Visibility

function HandleVisibility () {

switch (currentVisibility) {

case 0 : // deactivate at start

if(currentLocation == 0 ) {

// turn off the timer for the cursor before deactivating the object

pickTimerTime = Time.time; // set timer to now to force it to finish

yield; // give timer a chance to stop

if(currentSound != null) {

ProcessAudio (currentSound); // send audio clip off for processing first

yield new WaitForSeconds(currentSound.length); // allow time to play the sound clip

}

gameObject.SetActive(false); // deactivate the object immediately

}

break;

case 1: // currentVisibility is 1, Show at start

print ("here at 1");

if (useAlpha) {

startColor = alphaColor; // assign the start color

endColor = originalColor; // assign the end color

ent = 0; // start the fade

}

break;

case 2: // currentVisibility is 2, Show at start, hide at end

if (useAlpha) {

startColor = alphaColor; // assign the start color

endColor = originalColor; // assign the end color

ent = 0; // start the fade

}

// set up for fade out

if (aniLength == 0.0) aniLength = 2.0; // at least let it show a couple of seconds before the fade

fadeTimerTime = Time.time + aniLength;

fadeTimer = true; // turn on the flag to check the timer

break;

case 3: // currentVisibility is 3, hide at end

// set up for fade out

if (aniLength == 0.0) aniLength = 2.0; // at least let it show a couple of seconds before the fade

fadeTimerTime = Time.time + aniLength;

fadeTimer = true; // turn on the flag to check the timer

break;

}

}


Developing non keyframed fades

Developing Non-Keyframed Fades

function Update () {

if (pickTimer && Time.time > pickTimerTime) { // if time is up and flag is on...

pickTimer = false; // turn off the flag

// turn off the flag to suppress the cursor

controlCenter.GetComponent(GameManager).suppressPointer = false;

}

// timer for visibility fades

if (fadeTimer && Time.time > fadeTimerTime) { // if time is up and flag is on...

fadeTimer = false; // turn off the flag

if(!useAlpha) gameObject.SetActive (false); // deactivate the object

// set up for the fade out

endColor = alphaColor;

startColor = originalColor;

ent = 0; // start the fade

}

if(!useAlpha) return; // skip the fade code if it is not being used

else {

if(fadeIn) {

startColor = alphaColor;

endColor = originalColor;

}

if(fadeOut) {

endColor = alphaColor;

startColor = originalColor;

}

if (ent < 1) {

// calculate the current color using linear interpolation between start & end while it is less than 1

renderer.material.color = Color.Lerp(startColor, endColor, ent);

// increase the ent value using the rate

ent = ent + Time.deltaTime/fadeTime;

//deactivate the object if it is finished fading out

if (ent >= 1 && endColor == alphaColor)

gameObject.SetActive (false);

} //end the if/ent

} // end the else

}


Handling special cases

Handling Special Cases

  • a0_ will trigger an animation on a nonaction object.

  • b0_ will change state only on the object.

  • c0_ will send a message to call a function called “DoCameraMatch” on any script on the specified object.

  • s0_ will send a message to call a function called “DoTheJob” on any script on the specified object.

  • p0_ will instantiate a prefab.

  • See LookupState function in ObjectLookup script


Ensuring player focus

Ensuring Player Focus

  • See FPAdventurerInputController script


Exploring lerp

Exploring Lerp

  • See CameraMatch script

  • See CameraMatchData script


Summary

Summary

In this chapter, you added sophistication and flexibility to your state engine. You finished the auxiliary object parsing code by having it call the state processing code on the auxiliary object itself. In doing so, you made it possible to transition any number of action objects into their own unique states with a single pick event.

By adding a special cases section to the object lookup, you provided a means of dealing with typical issues, such as two ways to get into or return to the same state, and any specialty cases that may crop up.

You also implemented a code-based means of fading action objects in and out of the scene. It made use of the Lerp function, which provided you with a means of smoothly going between a start and end value over a duration that you could also define.

With the state transitions working smoothly, you turned your attention to improving the mechanics of the interactions, by refining the cursor functionality. This helped to prevent the player from missing important transitions. Then you took it one step further by repurposing the Lerp functionality and introducing a camera match. This allowed you to make sure the player was in the perfect spot to watch the action play out and also prevent him or her from leaving or looking elsewhere during the action.


  • Login