private bool AnimationPlay()
{
if(KindAnimation.NON == KindAnimationPlay)
{ /* Not being requested changing animation */
return(true);
}
int indexAnimation = TableIndexAnimation[(int)KindAnimationPlay];
if(0 > indexAnimation)
{ /* Invalid Animation's index */
return(false);
}
ScriptRoot.AnimationPlay(-1, indexAnimation, 0); /* play infinite */
KindAnimationPlay = KindAnimation.NON;
return(true);
}
void Update()
{
/* Check Validity */
if(false == FlagInitialized)
{ /* Failed to initialize */
return;
}
/* Adjust Parameters */
if(0 >= SizePixelFontX)
{
SizePixelFontX = (int)Constant.FONTSIZE_DEFAULT;
}
if(0 > IndexFont)
{
IndexFont = 0;
}
if((int)Constant.FONT_MAX <= IndexFont)
{
IndexFont = (int)Constant.FONT_MAX - 1;
}
/* Clamp Value */
int valueDisplay = Mathf.Clamp(Value, ValueMin, ValueMax);
/* Check & Update Animation */
if(FlagVibrationPrevious != FlagVibration)
{
/* MEMO: Simply, If animation-change is reserved, postpone to update. */
/* This process does not matter because depend on the convenience for application's specification. */
if(KindAnimation.NON == KindAnimationPlay)
{ /* Not reserved */
KindAnimationPlay = (true == FlagVibration) ? KindAnimation.ANIMATION_VIBRATION : KindAnimation.ANIMATION_NOMOVE;
FlagVibrationPrevious = FlagVibration;
}
AnimationPlay();
}
/* Check & Update AdditionalColor */
/* MEMO: The reason for checking two types of updates, "IndexColor" and "FlagChangeColor", */
/* is that "FlagChangeColor" is updated from inspector and "IndexColor" is updated in the UserData-callback function. */
if((FlagChangeColorPrevious != FlagChangeColor) || (IndexColorPrevious != IndexColor))
{
FlagChangeColorPrevious = FlagChangeColor;
IndexColorPrevious = IndexColor;
if(null != AdditionalColor)
{
/* MEMO: Created "AdditionalColor"'s Parameter can continue to be used unless call "AdditionalColorRelease". */
/* To temporarily-disable AdditionalColor, set "Library_SpriteStudio6.KindOperationBlend.NON". */
AdditionalColor.SetOverall((true == FlagChangeColor) ? Library_SpriteStudio6.KindOperationBlend.MUL : Library_SpriteStudio6.KindOperationBlend.NON,
TableColorFont[IndexColor]
);
}
}
/* Check Update */
bool flagUpdateText = false;
if(ValuePrevious != Value)
{
ValuePrevious = Value;
flagUpdateText |= true;
}
if(IndexFontPrevious != IndexFont)
{
IndexFontPrevious = IndexFont;
flagUpdateText |= true;
}
if(FlagPaddingZeroPrevious != FlagPaddingZero)
{
FlagPaddingZeroPrevious = FlagPaddingZero;
flagUpdateText |= true;
}
// if(SizePixelFontXPrevious != SizePixelFontX)
// {
// SizePixelFontXPrevious = SizePixelFontX;
// flagUpdateText |= true;
// }
if(FlagProportionalPrevious != FlagProportional)
{
FlagProportionalPrevious = FlagProportional;
flagUpdateText |= true;
}
/* Update Text */
if(true == flagUpdateText)
{
string textValue;
/* Get Text */
if(true == FlagPaddingZero)
{ /* Zero-padding */
textValue = valueDisplay.ToString("D" + ((int)(Constant.DIGIT_MAX)).ToString());
}
else
{ /* Right-alignment */
textValue = valueDisplay.ToString("D");
}
/* Update Digits */
{
/* Generate Text */
char[] charactersDigit = textValue.ToCharArray(); /* Split to digit */
int countDigit = charactersDigit.Length;
int idParts;
int indexCharacter;
int positionPixelDigit = 0;
for(int i=0; i<countDigit; i++)
{
/* MEMO: Since "idParts == 0" is the "Root"-part, intentionally excluded. */
/* Setting HideSet's idParts to 0 is to control hidding the entire animation. */
idParts = TablePartsDigit[i].IDParts;
if(0 < idParts)
{
/* Change Cell */
/* MEMO: (IndexCellMap == 0) Because this Animation has 1 Texture. */
indexCharacter = IndexGetCharacter(charactersDigit[(countDigit - 1) - i]);
ScriptRoot.CellChangeParts( idParts,
0,
TableCellCharacter[IndexFont, indexCharacter].IndexCell,
Library_SpriteStudio6.KindIgnoreAttribute.PERMANENT /* Ignore "Reference-Cell" attribute even if change animation */
);
/* Show Digit */
/* MEMO: Don't Effect to children */
ScriptRoot.HideSet(idParts, false, false);
/* Set Digit's position */
{
/* Get Pixel-Width */
int pixelSpaceNow = (true == FlagProportional) ? (int)(TableCellCharacter[IndexFont, indexCharacter].SizeCell.x) : SizePixelFontX;
pixelSpaceNow /= 2; /* Spacing-width = (Previous digit's width + Now digit's width) / 2 */
/* Adjust Position */
if(0 < i)
{ /* The 1st-digit is Fixed-Position */
positionPixelDigit -= pixelSpaceNow;
/* MEMO: There are conditions that must be met to successfully overwrite part's "Transform" from script. */
/* 1. When overwrite position, "X Position", "Y Position" and "Z Position" */
/* must not have key-frame data in animation (and "Setup" animation). */
/* 2. When overwrite rotation, "X-axis Rotation", "Y-axis Rotation" and "Z-axis Rotation" */
/* must not have key-frame data in animation (and "Setup" animation). */
/* 3. When overwrite scaling, "X Scale" and "Y Scale" */
/* must not have key-frame data in animation (and "Setup" animation). */
/* ("Local X Scale" and "Local Y Scale" can have key-frame datas) */
Transform transformDigit = TablePartsDigit[i].Transform;
Vector3 localPositionDigit = transformDigit.localPosition;
localPositionDigit.x = (float)positionPixelDigit;
transformDigit.localPosition = localPositionDigit;
}
positionPixelDigit -= pixelSpaceNow;
}
}
}
for(int i=countDigit; i<(int)Constant.DIGIT_MAX; i++)
{
idParts = TablePartsDigit[i].IDParts;
if(0 < idParts)
{
ScriptRoot.HideSet(idParts, true, false);
}
}
}
}
}
void Start()
{
/* Initialize WorkArea */
FlagPaddingZeroPrevious = !FlagPaddingZero; /* Since this value can not be set with initializer... */
FlagProportionalPrevious = !FlagProportional;
FlagChangeColorPrevious = !FlagChangeColorPrevious;
FlagVibrationPrevious = !FlagVibrationPrevious;
/* Get Animation Control Script-Component */
GameObject gameObjectBase = GameObjectRoot;
if(null == gameObjectBase)
{
gameObjectBase = gameObject;
}
/* MEMO: "Script_SpriteStudio6_Root.Parts.RootGet" is function for finding "Script_SpriteStudio6_Root" in GameObjects below. */
/* (However, "Instance" is excluded. Find only "Highest-Root"-parts) */
/* You can find "shallowest hierarchy"-one from direct-children, but not guarantee the shallowest when deeper than children. */
/* Because wasteful to search every time access, recommend to cache. */
ScriptRoot = Script_SpriteStudio6_Root.Parts.RootGet(gameObjectBase);
if(null == ScriptRoot)
{ /* Error */
return;
}
/* Set UserData callback function */
/* MEMO: Set up function to handle UserData callback. */
/* To avoid receiving UserData callback, set "ScriptRoot.FunctionUserData" to null. */
ScriptRoot.FunctionUserData = FunctionCallBackUserData;
/* Get Animation Index */
/* MEMO: Collect animation-indexs ahead of time. */
/* Every change animation, also you can get index by name. */
/* But wasteful to search each time. */
TableIndexAnimation = AnimationIndexGet();
if(null == TableIndexAnimation)
{
return;
}
/* Animation Start */
KindAnimationPlay = (true == FlagVibration) ? KindAnimation.ANIMATION_VIBRATION : KindAnimation.ANIMATION_NOMOVE;
AnimationPlay();
/* Get Digit's Animation Parts */
TablePartsDigit = PartsInformationGet();
if(null == TablePartsDigit)
{
return;
}
/* MEMO: When position refresh occurs at animation initialize, refresh is prohibited */
/* to prevent overwriting position of digits' animation parts set at Update() with refreshing. */
int countPartsDigit = TablePartsDigit.Length;
int idParts;
for(int i=0; i<countPartsDigit; i++)
{
idParts = TablePartsDigit[i].IDParts;
if(0 <= idParts)
{
ScriptRoot.RefreshCancelTransform(idParts, true, false, false);
}
}
/* Get Cell Information */
TableCellCharacter = CellInformationGet();
if(null == TableCellCharacter)
{
return;
}
/* Create Additional-Color Parameter */
/* MEMO: Call "AdditionalColorRelease" when created parameter with "AdditionalColorCreate" are no longer used. */
AdditionalColor = ScriptRoot.AdditionalColorCreate();
/* Initialize Complete */
FlagInitialized = true;
}
void Update()
{
int indexAnimation;
/* Check Validity */
if (false == FlagInitialized)
{ /* Failed to initialize */
return;
}
/* Initialize Multi-Track & Connect Parts to Track */
if (false == FlagInitializedTrack)
{
ScriptRoot.AnimationStop(-1);
/* Initialize Multi-Track */
/* MEMO: The number of tracks must be equal or more than the number of animations played at the same time. */
/* In this sample, allocate different animations for "upper body" and "lower body", so two are required at least. */
/* */
/* Also, the reason for creating 4 tracks is because of "Animation Transition". */
/* "Animation Transitions" will play 2 animations during the transition so need 2 tracks when use "Animation Transition". */
/* In this sample, "upper body" and "lower body" are run separately, so the following 4 tracks are required. */
/* - For playing "upper body"'s animation */
/* - For playing "lower body"'s animation */
/* - For "upper body"'s animation-transition */
/* - For "lower body"'s animation-transition */
/* */
/* "Animation transition" is function to transition between 2 animations while interpolating TRS(Position, Rotation */
/* and Scaling). */
/* MEMO: To initialize multi tracks, Seting number of tracks directly from "Script_SpriteStudio6_Root"'s inspector is also OK. */
/* In this sample, provide as a way to initialize from a script. */
/* However, not recommended that Increasing or decreasing the number of tracks frequently during appliacation running. */
/* MEMO: "TrackReboot" function will not reinstall the track if more than specified number of tracks are already exist. */
/* Also, current playing state is preserved. */
if (false == ScriptRoot.TrackReboot((int)KindTrack.TERMINATOR))
{ /* Error */
return;
}
/* Connect Parts to Track */
/* MEMO: You can link(connect) each animation's parts to "Track"s. */
/* Each "Track"s can play different animations, so you can blend animations as a result. */
/* However, can not assign plural tracks to 1 part. */
if (false == PartsConnectTrack())
{
return;
}
/* Initialize Animation */
indexAnimation = TableIndexAnimation[(int)AnimationUpperBody];
ScriptRoot.AnimationPlay((int)KindTrack.BODY_UPPER, indexAnimation, 0);
AnimationUpperBodyPrevious = AnimationUpperBody;
indexAnimation = TableIndexAnimation[(int)AnimationLowerBody];
ScriptRoot.AnimationPlay((int)KindTrack.BODY_LOWER, indexAnimation, 0);
AnimationLowerBodyPrevious = AnimationLowerBody;
FlagInitializedTrack = true;
}
/* Adjust values */
if (0.1f >= TimeAnimationTransition)
{
TimeAnimationTransition = 0.1f;
}
/* Update Animations */
if (AnimationLowerBodyPrevious != AnimationLowerBody)
{
indexAnimation = TableIndexAnimation[(int)AnimationLowerBody];
if (0 <= indexAnimation)
{
if (true == FlagAnimationTransition)
{ /* Transition (Fade) */
/* MEMO: When start transition, you need to play destination animation on track for transition first. */
ScriptRoot.AnimationPlay((int)KindTrack.TRANSITION_LOWER, indexAnimation, 0);
/* MEMO: Connect transition track to current animation's track after destination animation is successfully played. */
/* Set the transtion track to "indexTrackSlave". */
/* MEMO: Transition ends at set time(TimeAnimationTransition). */
/* At the end of the transition, transition track's playing state will move to master track. */
/* MEMO: Transition while animating when current animation or destination animation is not in the pause state. */
ScriptRoot.TrackTransition((int)KindTrack.BODY_LOWER,
(int)KindTrack.TRANSITION_LOWER,
TimeAnimationTransition,
false /* Ignored if destination animation is not in pause state. */
);
/* MEMO: If you want timing of transition end, set callback function to "FunctionPlayEndTrack [master track's index]" of ScriptRoot. */
ScriptRoot.FunctionPlayEndTrack[(int)KindTrack.BODY_LOWER] = FunctionPlayEndTrackBody;
}
else
{ /* Immediate */
ScriptRoot.AnimationPlay((int)KindTrack.BODY_LOWER, indexAnimation, 0);
}
}
AnimationLowerBodyPrevious = AnimationLowerBody;
}
if (AnimationUpperBodyPrevious != AnimationUpperBody)
{
indexAnimation = TableIndexAnimation[(int)AnimationUpperBody];
if (0 <= indexAnimation)
{
if (true == FlagAnimationTransition)
{ /* Transition (Fade) */
/* MEMO: If you pause animation and make a transition, you can perform transition while stopping the animation. */
ScriptRoot.AnimationPlay((int)KindTrack.TRANSITION_UPPER, indexAnimation, 0);
ScriptRoot.AnimationPause((int)KindTrack.TRANSITION_UPPER, true);
ScriptRoot.AnimationPause((int)KindTrack.BODY_UPPER, true);
/* MEMO: Set "flagCancelPauseAfterTransition" to true to automatically unpause animation when transition is complete. */
/* Of course, you can get the timing with transition end callback and cancel pause state by yourself. */
/* But this way is more easier. */
ScriptRoot.TrackTransition((int)KindTrack.BODY_UPPER,
(int)KindTrack.TRANSITION_UPPER,
TimeAnimationTransition,
true
);
}
else
{ /* Immediate */
ScriptRoot.AnimationPlay((int)KindTrack.BODY_UPPER, indexAnimation, 0);
}
}
AnimationUpperBodyPrevious = AnimationUpperBody;
}
}
