[bestmomo]

Comme suite à la demande de anpton j'ai fait une nouvelle version du pack "articulation". Cette fois pour un axe et de multiples primitives. C'est le cas pour les volets. Le principe reste pratiquement le même avec une axe et ce script :

Code PHP:

////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                            //
//                               Articulation Multi Axe V 1.00                                  //
//                                                                                            //
////////////////////////////////////////////////////////////////////////////////////////////////
//                          Copyright (c) 2012 by Bestmomo Lagan                              //
////////////////////////////////////////////////////////////////////////////////////////////////
//   This program is free software: you can redistribute it and/or modify                     //
//    it under the terms of the GNU General Public License as published by                    //
//    the Free Software Foundation, either version 3 of the License, or                       //
//    (at your option) any later version.                                                     //
//                                                                                            //
//    Articulations is distributed WITHOUT ANY WARRANTY;                                      //
//    See the GNU General Public License for more details.                                    //
//                                                                                            //
//    To get a copy of the GNU General Public License, see <http://www.gnu.org/licenses/>.    //
////////////////////////////////////////////////////////////////////////////////////////////////

// -----------------------------------------------
//        Paramètres
// -----------------------------------------------

integer CANAL_SETUP   = -2253610;

// -----------------------------------------------
//        Etat par défaut
// -----------------------------------------------
default
{
    state_entry() {
        // Ecoute setup
        llListen(CANAL_SETUP + 1, "", NULL_KEY, "");
    }

    listen(integer channel, string name, key id, string message) {
        if(message == "DIE") llDie();
        else
            // Réponse à demande de position et rotation
            llSay(CANAL_SETUP, "SET@" + (string)llGetPos() + "@" + (string)llGetRot());
    }
} 

Un setup :

Code PHP:

////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                            //
//                              Articulation Multi Setup V 1.00                                 //
//                                                                                            //
////////////////////////////////////////////////////////////////////////////////////////////////
//                          Copyright (c) 2012 by Bestmomo Lagan                              //
////////////////////////////////////////////////////////////////////////////////////////////////
//   This program is free software: you can redistribute it and/or modify                     //
//    it under the terms of the GNU General Public License as published by                    //
//    the Free Software Foundation, either version 3 of the License, or                       //
//    (at your option) any later version.                                                     //
//                                                                                            //
//    Articulations is distributed WITHOUT ANY WARRANTY;                                      //
//    See the GNU General Public License for more details.                                    //
//                                                                                            //
//    To get a copy of the GNU General Public License, see <http://www.gnu.org/licenses/>.    //
////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////
//                           Parameters that you can change                                   //
////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////
//                Dont change code below unless you know what you do                          //
////////////////////////////////////////////////////////////////////////////////////////////////

// -----------------------------------------------
//        Variables de travail
// -----------------------------------------------
integer     i_canal_menu;
float       f_angle;

// Axe
vector      v_axe;

// -----------------------------------------------
//        Variables de paramétrage
// -----------------------------------------------
// Numéro de liaison de la prim
list        l_link;

// Position de l'axe
vector      v_centre_axe;

// Rotation des prims pour les deux états
list        l_r_rot_state_1;
list        l_r_rot_state_2;

// Position des prims pour les deux états
list        l_v_pos_state_1;
list        l_v_pos_state_2;

// Rotation des vecteurs tournants
rotation    r_vec_rot;

// -----------------------------------------------
//        Paramètres à ne pas toucher
// -----------------------------------------------
integer    CANAL_SETUP     = -2253610;

// -----------------------------------------------
//        Canal aléatoire
// -----------------------------------------------
integer genCanal() {
    return ~(integer)llFrand((float)DEBUG_CHANNEL);
}
// -----------------------------------------------
//        Gestion des menus
// -----------------------------------------------
// Envoi du menu à l'owner
set_menu(string texte, list menu) {
    llDialog(llGetOwner(), texte, menu, i_canal_menu);
}
// Menu de sélection des primtives
menu_prims() {
    list l = ["End"];
    set_menu("Click all primitives to be moved and \"End\" when it's done", l);
}
// Menu de réglage rotation
menu_setup() {
    set_menu("\nAdjust prims and click \"End\" if it's adjusted"
        , ["-1","End","+1","-5","< >","+5","-20","< >","+20","-90","< >","+90"]);
}

// -----------------------------------------------
//        Passage de position globale <-> locale
// -----------------------------------------------
vector global_to_local(vector position) {
    return (position - llGetRootPosition()) / llGetRootRotation();
}

