Poses and body part movement

I think it's this one:

https://www.daz3d.com/forums/discussion/20208/breast-bounce-script-for-daz-studio-4-5/p9 - in one of the latest posts

Here the code:
---------------

// DAZ Studio version 4.10.0.123 filetype DAZ Script

var nUpDownMorphAmplitude = 1;
var nUpDownDamp = 30;
var nUpDownNumberOfFrames = 15;
var nUpDownNumberOfPeriods = 2;

var nRightLeftMorphAmplitude = 1;
var nRightLeftDamp = 30;
var nRightLeftNumberOfFrames = 15;
var nRightLeftNumberOfPeriods = 2;

var nForwardBackMorphAmplitude = 1;
var nForwardBackDamp = 10;
var nForwardBackNumberOfFrames = 20;
var nForwardBackNumberOfPeriods = 1;

var nMovingAveFrames = 0;
var nGravity = 9.8;

var oNode = Scene.getPrimarySelection();
var oObject = Scene.getPrimarySelection().getSkeleton().getObject();

var oDate = new Date(Date.now());
var eDate = new Date(3029,5,6,0,0); // DON'T FORGET TO COMMENT OUT 2 LINES BELOW!!!!

if (eDate - oDate > 0) {
//MessageBox.information(qsTr("You have " + Math.round((eDate-oDate)/1000/3600/24).toString()+" days left to try this software. "),qsTr("Breasts Physics"),qsTr("OK"));

if (oNode){
fDialog();
}
else {
MessageBox.information(qsTr("Select G3F and run again."),qsTr("Breasts Physics"),qsTr("OK"));
}
}
else {
MessageBox.information(qsTr("Contact me for a new version."),qsTr("Breasts Physics"),qsTr("OK"));
// stop
}

