mirror of
https://github.com/4ian/GDevelop.git
synced 2025-10-15 10:19:04 +00:00
941 lines
27 KiB
JavaScript
941 lines
27 KiB
JavaScript
// @ts-check
|
|
describe('gdjs.TweenRuntimeBehavior', () => {
|
|
const behaviorName = 'Tween';
|
|
|
|
const createScene = (timeDelta = 1000 / 60) => {
|
|
const runtimeGame = gdjs.getPixiRuntimeGame();
|
|
const runtimeScene = new gdjs.TestRuntimeScene(runtimeGame);
|
|
runtimeScene._timeManager.getElapsedTime = () => {
|
|
return timeDelta;
|
|
};
|
|
return runtimeScene;
|
|
};
|
|
|
|
/**
|
|
* @param {gdjs.RuntimeScene} runtimeScene
|
|
* @returns {gdjs.TestRuntimeObject}
|
|
*/
|
|
const addObject = (runtimeScene) => {
|
|
const object = new gdjs.TestRuntimeObject(runtimeScene, {
|
|
name: 'Object',
|
|
type: '',
|
|
effects: [],
|
|
variables: [],
|
|
behaviors: [
|
|
{
|
|
type: 'Tween::TweenBehavior',
|
|
name: behaviorName,
|
|
},
|
|
],
|
|
});
|
|
runtimeScene.addObject(object);
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* @param {gdjs.RuntimeScene} runtimeScene
|
|
*/
|
|
const addSprite = (runtimeScene) => {
|
|
const object = new gdjs.SpriteRuntimeObject(runtimeScene, {
|
|
name: 'Sprite',
|
|
type: 'Sprite',
|
|
effects: [],
|
|
variables: [],
|
|
behaviors: [
|
|
{
|
|
type: 'Tween::TweenBehavior',
|
|
name: behaviorName,
|
|
},
|
|
],
|
|
animations: [
|
|
{
|
|
name: 'animation',
|
|
directions: [
|
|
{
|
|
sprites: [
|
|
{
|
|
originPoint: { name: 'Center', x: 0, y: 0 },
|
|
centerPoint: {
|
|
name: 'Origin',
|
|
automatic: false,
|
|
x: 32,
|
|
y: 32,
|
|
},
|
|
points: [
|
|
{ name: 'Center', x: 0, y: 0 },
|
|
{ name: 'Origin', x: 32, y: 32 },
|
|
],
|
|
hasCustomCollisionMask: false,
|
|
customCollisionMask: [],
|
|
image: '',
|
|
},
|
|
],
|
|
timeBetweenFrames: 0,
|
|
looping: false,
|
|
},
|
|
],
|
|
useMultipleDirections: false,
|
|
},
|
|
],
|
|
updateIfNotVisible: true,
|
|
});
|
|
object.getWidth = () => 64;
|
|
object.getHeight = () => 64;
|
|
runtimeScene.addObject(object);
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* @param {gdjs.RuntimeScene} runtimeScene
|
|
*/
|
|
const addCube = (runtimeScene) => {
|
|
const object = new gdjs.Cube3DRuntimeObject(runtimeScene, {
|
|
name: 'Cube',
|
|
type: 'Scene3D::Cube3DObject',
|
|
effects: [],
|
|
variables: [],
|
|
behaviors: [
|
|
{
|
|
type: 'Tween::TweenBehavior',
|
|
name: behaviorName,
|
|
},
|
|
],
|
|
// @ts-ignore
|
|
content: {
|
|
width: 64,
|
|
height: 64,
|
|
depth: 64,
|
|
},
|
|
});
|
|
runtimeScene.addObject(object);
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* @param {gdjs.RuntimeScene} runtimeScene
|
|
*/
|
|
const addTextObject = (runtimeScene) => {
|
|
const object = new gdjs.TextRuntimeObject(runtimeScene, {
|
|
name: 'Text',
|
|
type: 'TextObject::Text',
|
|
effects: [],
|
|
variables: [],
|
|
behaviors: [
|
|
{
|
|
type: 'Tween::TweenBehavior',
|
|
name: behaviorName,
|
|
},
|
|
],
|
|
content: {
|
|
characterSize: 20,
|
|
font: '',
|
|
bold: false,
|
|
italic: false,
|
|
underlined: false,
|
|
color: '0;0;0',
|
|
text: '',
|
|
textAlignment: 'left',
|
|
verticalTextAlignment: 'top',
|
|
isOutlineEnabled: false,
|
|
outlineThickness: 2,
|
|
outlineColor: '255;255;255',
|
|
isShadowEnabled: false,
|
|
shadowColor: '0;0;0',
|
|
shadowOpacity: 128,
|
|
shadowDistance: 4,
|
|
shadowAngle: 90,
|
|
shadowBlurRadius: 2,
|
|
lineHeight: 0,
|
|
},
|
|
});
|
|
runtimeScene.addObject(object);
|
|
return object;
|
|
};
|
|
|
|
/** @type {gdjs.RuntimeScene} */
|
|
let runtimeScene;
|
|
/** @type {gdjs.RuntimeObject} */
|
|
let object;
|
|
/** @type {gdjs.SpriteRuntimeObject} */
|
|
let sprite;
|
|
/** @type {gdjs.Cube3DRuntimeObject} */
|
|
let cube;
|
|
/** @type {gdjs.TextRuntimeObject} */
|
|
let textObject;
|
|
/** @type {gdjs.TweenRuntimeBehavior} */
|
|
let behavior;
|
|
/** @type {gdjs.TweenRuntimeBehavior} */
|
|
let spriteBehavior;
|
|
/** @type {gdjs.TweenRuntimeBehavior} */
|
|
let cubeBehavior;
|
|
/** @type {gdjs.TweenRuntimeBehavior} */
|
|
let textObjectBehavior;
|
|
beforeEach(() => {
|
|
runtimeScene = createScene();
|
|
runtimeScene.getLayer('').setTimeScale(1.5);
|
|
object = addObject(runtimeScene);
|
|
sprite = addSprite(runtimeScene);
|
|
cube = addCube(runtimeScene);
|
|
textObject = addTextObject(runtimeScene);
|
|
//@ts-ignore
|
|
behavior = object.getBehavior(behaviorName);
|
|
//@ts-ignore
|
|
spriteBehavior = sprite.getBehavior(behaviorName);
|
|
//@ts-ignore
|
|
cubeBehavior = cube.getBehavior(behaviorName);
|
|
//@ts-ignore
|
|
textObjectBehavior = textObject.getBehavior(behaviorName);
|
|
});
|
|
|
|
it("can get default values for tweens that don't exist", () => {
|
|
expect(behavior.exists('MyTween')).to.be(false);
|
|
expect(behavior.getValue('MyTween')).to.be(0);
|
|
expect(behavior.getProgress('MyTween')).to.be(0);
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
});
|
|
|
|
it('can play a tween till the end', () => {
|
|
object.setPosition(200, 300);
|
|
|
|
behavior.addObjectPositionXTween2('MyTween', 600, 'linear', 0.25, false);
|
|
|
|
// Tween actions don't change the value directly.
|
|
expect(object.getX()).to.be(200);
|
|
expect(behavior.getValue('MyTween')).to.be(200);
|
|
expect(behavior.getProgress('MyTween')).to.be(0);
|
|
|
|
let oldX;
|
|
let oldValue;
|
|
let oldProgress;
|
|
for (let i = 0; i < 10; i++) {
|
|
oldX = object.getX();
|
|
oldValue = behavior.getValue('MyTween');
|
|
oldProgress = behavior.getProgress('MyTween');
|
|
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(true);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
expect(object.getX()).to.be.above(oldX);
|
|
expect(behavior.getValue('MyTween')).to.be.above(oldValue);
|
|
expect(behavior.getProgress('MyTween')).to.be.above(oldProgress);
|
|
}
|
|
// The tween reaches the end
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(true);
|
|
expect(object.getX()).to.be(600);
|
|
expect(behavior.getValue('MyTween')).to.be(600);
|
|
expect(behavior.getProgress('MyTween')).to.be(1);
|
|
expect(runtimeScene.getInstancesCountOnScene('Object')).to.be(1);
|
|
|
|
// The value is not changed after the tween is finished
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(true);
|
|
expect(object.getX()).to.be(600);
|
|
expect(behavior.getValue('MyTween')).to.be(600);
|
|
expect(behavior.getProgress('MyTween')).to.be(1);
|
|
|
|
// The value is not set to the targeted value over and over
|
|
// after the tween is finished.
|
|
object.setX(123);
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(object.getX()).to.be(123);
|
|
});
|
|
|
|
it('can remove the object at the end', () => {
|
|
object.setPosition(200, 300);
|
|
|
|
behavior.addObjectPositionXTween2('MyTween', 600, 'linear', 0.25, true);
|
|
|
|
for (let i = 0; i < 9; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
}
|
|
// The tween is near the end.
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(true);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
expect(object.getX()).to.be(600);
|
|
|
|
expect(runtimeScene.getInstancesCountOnScene('Object')).to.be(1);
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(runtimeScene.getInstancesCountOnScene('Object')).to.be(0);
|
|
});
|
|
|
|
it('can pause and resume a tween', () => {
|
|
object.setPosition(200, 300);
|
|
behavior.addObjectPositionXTween2('MyTween', 600, 'linear', 0.25, false);
|
|
|
|
// The tween starts
|
|
for (let i = 0; i < 5; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(true);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
}
|
|
expect(object.getX()).to.be(400);
|
|
|
|
// Pause the tween
|
|
behavior.pauseTween('MyTween');
|
|
expect(object.getX()).to.be(400);
|
|
for (let i = 0; i < 5; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
expect(object.getX()).to.be(400);
|
|
}
|
|
|
|
// The value is not overridden during the pause.
|
|
object.setX(123);
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(object.getX()).to.be(123);
|
|
|
|
// Resume the tween
|
|
behavior.resumeTween('MyTween');
|
|
|
|
// Tween actions don't change the value directly.
|
|
expect(object.getX()).to.be(123);
|
|
expect(behavior.isPlaying('MyTween')).to.be(true);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(object.getX()).to.be(440);
|
|
});
|
|
|
|
it('can stop and restart a tween', () => {
|
|
object.setPosition(200, 300);
|
|
|
|
// Start the tween
|
|
behavior.addObjectPositionXTween2('MyTween', 600, 'linear', 0.25, false);
|
|
for (let i = 0; i < 5; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(true);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
}
|
|
expect(object.getX()).to.be(400);
|
|
|
|
// Stop the tween
|
|
behavior.stopTween('MyTween', false);
|
|
expect(object.getX()).to.be(400);
|
|
for (let i = 0; i < 5; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(true);
|
|
expect(object.getX()).to.be(400);
|
|
}
|
|
|
|
// The value is not overridden by a stopped tween.
|
|
object.setX(123);
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(object.getX()).to.be(123);
|
|
|
|
// A stopped tween can't be resumed.
|
|
behavior.resumeTween('MyTween');
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(true);
|
|
expect(object.getX()).to.be(123);
|
|
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(object.getX()).to.be(123);
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(true);
|
|
|
|
// Restart the tween
|
|
behavior.addObjectPositionXTween2('MyTween', 623, 'linear', 0.25, false);
|
|
for (let i = 0; i < 5; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(true);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
}
|
|
expect(object.getX()).to.be(373);
|
|
});
|
|
|
|
it('can remove and recreate a tween', () => {
|
|
object.setPosition(200, 300);
|
|
|
|
// Start the tween
|
|
expect(behavior.exists('MyTween')).to.be(false);
|
|
behavior.addObjectPositionXTween2('MyTween', 600, 'linear', 0.25, false);
|
|
expect(behavior.exists('MyTween')).to.be(true);
|
|
for (let i = 0; i < 5; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(true);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
}
|
|
expect(object.getX()).to.be(400);
|
|
|
|
// Remove the tween
|
|
expect(behavior.exists('MyTween')).to.be(true);
|
|
behavior.removeTween('MyTween');
|
|
expect(behavior.exists('MyTween')).to.be(false);
|
|
expect(object.getX()).to.be(400);
|
|
for (let i = 0; i < 5; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
expect(object.getX()).to.be(400);
|
|
}
|
|
|
|
// The value is not overridden after the tween has been removed.
|
|
object.setX(123);
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(object.getX()).to.be(123);
|
|
|
|
// A removed tween can't be resumed.
|
|
behavior.resumeTween('MyTween');
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
expect(object.getX()).to.be(123);
|
|
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(object.getX()).to.be(123);
|
|
expect(behavior.isPlaying('MyTween')).to.be(false);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
|
|
// Recreate the tween
|
|
expect(behavior.exists('MyTween')).to.be(false);
|
|
behavior.addObjectPositionXTween2('MyTween', 623, 'linear', 0.25, false);
|
|
expect(behavior.exists('MyTween')).to.be(true);
|
|
for (let i = 0; i < 5; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(behavior.isPlaying('MyTween')).to.be(true);
|
|
expect(behavior.hasFinished('MyTween')).to.be(false);
|
|
}
|
|
expect(object.getX()).to.be(373);
|
|
expect(behavior.exists('MyTween')).to.be(true);
|
|
});
|
|
|
|
const checkProgress = (steps, getValueFunctions) => {
|
|
if (!Array.isArray(getValueFunctions)) {
|
|
getValueFunctions = [getValueFunctions];
|
|
}
|
|
for (let i = 0; i < steps; i++) {
|
|
const oldValues = getValueFunctions.map((getValue) => getValue());
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
|
|
for (let index = 0; index < oldValues.length; index++) {
|
|
expect(getValueFunctions[index]()).not.to.be(oldValues[index]);
|
|
}
|
|
}
|
|
};
|
|
|
|
it('can tween an object variable', () => {
|
|
const variable = object.getVariables().get('MyVariable');
|
|
variable.setNumber(200);
|
|
behavior.addVariableTween3('MyTween', variable, 600, 'linear', 0.25, false);
|
|
checkProgress(6, () => variable.getAsNumber());
|
|
expect(variable.getAsNumber()).to.be(440);
|
|
});
|
|
|
|
it('can tween an object value', () => {
|
|
behavior.addValueTween('MyTween', 200, 600, 'linear', 0.25, false, false);
|
|
checkProgress(6, () => behavior.getValue('MyTween'));
|
|
expect(behavior.getValue('MyTween')).to.be(440);
|
|
});
|
|
|
|
it('can tween the position on X axis', () => {
|
|
object.setX(200);
|
|
behavior.addObjectPositionXTween2('MyTween', 600, 'linear', 0.25, false);
|
|
checkProgress(6, () => object.getX());
|
|
expect(object.getX()).to.be(440);
|
|
});
|
|
|
|
it('can tween the position on Y axis', () => {
|
|
object.setY(200);
|
|
behavior.addObjectPositionYTween2('MyTween', 600, 'linear', 0.25, false);
|
|
checkProgress(6, () => object.getY());
|
|
expect(object.getY()).to.be(440);
|
|
});
|
|
|
|
it('can tween the position on Z axis', () => {
|
|
cube.setZ(200);
|
|
cubeBehavior.addObjectPositionZTween2(
|
|
null,
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, () => cube.getZ());
|
|
expect(cube.getZ()).to.be(440);
|
|
});
|
|
|
|
it('can tween the angle', () => {
|
|
object.setAngle(200);
|
|
behavior.addObjectAngleTween2('MyTween', 600, 'linear', 0.25, false);
|
|
checkProgress(6, () => object.getAngle());
|
|
expect(object.getAngle()).to.be(440);
|
|
});
|
|
|
|
it('can tween the rotation X', () => {
|
|
cube.setRotationX(200);
|
|
cubeBehavior.addObjectRotationXTween(
|
|
null,
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, () => cube.getRotationX());
|
|
expect(cube.getRotationX()).to.be(440);
|
|
});
|
|
|
|
it('can tween the rotation Y', () => {
|
|
cube.setRotationY(200);
|
|
cubeBehavior.addObjectRotationYTween(
|
|
null,
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, () => cube.getRotationY());
|
|
expect(cube.getRotationY()).to.be(440);
|
|
});
|
|
|
|
it('can tween the width', () => {
|
|
object.setWidth(200);
|
|
behavior.addObjectWidthTween2('MyTween', 600, 'linear', 0.25, false);
|
|
checkProgress(6, () => object.getWidth());
|
|
expect(object.getWidth()).to.be(440);
|
|
});
|
|
|
|
it('can tween the height', () => {
|
|
object.setHeight(200);
|
|
behavior.addObjectHeightTween2('MyTween', 600, 'linear', 0.25, false);
|
|
checkProgress(6, () => object.getHeight());
|
|
expect(object.getHeight()).to.be(440);
|
|
});
|
|
|
|
it('can tween the depth', () => {
|
|
cube.setDepth(200);
|
|
cubeBehavior.addObjectDepthTween2(
|
|
null,
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, () => cube.getDepth());
|
|
expect(cube.getDepth()).to.be(440);
|
|
});
|
|
|
|
it('can tween a number effect property', () => {
|
|
sprite.addEffect({
|
|
effectType: 'Outline',
|
|
name: 'MyEffect',
|
|
doubleParameters: { padding: 0, thickness: 200 },
|
|
stringParameters: { color: '16;32;64' },
|
|
booleanParameters: {},
|
|
});
|
|
spriteBehavior.addNumberEffectPropertyTween(
|
|
null,
|
|
'MyTween',
|
|
600,
|
|
'MyEffect',
|
|
'thickness',
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, () =>
|
|
sprite.getRendererEffects()['MyEffect'].getDoubleParameter('thickness')
|
|
);
|
|
expect(
|
|
sprite.getRendererEffects()['MyEffect'].getDoubleParameter('thickness')
|
|
).to.be(440);
|
|
});
|
|
|
|
it('can tween a color effect property', () => {
|
|
sprite.addEffect({
|
|
effectType: 'Outline',
|
|
name: 'MyEffect',
|
|
doubleParameters: { padding: 0, thickness: 200 },
|
|
stringParameters: { color: '16;32;64' },
|
|
booleanParameters: {},
|
|
});
|
|
spriteBehavior.addColorEffectPropertyTween(
|
|
null,
|
|
'MyTween',
|
|
'255;192;128',
|
|
'MyEffect',
|
|
'color',
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, () =>
|
|
sprite.getRendererEffects()['MyEffect'].getColorParameter('color')
|
|
);
|
|
expect(
|
|
sprite.getRendererEffects()['MyEffect'].getColorParameter('color')
|
|
).to.be(gdjs.rgbOrHexStringToNumber('76;235;27'));
|
|
});
|
|
|
|
it('can tween the opacity', () => {
|
|
sprite.setOpacity(128);
|
|
spriteBehavior.addObjectOpacityTween2(
|
|
'MyTween',
|
|
255,
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, () => sprite.getOpacity());
|
|
expect(sprite.getOpacity()).to.be(204.2);
|
|
});
|
|
|
|
it('can tween the color', () => {
|
|
sprite.setColor('16;32;64');
|
|
spriteBehavior.addObjectColorTween2(
|
|
'MyTween',
|
|
'255;192;128',
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
true
|
|
);
|
|
checkProgress(6, () => sprite.getColor());
|
|
// Colors are rounded by the tween.
|
|
expect(sprite.getColor()).to.be('76;235;27');
|
|
});
|
|
|
|
it('can tween the color to HSL', () => {
|
|
sprite.setColor('16;32;64');
|
|
spriteBehavior.addObjectColorHSLTween2(
|
|
'MyTween',
|
|
180,
|
|
true,
|
|
25,
|
|
50,
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, () => sprite.getColor());
|
|
// Colors are rounded by the tween.
|
|
expect(sprite.getColor()).to.be('57;110;129');
|
|
});
|
|
|
|
it('can tween the scale on X axis', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScaleX(200);
|
|
spriteBehavior.addObjectScaleXTween2(
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
checkProgress(6, () => sprite.getScaleX());
|
|
// The interpolation is exponential.
|
|
expect(sprite.getScaleX()).to.be(386.6364089863524);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scale on X axis to 0', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScaleX(1);
|
|
spriteBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
0,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
// The interpolation is exponential.
|
|
// It would need an infinite speed to go away from 0.
|
|
// This is why the scale is set to 0 directly.
|
|
for (let i = 0; i < 11; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(sprite.getScaleX()).to.be(0);
|
|
}
|
|
expect(spriteBehavior.hasFinished('MyTween')).to.be(true);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scale on X axis from 0', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScaleX(0);
|
|
spriteBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
1,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
// The interpolation is exponential.
|
|
// It would need an infinite speed to go away from 0.
|
|
// This is why the scale is set to 1 directly at the end.
|
|
for (let i = 0; i < 11; i++) {
|
|
expect(sprite.getScale()).to.be(0);
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
}
|
|
expect(spriteBehavior.hasFinished('MyTween')).to.be(true);
|
|
expect(sprite.getScaleX()).to.be(1);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scale on X axis from center', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScaleX(200);
|
|
spriteBehavior.addObjectScaleXTween2(
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
true
|
|
);
|
|
checkProgress(6, () => sprite.getScaleX());
|
|
// The interpolation is exponential.
|
|
expect(sprite.getScaleX()).to.be(386.6364089863524);
|
|
expect(sprite.getX()).to.be(-5872.3650875632775);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scale on Y axis', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScaleY(200);
|
|
spriteBehavior.addObjectScaleYTween2(
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
checkProgress(6, () => sprite.getScaleY());
|
|
// The interpolation is exponential.
|
|
expect(sprite.getScaleY()).to.be(386.6364089863524);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scale on Y axis to 0', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScaleY(1);
|
|
spriteBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
0,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
// The interpolation is exponential.
|
|
// It would need an infinite speed to go away from 0.
|
|
// This is why the scale is set to 0 directly.
|
|
for (let i = 0; i < 11; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(sprite.getScaleY()).to.be(0);
|
|
}
|
|
expect(spriteBehavior.hasFinished('MyTween')).to.be(true);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scale on Y axis from 0', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScaleY(0);
|
|
spriteBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
1,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
// The interpolation is exponential.
|
|
// It would need an infinite speed to go away from 0.
|
|
// This is why the scale is set to 1 directly at the end.
|
|
for (let i = 0; i < 11; i++) {
|
|
expect(sprite.getScale()).to.be(0);
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
}
|
|
expect(spriteBehavior.hasFinished('MyTween')).to.be(true);
|
|
expect(sprite.getScaleY()).to.be(1);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scale on Y axis from center', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScaleY(200);
|
|
spriteBehavior.addObjectScaleYTween2(
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
true
|
|
);
|
|
checkProgress(6, () => sprite.getScaleY());
|
|
// The interpolation is exponential.
|
|
expect(sprite.getScaleY()).to.be(386.6364089863524);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(-5572.3650875632775);
|
|
});
|
|
|
|
it('can tween the font size', () => {
|
|
textObject.setCharacterSize(200);
|
|
textObjectBehavior.addTextObjectCharacterSizeTween2(
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, () => textObject.getCharacterSize());
|
|
// The interpolation is exponential.
|
|
expect(textObject.getCharacterSize()).to.be(386.6364089863524);
|
|
});
|
|
|
|
it('can tween the position', () => {
|
|
object.setPosition(200, 300);
|
|
behavior.addObjectPositionTween2(
|
|
'MyTween',
|
|
600,
|
|
900,
|
|
'linear',
|
|
0.25,
|
|
false
|
|
);
|
|
checkProgress(6, [() => object.getX(), () => object.getY()]);
|
|
expect(object.getX()).to.be(440);
|
|
expect(object.getY()).to.be(660);
|
|
});
|
|
|
|
it('can tween the scale', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScale(200);
|
|
spriteBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
checkProgress(6, () => sprite.getScale());
|
|
// The interpolation is exponential.
|
|
expect(sprite.getScale()).to.be(386.6364089863524);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scale to 0', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScale(1);
|
|
spriteBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
0,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
// The interpolation is exponential.
|
|
// It would need an infinite speed to go away from 0.
|
|
// This is why the scale is set to 0 directly.
|
|
for (let i = 0; i < 11; i++) {
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
expect(sprite.getScale()).to.be(0);
|
|
}
|
|
expect(spriteBehavior.hasFinished('MyTween')).to.be(true);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scale from 0', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScale(0);
|
|
spriteBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
1,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
// The interpolation is exponential.
|
|
// It would need an infinite speed to go away from 0.
|
|
// This is why the scale is set to 1 directly at the end.
|
|
for (let i = 0; i < 11; i++) {
|
|
expect(sprite.getScale()).to.be(0);
|
|
runtimeScene.renderAndStep(1000 / 60);
|
|
}
|
|
expect(spriteBehavior.hasFinished('MyTween')).to.be(true);
|
|
expect(sprite.getScale()).to.be(1);
|
|
expect(sprite.getX()).to.be(100);
|
|
expect(sprite.getY()).to.be(400);
|
|
});
|
|
|
|
it('can tween the scales from center', () => {
|
|
sprite.setPosition(100, 400);
|
|
sprite.setScale(200);
|
|
spriteBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
true
|
|
);
|
|
checkProgress(6, () => sprite.getScale());
|
|
// The interpolation is exponential.
|
|
expect(sprite.getScale()).to.be(386.6364089863524);
|
|
expect(sprite.getX()).to.be(-5872.3650875632775);
|
|
expect(sprite.getY()).to.be(-5572.3650875632775);
|
|
});
|
|
|
|
it('can tween the scale of a cube', () => {
|
|
cube.setPosition(100, 400);
|
|
cube.setZ(800);
|
|
cube.setScale(200);
|
|
cubeBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
false
|
|
);
|
|
checkProgress(6, () => cube.getScale());
|
|
// The interpolation is exponential.
|
|
expect(cube.getScale()).to.be(386.6364089863524);
|
|
expect(cube.getX()).to.be(100);
|
|
expect(cube.getY()).to.be(400);
|
|
expect(cube.getZ()).to.be(800);
|
|
});
|
|
|
|
it('can tween the scales of a cube from center', () => {
|
|
cube.setPosition(100, 400);
|
|
cube.setZ(800);
|
|
cube.setScale(200);
|
|
cubeBehavior.addObjectScaleTween3(
|
|
'MyTween',
|
|
600,
|
|
'linear',
|
|
0.25,
|
|
false,
|
|
true
|
|
);
|
|
checkProgress(6, () => cube.getScale());
|
|
// The interpolation is exponential.
|
|
expect(cube.getScale()).to.be(386.6364089863524);
|
|
expect(cube.getX()).to.be(-5872.3650875632775);
|
|
expect(cube.getY()).to.be(-5572.3650875632775);
|
|
expect(cube.getZ()).to.be(-5172.3650875632775);
|
|
});
|
|
});
|