// -----------------------------------------------
//        Passage de rotation globale <-> locale
// -----------------------------------------------
rotation rot_to_local(rotation rot) {
    return rot / llGetRootRotation();
}

// -----------------------------------------------
//        Paramètres primitive
// -----------------------------------------------
set_texte(integer id, vector col) {
    llSetLinkPrimitiveParamsFast(id, [PRIM_TEXT, "Selected", <1,1,1>, 1]);
}
unset_texte(integer id) {
    llSetLinkPrimitiveParamsFast(id, [PRIM_TEXT, "", <0,0,0>, 0]);
}
vector get_pos(integer id) {
    return llList2Vector(llGetLinkPrimitiveParams(id, [PRIM_POS_LOCAL]), 0);
}
rotation get_rot(integer id) {
    return llList2Rot(llGetLinkPrimitiveParams(id, [PRIM_ROT_LOCAL]), 0);
}

// -----------------------------------------------
//        Sauvegardes informations
// -----------------------------------------------
save_infos() {
    string s = "Copy all informations between lines into a notecard called \"articulation\"\n"
        + "---------------------------------------------------------------------------------------------------------\n"
        + (string) v_centre_axe + "@" + (string)r_vec_rot;
    integer n = llGetListLength(l_link);
    while(n--) {
        s += "\n"
            + (string)llList2Integer(l_link, n)
            + "@" + (string)llList2Vector(l_v_pos_state_1, n)
            + "@" + (string)llList2Vector(l_v_pos_state_2, n)
            + "@" + (string)llList2Rot(l_r_rot_state_1, n)
            + "@" + (string)llList2Rot(l_r_rot_state_2, n);
    }
    s += "\n---------------------------------------------------------------------------------------------------------\n";
    llOwnerSay(s);
}

// -----------------------------------------------
//        Récupération des infos de l'axe
// -----------------------------------------------
default
{
    state_entry() {
        llOwnerSay(llGetScriptName() + " ready.");
        llSetText("Setup in progess...", <1,1,1>, 1);
        // Ecoute pour l'axe
        llListen(CANAL_SETUP, "", NULL_KEY, "");
        // Message à l'axe
        llSay(CANAL_SETUP + 1, "ASK");
        llSetTimerEvent(3.0);
    }

    listen(integer channel, string name, key id, string message) {
        // Réception messages de l'axe
        list l = llParseString2List(message, ["@"], []);
        // Récupération des données de l'axe
        if(llList2String(l, 0) == "SET") {
            vector v_centre_global = (vector)llList2String(l, 1);
            rotation r_global = (rotation)llList2String(l, 2);
            v_centre_axe = global_to_local(v_centre_global);
            rotation r_local = rot_to_local(r_global);
            v_axe = llVecNorm(v_centre_axe + <.0,.0,1.0> * r_local  - v_centre_axe);
            state prims;
        }
    }

    timer() {
        llSetTimerEvent(3.0);
        llOwnerSay("No axis !");
        // Message à l'axe
        llSay(CANAL_SETUP + 1, "ASK");
    }

    state_exit() {
        llSetTimerEvent(.0);
    }
}

// -----------------------------------------------
//        Définition des prims
// -----------------------------------------------
state prims
{
    state_entry() {
        // Canal pour le menu
        i_canal_menu = genCanal();
        // Ecoute pour le menu
        llListen(i_canal_menu, "", llGetOwner(), "");
        // Menu
        menu_prims();
    }

    listen(integer channel, string name, key id, string message) {
        if(message == "End") {
            if(llGetListLength(l_link))
                state etats;
            else {
                llOwnerSay("You must select at least one prim !");
                menu_prims();
            }
        }
    }

    touch_start(integer total_number) {
        integer id = llDetectedLinkNumber(0);
        // On ne doit pas prendre le root ni deux fois la même primitive !
        if(id != 1 && llListFindList(l_link, [id]) == -1) {
            set_texte(id, <1,1,1>);
            // Mémorisation des informations
            l_link += id;
            l_v_pos_state_1 += get_pos(id);
            l_r_rot_state_1 += get_rot(id);
        }
    }
}