function fDialog() {
const cDialNameUDLRAmplitude = "UDLR Amplitude";
const cDialNameUDLRDampingRatio = "UDLR Damping Ratio";
const cDialNameUDLRNoF = "UDLR Number of Frames";
const cDialNameUDLRNoP = "UDLR Number of Periods";

const cDialNameFBAmplitude = "FB Amplitude";
const cDialNameFBDampingRatio = "FB Damping Ratio";
const cDialNameFBNoF = "FB Number of Frames";
const cDialNameFBNoP = "FB Number of Periods";

const cDialNameMovingAve = "Moving Average";
const cDialNameGravity = "Gravity";

const nMARGIN = 5;
const nSPACING = 5;
const nMIN_BTN_WIDTH = 80;
const nMAX_BTN_HEIGHT = 20;

//var oNode = Scene.getPrimarySelection().getSkeleton();
Scene.setFrame(0);

if (oObject.findModifier(cDialNameUDLRAmplitude)) {

//Morph dials exist => set the values
nUpDownMorphAmplitude = oObject.findModifier(cDialNameUDLRAmplitude).getValueChannel().getValue();
nUpDownDamp = oObject.findModifier(cDialNameUDLRDampingRatio).getValueChannel().getValue();
nUpDownNumberOfFrames = oObject.findModifier(cDialNameUDLRNoF).getValueChannel().getValue();
nUpDownNumberOfPeriods = oObject.findModifier(cDialNameUDLRNoP).getValueChannel().getValue();
nForwardBackMorphAmplitude = oObject.findModifier(cDialNameFBAmplitude).getValueChannel().getValue();
nForwardBackDamp = oObject.findModifier(cDialNameFBDampingRatio).getValueChannel().getValue();
nForwardBackNumberOfFrames = oObject.findModifier(cDialNameFBNoF).getValueChannel().getValue();
nForwardBackNumberOfPeriods = oObject.findModifier(cDialNameFBNoP).getValueChannel().getValue();
nMovingAveFrames = oObject.findModifier(cDialNameMovingAve).getValueChannel().getValue();
nGravity = oObject.findModifier(cDialNameGravity).getValueChannel().getValue();

}
else {

//Morph dials dont exist ==> Create them
fCreateDial(cDialNameUDLRAmplitude, nUpDownMorphAmplitude, 0, 2.0);
fCreateDial(cDialNameUDLRDampingRatio, nUpDownDamp, 10, 90);
fCreateDial(cDialNameUDLRNoF, nUpDownNumberOfFrames, 0, 30);
fCreateDial(cDialNameUDLRNoP, nUpDownNumberOfPeriods, 0, 3);
fCreateDial(cDialNameFBAmplitude, nForwardBackMorphAmplitude, 0, 2.0);
fCreateDial(cDialNameFBDampingRatio, nForwardBackDamp, 10, 90);
fCreateDial(cDialNameFBNoF, nForwardBackNumberOfFrames, 0, 30);
fCreateDial(cDialNameFBNoP, nForwardBackNumberOfPeriods, 0, 3);
fCreateDial(cDialNameMovingAve, nMovingAveFrames, 0, 7);
fCreateDial(cDialNameGravity, nGravity, 0, 10);

}

// Get the Help Manager for "What's This?" and tool tips
var oHelpMgr = App.getHelpMgr();

// find the "What's This?" action; for the help button
var oActionMgr = MainWindow.getActionMgr();
var oHelpAction = oActionMgr ? oActionMgr.findAction( "DzWhatsThisAction" ) : undefined;

/*****************************
Dialog
*****************************/
var wDlg = new DzDialog();
wDlg.caption = "Breast Physics v.1.02";

// Main Layout
var wDlgLyt = new DzVBoxLayout( wDlg );
wDlgLyt.autoAdd = true;
wDlgLyt.margin = nMARGIN;
wDlgLyt.spacing = nSPACING;

// Create a label
var wLbl = new DzLabel( wDlg );
wLbl.text = "\n\"Breast Control Genesis 3 Female(s)\" is required to run this script.\n";

// =========================================
// Create a UpDown/LeftRight Large Group box
var wBoxUDLRLarge = new DzHGroupBox( wDlg );
wBoxUDLRLarge.orientation = DzHGroupBox.Vertical;
wBoxUDLRLarge.title = "Up / Down / Left / Right Vibration";

// Create a group box
var wBoxUDLRStrength = new DzHGroupBox( wBoxUDLRLarge );
// Create a label
var wLbl = new DzLabel( wBoxUDLRStrength );
wLbl.text = "Amplitude";
// Create a float slider
var wSliderUDLRStrength = new DzFloatSlider( wBoxUDLRStrength );
wSliderUDLRStrength.min = 0;
wSliderUDLRStrength.max = 2;
wSliderUDLRStrength.clamped = true;
wSliderUDLRStrength.sensitivity = 0.1;
wSliderUDLRStrength.textEditable = true;
wSliderUDLRStrength.textVisible = true;
wSliderUDLRStrength.value = nUpDownMorphAmplitude;

// Create a group box
var wBoxUDLRDampingRatio = new DzHGroupBox( wBoxUDLRLarge );
// Create a label
var wLbl = new DzLabel( wBoxUDLRDampingRatio );
wLbl.text = "Damping ratio";
// Create a int slider
var wSliderUDLRDampingRatio = new DzIntSlider( wBoxUDLRDampingRatio );
wSliderUDLRDampingRatio.min = 10;
wSliderUDLRDampingRatio.max = 90;
wSliderUDLRDampingRatio.clamped = true;
wSliderUDLRDampingRatio.sensitivity = 1;
wSliderUDLRDampingRatio.textEditable = true;
wSliderUDLRDampingRatio.textVisible = true;
wSliderUDLRDampingRatio.displayAsPercent = true;
wSliderUDLRDampingRatio.value = nUpDownDamp;

// Create a group box
var wBoxUDLRNoF = new DzHGroupBox( wBoxUDLRLarge );
// Create a label
var wLbl = new DzLabel( wBoxUDLRNoF );
wLbl.text = "Number of frames per period";
// Create a int slider
var wSliderUDLRNoF = new DzIntSlider( wBoxUDLRNoF );
wSliderUDLRNoF.min = 0;
wSliderUDLRNoF.max = 30;
wSliderUDLRNoF.clamped = true;
wSliderUDLRNoF.sensitivity = 1;
wSliderUDLRNoF.textEditable = true;
wSliderUDLRNoF.textVisible = true;
wSliderUDLRNoF.value = nUpDownNumberOfFrames;

// Create a group box
var wBoxUDLRNoP = new DzHGroupBox( wBoxUDLRLarge );
// Create a label
var wLbl = new DzLabel( wBoxUDLRNoP );
wLbl.text = "Number of periods to vibrate";
// Create a enum slider
wSliderUDLRNoP = new DzEnumSlider( wBoxUDLRNoP );
wSliderUDLRNoP.addItem( "1" );
wSliderUDLRNoP.addItem( "2" );
wSliderUDLRNoP.addItem( "3" );
wSliderUDLRNoP.addItem( "4" );
wSliderUDLRNoP.value = nUpDownNumberOfPeriods;

// =========================================
// Create a Forward/Backward Large Group box
var wBoxFBLarge = new DzHGroupBox( wDlg );
wBoxFBLarge.orientation = DzHGroupBox.Vertical;
wBoxFBLarge.title = "Forward / Backward Vibration";

// Create a group box
var wBoxFBStrength = new DzHGroupBox( wBoxFBLarge );
// Create a label
var wLbl = new DzLabel( wBoxFBStrength );
wLbl.text = "Amplitude";
// Create a float slider
var wSliderFBStrength = new DzFloatSlider( wBoxFBStrength );
wSliderFBStrength.min = 0;
wSliderFBStrength.max = 2;
wSliderFBStrength.clamped = true;
wSliderFBStrength.sensitivity = 0.1;
wSliderFBStrength.textEditable = true;
wSliderFBStrength.textVisible = true;
wSliderFBStrength.value = nForwardBackMorphAmplitude;

// Create a group box
var wBoxFBDampingRatio = new DzHGroupBox( wBoxFBLarge );
// Create a label
var wLbl = new DzLabel( wBoxFBDampingRatio );
wLbl.text = "Damping ratio";
// Create a int slider
var wSliderFBDampingRatio = new DzIntSlider( wBoxFBDampingRatio );
wSliderFBDampingRatio.min = 10;
wSliderFBDampingRatio.max = 90;
wSliderFBDampingRatio.clamped = true;
wSliderFBDampingRatio.sensitivity = 1;
wSliderFBDampingRatio.textEditable = true;
wSliderFBDampingRatio.textVisible = true;
wSliderFBDampingRatio.displayAsPercent = true;
wSliderFBDampingRatio.value = nForwardBackDamp;

// Create a group box
var wBoxFBNoF = new DzHGroupBox( wBoxFBLarge );
// Create a label
var wLbl = new DzLabel( wBoxFBNoF );
wLbl.text = "Number of frames per period";
// Create a int slider
var wSliderFBNoF = new DzIntSlider( wBoxFBNoF );
wSliderFBNoF.min = 0;
wSliderFBNoF.max = 30;
wSliderFBNoF.clamped = true;
wSliderFBNoF.sensitivity = 1;
wSliderFBNoF.textEditable = true;
wSliderFBNoF.textVisible = true;
wSliderFBNoF.value = nForwardBackNumberOfFrames;

// Create a group box
var wBoxFBNoP = new DzHGroupBox( wBoxFBLarge );
// Create a label
var wLbl = new DzLabel( wBoxFBNoP );
wLbl.text = "Number of periods to vibrate";
// Create a enum slider
wSliderFBNoP = new DzEnumSlider( wBoxFBNoP );
wSliderFBNoP.addItem( "1" );
wSliderFBNoP.addItem( "2" );
wSliderFBNoP.addItem( "3" );
wSliderFBNoP.addItem( "4" );
wSliderFBNoP.value = nForwardBackNumberOfPeriods;

// =========================================
// Create Large Group box for Others
var wBoxOthers = new DzHGroupBox( wDlg );
wBoxOthers.orientation = DzHGroupBox.Horizontal
wBoxOthers.title = "Others"

// Create a group box
var wBoxMA = new DzHGroupBox( wBoxOthers );
// Create a label
var wLbl = new DzLabel( wBoxMA );
wLbl.text = "Moving Ave.";
// Create a enum slider
wSliderMovingAve = new DzEnumSlider( wBoxMA );
wSliderMovingAve.addItem( "1" );
wSliderMovingAve.addItem( "2" );
wSliderMovingAve.addItem( "3" );
wSliderMovingAve.addItem( "4" );
wSliderMovingAve.addItem( "5" );
wSliderMovingAve.addItem( "6" );
wSliderMovingAve.addItem( "7" );
wSliderMovingAve.addItem( "8" );
wSliderMovingAve.value = nMovingAveFrames;

// Create a group box
var wBoxGravity = new DzHGroupBox( wBoxOthers );
// Create a label
var wLbl = new DzLabel( wBoxGravity );
wLbl.text = "Gravity";
// Create a float slider
var wSliderGravity = new DzFloatSlider( wBoxGravity );
wSliderGravity.min = 0;
wSliderGravity.max = 10;
wSliderGravity.clamped = true;
wSliderGravity.sensitivity = 0.1;
wSliderGravity.textEditable = true;
wSliderGravity.textVisible = true;
wSliderGravity.value = nGravity;

// =========================================

// Create a group box for the dialog buttons
var wDlgBtnsGB = new DzGroupBox( wDlg );
wDlgBtnsGB.flat = true;

// Create a layout for the dialog buttons
var wDlgBtnsLyt = new DzGridLayout( wDlgBtnsGB );
wDlgBtnsLyt.margin = nMARGIN;
wDlgBtnsLyt.spacing = nSPACING;

// Create a label
var wLbl = new DzLabel( wDlgBtnsGB );
wLbl.text = "2018/03/20 by MasatoK0606. All rights reserved."

// Stretch the column between the left and right sides
wDlgBtnsLyt.setColStretch( 1, 1 );

// Create the accept push button
var wAcceptBtn = new DzPushButton( wDlgBtnsGB );
wAcceptBtn.text = "Simulate";
wAcceptBtn.minWidth = nMIN_BTN_WIDTH;
wAcceptBtn.maxHeight = nMAX_BTN_HEIGHT;
wDlg.setAcceptButton( wAcceptBtn );
//wAcceptBtn.toolTip = oHelpMgr.getToolTip( "AcceptDialog" );
//wAcceptBtn.whatsThis = oHelpMgr.getHelpString( "AcceptDialog" );
wDlgBtnsLyt.addWidget( wAcceptBtn, 0, 2 );

// Create the cancel push button
var wCancelBtn = new DzPushButton( wDlgBtnsGB );
wCancelBtn.text = "Cancel";
wCancelBtn.minWidth = nMIN_BTN_WIDTH;
wCancelBtn.maxHeight = nMAX_BTN_HEIGHT;
wDlg.setRejectButton( wCancelBtn );
//wCancelBtn.toolTip = oHelpMgr.getToolTip( "CancelDialog" );
//wCancelBtn.whatsThis = oHelpMgr.getHelpString( "CancelDialog" );
wDlgBtnsLyt.addWidget( wCancelBtn, 0, 3 );

// Polish
wDlg.width = wDlg.minWidth > 400 ? wDlg.minWidth : 400;
wDlg.height = wDlg.minHeight;

// Launch the dialog
if( wDlg.exec() ) {
// Set parameters;
nUpDownMorphAmplitude = wSliderUDLRStrength.value;
nUpDownDamp = wSliderUDLRDampingRatio.value/100; // 2nd peak / 1st peak
nUpDownNumberOfFrames = wSliderUDLRNoF.value; // number of frames per period
nUpDownNumberOfPeriods = wSliderUDLRNoP.value + 1; // number of periods to vibrate

nRightLeftMorphAmplitude = wSliderUDLRStrength.value;
nRightLeftDamp = wSliderUDLRDampingRatio.value/100; // 2nd peak / 1st peak
nRightLeftNumberOfFrames = wSliderUDLRNoF.value; // number of frames per period
nRightLeftNumberOfPeriods = wSliderUDLRNoP.value; // number of periods to vibrate

nForwardBackMorphAmplitude = wSliderFBStrength.value;
nForwardBackDamp = wSliderFBDampingRatio.value/100; // 2nd peak / 1st peak
nForwardBackNumberOfFrames = wSliderFBNoF.value; // number of frames per period
nForwardBackNumberOfPeriods = wSliderFBNoP.value + 1; // number of periods to vibrate

nMovingAveFrames = wSliderMovingAve.value + 1;
vGravity = DzVec3(0,wSliderGravity.value*100/900,0);

// Set parameters to morph dials
document.addEventListener('readystatechange', function() {
if (document.readyState === "complete") {
init();
}
Scene.setFrame(0);
oObject.findModifier(cDialNameUDLRAmplitude).getValueChannel().setValue(wSliderUDLRStrength.value);
oObject.findModifier(cDialNameUDLRDampingRatio).getValueChannel().setValue(wSliderUDLRDampingRatio.value);
oObject.findModifier(cDialNameUDLRNoF).getValueChannel().setValue(wSliderUDLRNoF.value);
oObject.findModifier(cDialNameUDLRNoP).getValueChannel().setValue(wSliderUDLRNoP.value);
oObject.findModifier(cDialNameFBAmplitude).getValueChannel().setValue(wSliderFBStrength.value);
oObject.findModifier(cDialNameFBDampingRatio).getValueChannel().setValue(wSliderFBDampingRatio.value);
oObject.findModifier(cDialNameFBNoF).getValueChannel().setValue(wSliderFBNoF.value);
oObject.findModifier(cDialNameFBNoP).getValueChannel().setValue(wSliderFBNoP.value);
oObject.findModifier(cDialNameMovingAve).getValueChannel().setValue(wSliderMovingAve.value);
oObject.findModifier(cDialNameGravity).getValueChannel().setValue(wSliderGravity.value);

// Start Main process
fMain();
Scene.setFrame(0);
// Display finish dialog
if( MessageBox.question( qsTr("Simulation complete."), qsTr("Breast Physics"), qsTr("&Run"), qsTr("&Finish") ) == 0 ){
Scene.play();
}
}
else
{
MessageBox.information( "Process aborted by user.", "Breasts Physics", "&OK" );
}
}

// ================= Main Routine ===================
function fMain() {
//const nMovingAveFrames = 2;
//const vGravity = DzVec3(0,980/900,0);

const sUpDownRMorph = "1 R Move UpDown";
const sUpDownLMorph = "1 L Move UpDown";
const sUpDownAdjustRMorph = "1 R Rotate UpDown";
const sUpDownAdjustLMorph = "1 L Rotate UpDown";

const sRightLeftRMorph = "2 R Move Side2Side";
const sRightLeftLMorph = "2 L Move Side2Side";
const sRightLeftAdjustRMorph = "2 R Rotate Side2Side";
const sRightLeftAdjustLMorph = "2 L Rotate Side2Side";

const sForwardBackRMorph = "!Breast Diameter" //"!TogetherApart";//"3 R Depth";
const sForwardBackLMorph = "!Breast Diameter" //"!TogetherApart";//"3 L Depth";
const sForwardBackAdjustMorph = "!TogetherApart";

var qRot=[];

var vRPos=[];
var vRVel=[];
var vRAcc=[];
var vRAccLocal=[];
var vRAccLocalAve=[];

var vLPos=[];
var vLVel=[];
var vLAcc=[];
var vLAccLocal=[];
var vLAccLocalAve=[];

var nRUpDownShiftValue=[];
var nLUpDownShiftValue=[];
var nRRightLeftShiftValue=[];
var nLRightLeftShiftValue=[];
var nRForwardBackShiftValue=[];
var nLForwardBackShiftValue=[];

var oNode = Scene.getPrimarySelection();
var oSkel = oNode.getSkeleton();
var oChest = oSkel.findNodeChild("chestLower", true);
var oRPect = oSkel.findNodeChild("rPectoral", true);
var oLPect = oSkel.findNodeChild("lPectoral", true);

const pUpDownRMorph = oSkel.findPropertyByLabel(sUpDownRMorph);
const pUpDownLMorph = oSkel.findPropertyByLabel(sUpDownLMorph);
const pUpDownAdjustRMorph = oSkel.findPropertyByLabel(sUpDownAdjustRMorph);
const pUpDownAdjustLMorph = oSkel.findPropertyByLabel(sUpDownAdjustLMorph);
const pRightLeftRMorph = oSkel.findPropertyByLabel(sRightLeftRMorph);
const pRightLeftLMorph = oSkel.findPropertyByLabel(sRightLeftLMorph);
const pRightLeftAdjustRMorph = oSkel.findPropertyByLabel(sRightLeftAdjustRMorph);
const pRightLeftAdjustLMorph = oSkel.findPropertyByLabel(sRightLeftAdjustLMorph);
const pForwardBackRMorph = oObject.findModifier(sForwardBackRMorph); // Modifier in G3F version
const pForwardBackLMorph = oObject.findModifier(sForwardBackLMorph); // Modifier in G3F version
//const pForwardBackAdjustMorph = oSkel.findPropertyByLabel(sForwardBackAdjustMorph);

const cLastFrame = Scene.getAnimRange().end / Scene.getTimeStep();

if(oChest) {
//startProgress( "Simulation in progress...", cLastFrame, false, true );
// Get position
for(var n=0; n < cLastFrame+1; n++) {
// Proceed to Nth frame
Scene.setFrame(n);
// WS coordinates
qRot[n] = oChest.getWSRot();
vRPos[n] = oRPect.getWSPos();
vLPos[n] = oLPect.getWSPos();
}
// Velocity
for(var n=0; n < cLastFrame+1; n++) {
if(n<1){
vRVel[n]=DzVec3[0,0,0];
vLVel[n]=DzVec3[0,0,0];
}
else{
vRVel[n]=vRPos[n].subtract(vRPos[n-1]);
vLVel[n]=vLPos[n].subtract(vLPos[n-1]);
}
}

// Global accelaration in local coordinate system
for(var n=0; n < cLastFrame+1; n++){
if(n<2){
vRAcc[n]=DzVec3(0,0,0);
vLAcc[n]=DzVec3(0,0,0);
}
else{
vRAcc[n]=vRVel[n].subtract(vRVel[n-1]);
vLAcc[n]=vLVel[n].subtract(vLVel[n-1]);
}
vRAcc[n]=vRAcc[n].add(vGravity);
vLAcc[n]=vLAcc[n].add(vGravity);
qInv=qRot[n].inverse();
vRAccLocal[n]=qInv.multVec(vRAcc[n]);
vLAccLocal[n]=qInv.multVec(vLAcc[n]);
vRAccLocal[n]=vRAccLocal[n].subtract(vGravity);
vLAccLocal[n]=vLAccLocal[n].subtract(vGravity);
}

// ====Moving Average====
for(var n=0; n < cLastFrame+1; n++) {
var vRTotal = new DzVec3(0,0,0);
var vLTotal = new DzVec3(0,0,0);
var vCounter = new DzVec3(0,0,0);
var vInc = new DzVec3(1,1,1);
for(var nTime=-(nMovingAveFrames-1); nTime < 1; nTime++) {
if(n+nTime >= 0) {
vRTotal=vRTotal.add(vRAccLocal[n + nTime]);
vLTotal=vLTotal.add(vLAccLocal[n + nTime]);
vCounter=vCounter.add(vInc);
}
}
vRAccLocalAve[n] = vRTotal.divide(vCounter);
vLAccLocalAve[n] = vLTotal.divide(vCounter);
}

// Initialize Shape Shift Array
for(var n=0; n < cLastFrame+1; n++){
nRUpDownShiftValue[n]=0;
nLUpDownShiftValue[n]=0;
nRRightLeftShiftValue[n]=0;
nLRightLeftShiftValue[n]=0;
nRForwardBackShiftValue[n]=0;
nLForwardBackShiftValue[n]=0;
}

// Calculate Shape Shift values for each frame
for(var n=0; n < cLastFrame+1; n++) {
//Up Down oscillation
for(var nTime=0; nTime < (nUpDownNumberOfFrames * nUpDownNumberOfPeriods) +1; nTime++) {
if(n+nTime < cLastFrame+1) {
nRUpDownShiftValue[n + nTime] += UpDownOscillation(nTime) * (vRAccLocalAve[n].y) * (-1);
nLUpDownShiftValue[n + nTime] += UpDownOscillation(nTime) * (vLAccLocalAve[n].y) * (-1);
}
}
//Right Left oscillation
for(var nTime=0; nTime < (nRightLeftNumberOfFrames * nRightLeftNumberOfPeriods)+1; nTime++) {
if(n+nTime < cLastFrame+1) {
nRRightLeftShiftValue[n + nTime] += RightLeftOscillation(nTime) * vRAccLocalAve[n].x * (-1);
nLRightLeftShiftValue[n + nTime] += RightLeftOscillation(nTime) * vLAccLocalAve[n].x * (-1);
}
}
//Forward Back oscillation
for(var nTime=0; nTime < (nForwardBackNumberOfFrames * nForwardBackNumberOfPeriods)+1; nTime++) {
if(n+nTime < cLastFrame+1) {
nRForwardBackShiftValue[n + nTime] += ForwardBackOscillation(nTime) * vRAccLocalAve[n].z * (-1);
nLForwardBackShiftValue[n + nTime] += ForwardBackOscillation(nTime) * vLAccLocalAve[n].z * (-1);
}
}
}

// set limit to Shape Shift value
const cMaxUpDown = 0.8;
const cMinUpDown = -0.6;
const cMaxRightLeft = 0.4;
const cMinRightLeft = -0.4;
const cMaxForwardBack = 0.3;
const cMinForwardBack = -0.3;
// Get the max and min value
nMaxRUpDown = 0; nMinRUpDown =0; nMaxLUpDown = 0; nMinLUpDown =0;
nMaxRRightLeft = 0; nMinRRightLeft =0; nMaxLRightLeft = 0; nMinLRightLeft =0;
nMaxRForwardBack = 0; nMaxLForwardBack = 0; nMinRForwardBack = 0; nMinLForwardBack = 0;
for (var n=0; n < cLastFrame+1; n++) {
nMaxRUpDown = Math.max(nRUpDownShiftValue[n],nMaxRUpDown);
nMinRUpDown = Math.min(nRUpDownShiftValue[n],nMinRUpDown);
nMaxLUpDown = Math.max(nLUpDownShiftValue[n],nMaxLUpDown);
nMinLUpDown = Math.min(nLUpDownShiftValue[n],nMinLUpDown);
nMaxRRightLeft = Math.max(nRRightLeftShiftValue[n],nMaxRRightLeft);
nMinRRightLeft = Math.min(nRRightLeftShiftValue[n],nMinRRightLeft);
nMaxLRightLeft = Math.max(nLRightLeftShiftValue[n],nMaxLRightLeft);
nMinLRightLeft = Math.min(nLRightLeftShiftValue[n],nMinLRightLeft);
nMaxRForwardBack = Math.max(nRForwardBackShiftValue[n],nMaxRForwardBack);
nMinRForwardBack = Math.min(nRForwardBackShiftValue[n],nMinRForwardBack);
nMaxLForwardBack = Math.max(nLForwardBackShiftValue[n],nMaxLForwardBack);
nMinLForwardBack = Math.min(nLForwardBackShiftValue[n],nMinLForwardBack);
}
// Lower the value
var nMaxUpDown = Math.max(nMaxRUpDown, nMaxLUpDown);
if (nMaxUpDown > cMaxUpDown) {
for (var n=0; n < cLastFrame+1; n++) {
if (nRUpDownShiftValue[n]>0){
nRUpDownShiftValue[n] = nRUpDownShiftValue[n] / nMaxUpDown * cMaxUpDown;
}
if (nLUpDownShiftValue[n]>0){
nLUpDownShiftValue[n] = nLUpDownShiftValue[n] / nMaxUpDown * cMaxUpDown;
}
}
}
var nMinUpDown = Math.min(nMinRUpDown, nMinLUpDown);
if (nMinUpDown < cMinUpDown) {
for (var n=0; n < cLastFrame+1; n++) {
if (nRUpDownShiftValue[n]<0){
nRUpDownShiftValue[n] = nRUpDownShiftValue[n] / nMinUpDown * cMinUpDown;
}
if (nLUpDownShiftValue[n]<0){
nLUpDownShiftValue[n] = nLUpDownShiftValue[n] / nMinUpDown * cMinUpDown;
}
}
}
var nMaxRightLeft = Math.max(nMaxRRightLeft, nMaxLRightLeft);
if (nMaxRightLeft > cMaxRightLeft) {
for (var n=0; n < cLastFrame+1; n++) {
if (nRRightLeftShiftValue[n]>0){
nRRightLeftShiftValue[n] = nRRightLeftShiftValue[n] / nMaxRightLeft * cMaxRightLeft;
}
if (nLRightLeftShiftValue[n]>0){
nLRightLeftShiftValue[n] = nLRightLeftShiftValue[n] / nMaxRightLeft * cMaxRightLeft;
}
}
}
var nMinRightLeft = Math.min(nMinRRightLeft, nMinLRightLeft);
if (nMinRightLeft < cMinRightLeft) {
for (var n=0; n < cLastFrame+1; n++) {
if (nRRightLeftShiftValue[n]<0){
nRRightLeftShiftValue[n] = nRRightLeftShiftValue[n] / nMinRightLeft * cMinRightLeft;
}
if (nLRightLeftShiftValue[n]<0){
nLRightLeftShiftValue[n] = nLRightLeftShiftValue[n] / nMinRightLeft * cMinRightLeft;
}
}
}
var nMaxForwardBack = Math.max(nMaxRForwardBack, nMaxLForwardBack);
if (nMaxForwardBack > cMaxForwardBack) {
for (var n=0; n < cLastFrame+1; n++) {
if (nRForwardBackShiftValue[n]>0){
nRForwardBackShiftValue[n] = nRForwardBackShiftValue[n] / nMaxForwardBack * cMaxForwardBack;
}
if (nLForwardBackShiftValue[n]>0){
nLForwardBackShiftValue[n] = nLForwardBackShiftValue[n] / nMaxForwardBack * cMaxForwardBack;
}
}
}
var nMinForwardBack = Math.min(nMinRForwardBack, nMinLForwardBack);
if (nMinForwardBack < cMinForwardBack) {
for (var n=0; n < cLastFrame+1; n++) {
if (nRForwardBackShiftValue[n]<0){
nRForwardBackShiftValue[n] = nRForwardBackShiftValue[n] / nMinForwardBack * cMinForwardBack;
}
if (nLForwardBackShiftValue[n]<0){
nLForwardBackShiftValue[n] = nLForwardBackShiftValue[n] / nMinForwardBack * cMinForwardBack;
}
}
}

// set morph
for(var n=0; n < cLastFrame+1; n++) {
Scene.setFrame(n)
// UpDown Morph
pUpDownRMorph.setValue(nUpDownMorphAmplitude * nRUpDownShiftValue[n]);
pUpDownLMorph.setValue(nUpDownMorphAmplitude * nLUpDownShiftValue[n]);
// RightLeft Morph
pRightLeftRMorph.setValue(nRightLeftMorphAmplitude * nRRightLeftShiftValue[n]);
pRightLeftLMorph.setValue(nRightLeftMorphAmplitude * nLRightLeftShiftValue[n]);
// ForwardBack Morph
pForwardBackRMorph.getValueChannel().setValue(nForwardBackMorphAmplitude * nRForwardBackShiftValue[n]); // Modifier in G3F version
pForwardBackLMorph.getValueChannel().setValue(nForwardBackMorphAmplitude * nLForwardBackShiftValue[n]); // Modifier in G3F version
}
}
}

function UpDownOscillation(value) {
return 0.5 * Math.exp(value/nUpDownNumberOfFrames*Math.log(nUpDownDamp)) * Math.sin(value/nUpDownNumberOfFrames*2*Math.PI);
}

function RightLeftOscillation(value) {
return 0.5 * Math.exp(value/nRightLeftNumberOfFrames*Math.log(nRightLeftDamp)) * Math.sin(value/nRightLeftNumberOfFrames*2*Math.PI);
}

function ForwardBackOscillation(value) {
return 0.1 * Math.exp(value/nForwardBackNumberOfFrames*Math.log(nForwardBackDamp)) * Math.sin(value/nForwardBackNumberOfFrames*2*Math.PI);
}

function fCreateDial(Name, Value, Min, Max) {
Scene.setFrame(0);
var newMorphDeltas = new DzMorphDeltas();
var newMorph = new DzMorph( newMorphDeltas );
oObject.addModifier (newMorph, -1);
var curModifier = oObject.getModifier(oObject.getNumModifiers()-1);
curModifier.setName( Name );
var curProperty = newMorph.getValueChannel();
curProperty.setValue( Value );
curProperty.setMin( Min );
curProperty.setMax( Max );
curProperty.setIsClamped ( true );
}

uhm.. @abad I thought you were talking about the script from JRod, but I see I'm wrong..

so the one you posted should be by masatok..

and in the same thread there's the first one by abother user as well.. not available anymore.. 🙂

and does this one require Breast Control and Breast Movement?

the original script is form Masako´s own... (Missing off this world..) Is a "dse", encrypted code, but... I have the key to open de Pandora´s box. 😀

@abad thanks for the info.. I need to try it someday..

and sorry but I'm from italy 😀 my nick is about this

https://redbavon.files.wordpress.com/2017/08/super-santos_vs_super-tele.jpg

one of the cheapest football ball we as kids used for years in the 90s, don't know if they do nowadays