// -----------------------------------------------
//        Réglage du deuxième état
// -----------------------------------------------
state etats
{
    state_entry() {
        // Canal pour le menu
        i_canal_menu = genCanal();
        // Ecoute pour le menu
        llListen(i_canal_menu, "", llGetOwner(), "");
        // Menu
        menu_setup();
    }

    listen(integer channel, string name, key id, string message) {
        // Réception messages des menus
        if(channel == i_canal_menu) {
            // Touche neutre
            if(message == "< >" || message == " ") menu_setup();
            // Fin du réglage
            else if(message == "End") {
                // Mémorisation état 2
                integer i;
                integer n = llGetListLength(l_link);
                for(; i < n; ++i) {
                    integer id_link = llList2Integer(l_link, i);
                    l_v_pos_state_2 += get_pos(id_link);
                    l_r_rot_state_2 += get_rot(id_link);
                }
                // Effacement des textes flottants
                unset_texte(1);
                while(n--) unset_texte(llList2Integer(l_link, n));
                // Destruction de l'axe
                llSay(CANAL_SETUP + 1, "DIE");
                // Enregistrement des informations
                save_infos();
                // Fin
                llOwnerSay("Drop \"Articulation action\" script in object inventory");
                llRemoveInventory(llGetScriptName());
            }
            // Réglage en cours
            else {
                float f_valeur = (float)message;
                f_angle += f_valeur;
                r_vec_rot = llAxisAngle2Rot(v_axe, f_angle * DEG_TO_RAD);
                integer n = llGetListLength(l_link);
                // Mise en mouvement global
                while(n--) {
                    integer id_link = llList2Integer(l_link, n);
                    vector v_tournant = llList2Vector(l_v_pos_state_1, n) - v_centre_axe;
                    llSetLinkPrimitiveParamsFast(id_link, [
                        PRIM_POSITION, v_centre_axe + v_tournant * r_vec_rot,
                        PRIM_ROT_LOCAL, llList2Rot(l_r_rot_state_1, n) * r_vec_rot]);
                }
                menu_setup();
            }
        }
    }
} 

Il suffit de positionner l'axe, de mettre le setup dans le root. Un menu apparaît et vous devez cliquer sur toutes les primitives concernées par le mouvement. Quand c'est fait vous cliquez sur le bouton "End", apparaît alors le menu pour le réglage. Quand c'est fini on demande de créer une notecard "articulation" avec les paramètres générés. Un truc comme ça :

<-0.75537, 0.00738, 0.13965>@<-0.00000, -0.17365, -0.00000, 0.98481>
2@<0.00000, 0.00000, 0.13057>@<-0.04245, 0.00000, 0.38947>@<0.00000, 0.00000, 0.00000, 1.00000>@<0.00000, -0.17365, 0.00000, 0.98481>
3@<0.00000, 0.75510, 0.14360>@<-0.04691, 0.75510, 0.40171>@<0.00000, 0.00000, 0.00000, 1.00000>@<0.00000, -0.17365, 0.00000, 0.98481>
4@<0.00000, 0.25510, 0.14360>@<-0.04691, 0.25510, 0.40171>@<0.00000, 0.00000, 0.00000, 1.00000>@<0.00000, -0.17365, 0.00000, 0.98481>
5@<0.00000, -0.24400, 0.14360>@<-0.04691, -0.24400, 0.40171>@<0.00000, 0.00000, 0.00000, 1.00000>@<0.00000, -0.17365, 0.00000, 0.98481>
6@<0.00000, -0.74400, 0.14360>@<-0.04691, -0.74400, 0.40171>@<0.00000, 0.00000, 0.00000, 1.00000>@<0.00000, -0.17365, 0.00000, 0.98481>

Il faut mettre la note dans le root accompagnée de ce script :

Code PHP:

////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                            //
//                              Articulation Multi Action V 1.01                                //
//                                                                                            //
////////////////////////////////////////////////////////////////////////////////////////////////
//                          Copyright (c) 2012 by Bestmomo Lagan                              //
////////////////////////////////////////////////////////////////////////////////////////////////
//   This program is free software: you can redistribute it and/or modify                     //
//    it under the terms of the GNU General Public License as published by                    //
//    the Free Software Foundation, either version 3 of the License, or                       //
//    (at your option) any later version.                                                     //
//                                                                                            //
//    Articulations is distributed WITHOUT ANY WARRANTY;                                      //
//    See the GNU General Public License for more details.                                    //
//                                                                                            //
//    To get a copy of the GNU General Public License, see <http://www.gnu.org/licenses/>.    //
////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////
//                           Parameters that you can change                                   //
////////////////////////////////////////////////////////////////////////////////////////////////

// Time
float       TIME            = 2;        // Transition time in seconds
integer     AUTO            = FALSE;    // TRUE for loop mode
float       RETURNTIME      = 0;        // Time for auto return to first position (0 for no auto-return)
integer     API             = FALSE;    // True for only API

// Access
string      ACCESS          = "All";    // Access must be "All", "Group", "Owner" or "List"
list        ACCESSLIST      = [];       // Access names list if ACCESS is on "List"

// Sounds
string      SECONDSOUND     = "none";   // Sound for second position ("none" if none)
string      FIRSTSOUND      = "none";   // Sound for first position ("none" if none)

// Sensor
float       SENSOR_RANGE    = 0;        // Sensor range (0 for none), no touch action if sensor
float       SENSOR_DELAY    = 4;        // Sensor delay (no matter if no sensor)

// Messages
string      ACCESSMESSAGE   = "Sorry but your are not allowed to command this object";
string      CLICKMESSAGE    = "Come closer to command this object";

// API
integer     API_CLICK       = 211;      // Like a "click"
integer     API_AUTO_START  = 212;      // Start in "auto" mode
integer     API_AUTO_STOP   = 213;      // Stop in "auto" mode
integer     API_GO_POS_1    = 214;      // Go to first position
integer     API_GO_POS_2    = 215;      // Go to second  position
integer     API_GET_POS     = 216;      // To get position
integer     API_POS_ANSWER  = 217;      // POsition answer

////////////////////////////////////////////////////////////////////////////////////////////////
//                Dont change code below unless you know what you do                          //
////////////////////////////////////////////////////////////////////////////////////////////////

// -----------------------------------------------
//        Variables de paramétrage
// -----------------------------------------------
// Numéro de liaison de la prim
list        l_link;

// Position de l'axe
vector      v_centre_axe;

// Rotation des prims pour les deux états
list        l_r_rot_state_1;
list        l_r_rot_state_2;

// Position des prims pour les deux états
list        l_v_pos_state_1;
list        l_v_pos_state_2;

// Rotation des vecteurs tournants
rotation    r_vec_rot;

// -----------------------------------------------
//        Paramètres à ne pas toucher
// -----------------------------------------------
float      TEMPS_BASE    = .04;
string     NOTECONFIG   = "articulation";

// -----------------------------------------------
//        Paramètres primitive
// -----------------------------------------------
vector get_pos(integer id) {
    return llList2Vector(llGetLinkPrimitiveParams(id, [PRIM_POS_LOCAL]), 0);
}

// -----------------------------------------------
//        Variables de travail
// -----------------------------------------------
integer     i_auto;

// Pour lecture note
integer     iStep;
key            kQuery;
integer        iNotecardLine;

// -----------------------------------------------
//        Fonctions pour lecture de la note
// -----------------------------------------------

// Fonction qui lance la lecture de la note de configuration si présente
read_config() {
    if(llGetInventoryType(NOTECONFIG) == INVENTORY_NOTECARD) {
        kQuery = llGetNotecardLine(NOTECONFIG, iNotecardLine++);
        llWhisper(0, "Reading notecard \"" + NOTECONFIG + "\"...");
    }
}

// Traitement de la note
integer traite_note(string data) {
    if (data != EOF) {
        if(llGetSubString(data, 0, 1) != "//" && data != "" && data != " ") {
            list l = llParseString2List(data, ["@"], []);
            if(iStep++) {
                l_link += (integer)llList2String(l, 0);
                l_v_pos_state_1 += (vector)llList2String(l, 1);
                l_v_pos_state_2 += (vector)llList2String(l, 2);
                l_r_rot_state_1 += (rotation)llList2String(l, 3);
                l_r_rot_state_2 += (rotation)llList2String(l, 4);
            }
            else {
                v_centre_axe = (vector)llList2String(l, 0);
                r_vec_rot = (rotation)llList2String(l, 1);
            }
        }
        kQuery = llGetNotecardLine(NOTECONFIG, iNotecardLine++);
        return FALSE;
    }
    else return TRUE;
}

// -----------------------------------------------
//        Test d'accès
// -----------------------------------------------
integer test_access(key id) {
    if(ACCESS == "List" && ~llListFindList(ACCESSLIST, [llKey2Name(id)])) return TRUE;
    else if(ACCESS == "Owner" && llGetOwner() == id) return TRUE;
    else if(ACCESS == "Group" && llSameGroup(id)) return TRUE;
    else if(ACCESS == "All") return TRUE;
    else return FALSE;
}

// -----------------------------------------------
//        Interpolation
// -----------------------------------------------
rotation r_cos(rotation r0, rotation r1, float t){
    float f = (1 - llCos(t * PI)) / 2;
    float f_ang = llAngleBetween(r0, r1);
    if(f_ang > PI) f_ang -= TWO_PI;
    return r0 * llAxisAngle2Rot(llRot2Axis(r1 / r0) * r0, f_ang * f);
}

// -----------------------------------------------
//        Transition
// -----------------------------------------------
transition(integer i_back) {
    float f_step = 1.0 / (TIME / TEMPS_BASE);
    float step;
    while((step += f_step) <= 1.0) {
        integer n = llGetListLength(l_link);
        integer i;
        rotation r;
        list l_params;
        for(; i < n; ++i) {
            if(i_back) r = r_cos(r_vec_rot, ZERO_ROTATION, step);
            else r = r_cos(ZERO_ROTATION, r_vec_rot, step);
            vector v_tournant = llList2Vector(l_v_pos_state_1, i) - v_centre_axe;
            vector pos = v_centre_axe + v_tournant * r;
            if(i) l_params += [PRIM_LINK_TARGET, llList2Integer(l_link, i)];
            l_params += [PRIM_POSITION, pos, PRIM_ROT_LOCAL, llList2Rot(l_r_rot_state_1, i) * r];
        }
        llSetLinkPrimitiveParamsFast(llList2Integer(l_link, 0), l_params);
        llSleep(TEMPS_BASE);
    }
}

// -----------------------------------------------
//        Manoeuvre de l'objet
// -----------------------------------------------
// Test de première position
integer test_first() {
    return get_pos(llList2Integer(l_link, 0)) == llList2Vector(l_v_pos_state_1, 0);
}

// Test de seconde position
integer test_second() {
    return get_pos(llList2Integer(l_link, 0)) == llList2Vector(l_v_pos_state_2, 0);
}

// Manoeuvre sur clic
action_click() {
    // Vers second
    if(test_first()) {
        go_second();
    }
    // vers premier
    else if(test_second()) {
        if(RETURNTIME == .0) go_first();
    }
    // Cas où il y a eu une modification de build
    else {
        llSetText("", ZERO_VECTOR, 0);
        llResetScript();
    }
}

// Passage en seconde position
go_second() {
    transition(FALSE);
    // Fixation de l'état
    integer n = llGetListLength(l_link);
    while(n--) {
        llSetLinkPrimitiveParamsFast(llList2Integer(l_link, n), [
            PRIM_POSITION, llList2Vector(l_v_pos_state_2, n),
            PRIM_ROT_LOCAL, llList2Rot(l_r_rot_state_2, n)]);
    }
    if(SECONDSOUND != "none") llTriggerSound(SECONDSOUND, 1.0);
    else if(RETURNTIME != .0 && SENSOR_RANGE == .0 && !AUTO) llSetTimerEvent(RETURNTIME);
}

// Passage en première position
go_first() {
    transition(TRUE);
    // Fixation de l'état
    integer n = llGetListLength(l_link);
    while(n--) {
        llSetLinkPrimitiveParamsFast(llList2Integer(l_link, n), [
            PRIM_POSITION, llList2Vector(l_v_pos_state_1, n),
            PRIM_ROT_LOCAL, llList2Rot(l_r_rot_state_1, n)]);
    }
    if(FIRSTSOUND != "none") llTriggerSound(FIRSTSOUND, 1.0);
}

// -----------------------------------------------
//        Etat d'initialisation
// -----------------------------------------------
default {
    state_entry() {
        llWhisper(0, "Looking for notecard \"" + NOTECONFIG + "\"...");
        read_config();
    }

    dataserver(key id, string data)    {
        if(kQuery == id) {
            if(traite_note(data))
                state marche;
        }
    }

    changed(integer change) {
        if(change & CHANGED_INVENTORY) read_config();
    }
}
// -----------------------------------------------
//        Etat de fonctionnement
// -----------------------------------------------
state marche
{
    state_entry() {
        llWhisper(0, "Notecard \"" + NOTECONFIG + "\" read. All is OK.");
        // Retour en première position
        integer n = llGetListLength(l_link);
        while(n--) {
            llSetLinkPrimitiveParamsFast(llList2Integer(l_link, n), [
                PRIM_POSITION, llList2Vector(l_v_pos_state_1, n),
                PRIM_ROT_LOCAL, llList2Rot(l_r_rot_state_1, n)]);
        }
        // Sensor éventuel
        if(SENSOR_RANGE != .0 && !API) llSensorRepeat("", NULL_KEY, AGENT, SENSOR_RANGE, PI, SENSOR_DELAY);
        // Marche automatique
        if(AUTO) {
            i_auto = TRUE;
            llSetTimerEvent(.01);
        }
    }

    touch_start(integer total_number) {
        // On vérifie que le clic se fait sur une prim qui doit bouger
        if(~llListFindList(l_link, [llDetectedLinkNumber(0)]) && !API) {
            key k = llDetectedKey(0);
            if(test_access(k)) {
                if(SENSOR_RANGE == .0) action_click();
                else if(test_first()) llInstantMessage(k, CLICKMESSAGE);
            }
            else llInstantMessage(k, ACCESSMESSAGE);
        }
    }

    sensor(integer total_number) {
        // Gestion si objet en première position
        if(test_first()) {
            // Test de personnes autorisées
            while(total_number--) if(test_access(llDetectedKey(total_number))) {
                go_second();
                return;
            }
            // Si personne autorisée on met en seconde si première
            else if(test_second()) go_first();
        }
    }

    no_sensor() {
        // Si personne on met en première
        if(test_second()) go_first();
    }

    link_message(integer sender_number, integer number, string message, key id) {
        if(number == API_CLICK && SENSOR_RANGE == .0) action_click();
        else if(number == API_GO_POS_1) go_first();
        else if(number == API_GO_POS_2) go_second();
        else if(number == API_GET_POS) {
            llMessageLinked(LINK_THIS, API_POS_ANSWER, (string)test_second(), NULL_KEY);
        }
        else if(AUTO) {
            if(number == API_AUTO_START) {
                i_auto = TRUE;
                llSetTimerEvent(.01);
            }
            else if(number == API_AUTO_STOP) i_auto = FALSE;
        }
    }

    timer() {
        llSetTimerEvent(.0);
        if(AUTO) {
            if(i_auto) {
                if(test_first()) go_second();
                else go_first();
                llSetTimerEvent(.01);
            }
        }
        else go_first();
    }
} 

Et ça fonctionne comme pour les versions précédentes avec les mêmes paramètres.

Maintenant pour faire fonctionner les volets il faut évidemment faire tous les setups en commençant par celui-ci (parce qu'il manipule les textes flottants et du coup on perdrait les autres setup). Et après il faut utiliser les API. J'ai d'ailleurs mis à jour le script "action" (V 1.03) de l'autre version de "articulations" pour enrichir l'API. Mais j'expliquerai ça dans un prochain post .

[black cats]

Mais dites moi, dites moi, jusqu'où s'arrêtera-t-il ?
Tu as mangé du lion, dis donc ?
Ton degré d'activité m'impressionne

[anpton]

Quand je vois votre degrés d'implication et de réactivité à tous les deux, Bestmomo encore une fois pour cette histoire de volets et après tant de solutions apportées et Black Cats, lui aussi pour toute l'aide qu'il apporte ici et aussi pour notre projet commun de Trebuchet 100% fonctionnel, je pense que vous êtes pareils, des passionnés, toujours à vouloir repousser les limites.

Franchement je suis super impressionné et je me dis que les mondes virtuels valent vraiment la peine d'être vécus, pour la qualité des rencontres qu'on y fait...

[bestmomo]

Pour les volets :

• faire le setup avec le système "articulation multi" de ce fil avec comme position 1 la fermeture. Garder la notecard ou la mettre dans le root mais ne pas mettre encore le script d'action pour éviter d'avoir tout qui bouge pour les setup suivants
• faire les deux setup avec le système "articulation" du fil précédent (bien prendre la version 1.03 pour avoir l'API à jour) avec comme position 1 la fermeture, un pour chaque demi-volet, ne pas mettre encore les scripts d'action
• mettre le script d'action pour le multi en changeant ce paramètre :
  

integer API = TRUE; // True for only API

• mettre les deux scripts pour les articulations "normales" et changer le même paramètre d'API dans les deux scripts
  

Dans cette situation on a encore rien qui marche, le fait de mettre l'API à TRUE rend le script dépendant d'un autre script, il devient en quelque sorte esclave. Voilà le script qui va servir à commander tout ça :

Code PHP:

// -----------------------------------------------
//        Variables
// -----------------------------------------------
integer     canalMenu;
integer     ecouteMenu;
key         id_ava;
integer     i_grand;
integer     i_petit;
integer     i_step;

// -----------------------------------------------
//        Gestion de l'écoute du menu
// -----------------------------------------------
updateEcoute(key id) {
    cancelEcoute();
    canalMenu = genCanal();
    ecouteMenu = llListen(canalMenu, "", id, "");
    llSetTimerEvent(60.0);
}
cancelEcoute() {
    if(ecouteMenu > 0) {
        llListenRemove(ecouteMenu);
        ecouteMenu = 0;
        llSetTimerEvent(.0);}
}
endMenu() {
    llSetTimerEvent(.0);
    llOwnerSay("Time for dialog has expired, click again for use...");
}
setMenu() {
    list l;
    if(i_petit) l += "Fermer petit";
    else if(i_grand) l += "Fermer grand";
    else l += ["Ouvrir petit","Ouvrir grand"];
    updateEcoute(id_ava);
    llDialog(id_ava, "Choisir une option", l, canalMenu);
}
// -----------------------------------------------
//        Canal aléatoire
// -----------------------------------------------
integer genCanal() {
    return ~(integer)llFrand((float)DEBUG_CHANNEL);
}
// -----------------------------------------------
//        Etat par défaut
// -----------------------------------------------
default
{
    touch_start(integer total_number) {
        id_ava = llDetectedKey(0);
        i_step = 0;
        llMessageLinked(LINK_THIS, 116, "", NULL_KEY);
    }

    link_message(integer sender_number, integer number, string message, key id) {
        if(number == 117 && i_step == 0) {
            i_step++;
            i_grand = (integer)message;
            llMessageLinked(LINK_THIS, 216, "", NULL_KEY);
        }
        else if(number == 217 && i_step == 1) {
            i_step++;
            i_petit = (integer)message;
            setMenu();
        }
    }

    listen(integer channel, string name, key id, string message) {
        cancelEcoute();
        if(message == "Fermer petit") llMessageLinked(LINK_THIS, 214, "", NULL_KEY);
        else if(message == "Fermer grand") llMessageLinked(LINK_THIS, 114, "", NULL_KEY);
        else if(message == "Ouvrir petit") llMessageLinked(LINK_THIS, 215, "", NULL_KEY);
        else if(message == "Ouvrir grand") llMessageLinked(LINK_THIS, 115, "", NULL_KEY);
    }

    timer() {
        endMenu();
    }
} 

Bon c'est une trame qui fonctionne à arranger selon les besoins . J'ai pas trop sécurisé pour des clics multiples non plus.


PS : pour la culture générale API signifie Application Programming Interface, ce qui veut dire en bon Français Interface de programmation, c'est une façon de présenter une interface (un intermédiaire) pour commander un système, ici un script.

[anpton]

Waow !!! Ça fonctionne génialement bien

C'est fou ce qu'on se sent intelligent quand les explications sont claires.

Je reviens car il me semble qu'il y a un petit "bug" :

Je commence en faisant "ouvrir grand", ça fonctionne,
Ensuite je fais "fermer grand", ça fonctionne,
Puis "ouvrir petit", ça fonctionne,
Puis "fermer petit", ça fonctionne
Je refais "ouvrir grand" et là il n'y a qu'un côté qui ouvre (vert, bleu).

J'ai recommencé plusieurs fois, réinitialisé les scripts, toujours le même bug...

Bon je file casser une croûte et je retourne recommencer toute la manip de setup voir si c'est pas moi qui a merdé.

[bestmomo]

Citation :

Publié par anpton

Je reviens car il me semble qu'il y a un petit "bug" ...

Si ça marche une première fois pour la grande ouverture je ne vois pas pourquoi après ça ne marche plus . Tu as un bug un peu étrange que je n'ai pas rencontré personnellement en faisant des tas de manipulations avec les volets. Tu peux toujours tester tes setup individuellement en mettant des scripts d'actions sans activer l'API. Comme ça ils fonctionnent avec un clic.

Attention j'ai changer le mode opératoire du clic avec la dernière version, il faut maintenant cliquer sur les primitives qui doivent bouger, ça évite pour une maison avec plein de portes par exemple de tout ouvrir d'un coup . Mais l'inconvénient c'est qu'on a plus la synchronisation pour par exemple tes deux volets, à ce moment-là il faut utiliser l'API et se faire un petit script personnalisé.

[anpton]

Bon donc j'ai tout recommencé, en partant de zéro (avec des prims neuves pour être sur que plus rien ne traîne)...
Et j'arrive au même résultat, ça fonctionne avec les volets jusqu'à ce que j'ouvre "petit" et une fois "petit" refermé, il y a plus que le vert-bleu des volets qui s'ouvre.

J'ai fais des manips et des manips, relu ton explication... Rien à faire. Je reprendrais ça à tête reposée.

[bestmomo]

Normalement tu as 3 scripts d'action (2 normaux et un du multi) et dans chacun de ces scripts tu dois avoir changé la ligne de l'API pour avoir la valeur à TRUE. J'ai l'impression que tu en oublies un .

[anpton]

La ligne est à la valeur "TRUE" sur les 3 scripts d'action

[bestmomo]

Citation :

Publié par anpton

La ligne est à la valeur "TRUE" sur les 3 scripts d'action

Bon je comprends pas ce qui t'arrive, tu peux m'envoyer ton truc IW ? A bestmomo Lagan.

Edit : après réflexion je crois que j'ai compris ton problème. Dans le script je fais un test pour savoir si les primitives sont en position 1 ou 2. Avec un seul setup pas de souci mais avec plusieurs j'envisage deux possibilités :

1. pour le second setup les primitives n'ont pas été ramenées exactement dans la même position (et je dois peut-être changer le mode opératoire que j'avais fait en disant de mettre le premier script d'action pour ramener exactement les primitives, quitte à le retirer ensuite)
2. étant donné que j'arrondis un peu les valeurs pour les faire entrer dans le texte flottant pour le setup de l'articulation simple alors que je ne le fais pas pour l'articulation multi il s epeut qu'il y ait une petite différence de valeurs
   

Dans les deux cas le test échoue et les primitives ne bougent pas. Il faudrait que j'assouplisse mon test positionnel pour éviter ça .

Dans les scripts d'action change ces lignes et dis moi si ça fonctionne :

Code PHP:

// -----------------------------------------------
//        Manoeuvre de l'objet
// -----------------------------------------------
// Test de première position
integer test_first() {
    //return get_pos(llList2Integer(l_link, 0)) == llList2Vector(l_v_pos_state_1, 0);
    return llVecDist(get_pos(llList2Integer(l_link, 0)), llList2Vector(l_v_pos_state_1, 0)) < .01;
}

// Test de seconde position
integer test_second() {
    //return get_pos(llList2Integer(l_link, 0)) == llList2Vector(l_v_pos_state_2, 0);
    return llVecDist(get_pos(llList2Integer(l_link, 0)), llList2Vector(l_v_pos_state_2, 0)) < .01;
} 

[anpton]

Citation :

Publié par bestmomo

Dernière modification par bestmomo ; Aujourd'hui à 09h13.

Tu lâches pas l'affaire, toi ! Quand tu as un os à ronger... Tu es pourtant pas un chien !

Je m'y colle immédiatement et je te fais un rapport dans l'heure qui vient.

[anpton]

Bon, j'ai tout fait comme tu l'as indiqué (enfin je pense). Mais toujours le même soucis après une première séquence réussie, un seul côté "grand" continue de fonctionner (sauf que là c'est "rouge/jaune).

Je t'ai transmis une copie de mon ensemble de test.

Merci encore du temps que tu consacres.

[bestmomo]

Tu aurais dû m'envoyer ton truc plus tôt .

Puisque tu es méticuleux relis la phrase que j'avais mise avec du gras :

Spoiler : Cliquez ce bouton ou survolez le contenu pour afficher le spoiler

Vous pouvez faire plusieurs setup dans un même objet, comme dans mon exemple de cube où j'ai fait 4 setup. Il suffit de recommencer tout le scénario et de mettre un nouveau script d'action à la fin avec le même nom.

Tu as changé le nom du script d'action, le premier Action_V2 et le second Action_V2_1.

En mettant le script avec le même nom il s'indente automatiquement, par exemple si je prends action, j'aurai la suite :

• action
• action 1
• action 2
• ...
  

Et comme ça le script connait son index et ça fonctionne. C'est pour cette raison que tu as qu'une moitié de tes volets qui fonctionnent.


Mais il y a peut-être autre chose parce qu'en mettant mes scripts dans ton build je n'ai pas réussi à le faire fonctionner, je n'ai pas eu le temps de creuser cette affaire.

[anpton]

Donc, en fait, c'est ce matin que j'ai rajouté le tiret entre le nom et "1"...

Parce que j'ai relu ton topic et que comme tu dis "Important : le nom du script d'action ne doit pas comporter d'espace. Par exemple "mon script" ne va pas alors que "mon_script" est correct.". Je me suis dit que dans cet espace là pouvait poser problème...

[bestmomo]

Bon, après plein de tests j'ai trouvé la faille. En fait dans mon test j'ai une primitive qui bouge pas quand on ouvre en grand et elle servait de référence pour la position et masquait le défaut qui s'était glissé dans mon code.

Donc maintenant ça fonctionne mais il faut prendre toutes les nouvelles versions des scripts .

[anpton]

Nouvelles versions des scripts soigneusement archivées...

Je me sent pas de reconstruire un bazar ce soir, mais demain soir sans faute.

De toute manière j'ai une copie du proto testé et approuvé par le chef, donc.

[Elenia Boucher]

Tes scripts sont FA-BU-LEUX Bestmomo.

C'est très exactement ce dont j'avais besoin.

J'y serais arrivé sans je pense mais là en quelques clics c'est réglé.

Un grand merci.