Unterschied zwischen p_balg und V_balg

Hallo,

ich hätte eine Frage an die Entwickler; was ist der Unterschied zwischen p_balg und v_balg ind der Scriptdatei bremse.osc?
Desweiteren würde mich interessieren, was der Standartwert des p_balg und des v_balg wären. Vielsten Dank!

Gruß

Flo

V_balg ist das Volumen der jeweiligen Federbälge. Die genauen Volumina sind in der zugehörigen Constfile angegeben. P_balg ist der Druck im Federbalg, der in der Regel irgendwo zwischen 3 und ca. 5 bar liegt.

Gut, vielen Dank, weil ich verzweifelt versucht habe, den Druck zu ändern, aber immer nur das Volumen verändert habe.

Noch eine weitere Frage zum Syntax wenn es gestattet ist:

Wertezuweisen ist doch

Code:

1234 (variable)

und die If-Schleife funktioniert doch folgendermaßen : (?)

Code:

Bedingung 
{if}
Methode/Zuweisung  'wenn Bedingung True ist, dann das, was hier steht?
{else}
alternive Methode/Zuweisung  'wenn Bedingung False ist, dann das, was hier steht?
{endif}

Stimmt so, oder? Wenn nicht, bitte berichtigen. Werden im SDK auch die Trigger erklärt und die ganzen Events?

Gruß

Flo

zum speichern aber bitte

Code:

1234 (S.L.variable)

Ansonsten alles korrekt. Trigger und Soundevents werden im SDK genauer erläutert.

Jetzt muss ich doch nochmal nachfragen:

5 Bar entsprechen einem Attributwert von 5?

Und für was genau steht S.L.variable? Ist selbbige dann "Klassenübergreifend" ?

Die Werte im Script sind in Pa, also 500000 für 5 bar.

S.L. steht für "save local" und speichert den vorherigen Wert in die nachgestellte lokale Variable des Busses.

Eins muss ich noch wissen, dann bin ich glücklich

Bei der If-Bedingung ist der Vergleichsoperator dahintergestellt, richtig? Also so:

Code:

Wert1 Wert2 >

Wert1 Wert2 > ' Wert1 größer als Wert2 dann True
Wert1 Wert2 < ' Wert1 kleiner als Wert2 dann True
Wert1 Wert2 = ' Wert1 gleich Wert2 dann True
Wert1 Wert2 =! 'Wert1 ungleich Wert2 dann True
Wert1 Wert2 && ' ???
Wert1 Wert2 || ' ???

Könnteste evtl meinen Beitrag editieren, dann isses einfacher zum korigieren

Gruß

Flo

Der Vergleichsoperator ist, wie die anderen Operatoren auch, immer nachgestellt.

Wert1 Wert2 &&: AND-Verknüpfung: Wenn beide Werte größer Null, dann true
Wert1 Wert2 ||: OR-Verknüpfung: Wenn einer der Werte größer Null, dann true

Und nochmal ne Frage:

Ist das Script immer "geloopt", sodass man den Druck des Balgs langsam erniedrigen kann, so nach dem Motto:

Code:

(S.L.bremse_p_balg_1_R) 200 >
      {if}

      (S.L.bremse_p_balg_1_R) - 200 (S.L.bremse_p_balg_1_R)
      (S.L.bremse_p_balg_0_R) - 200 (S.L.bremse_p_balg_0_R)
      {endif}

Braucht man sonst noch iwas beachten?

Jedes Script wird einmal pro Frame durchlaufen. Soll also eine Bewegung langsam erfolgen, reicht es, in jedem Frame einen (zeitnormierten) Wert der Ursprungsgröße abzuziehen. Für die Zeitnormierung kannst du (L.S.Timegap) benutzen, was dir die Zeitspanne zwischen diesem und dem letzten Frame zurückgibt.

Wird eine Auflistung solcher Attribute auch im SDK Einzug finden?

Davon gehe ich mal schwerst aus

So, irgendwie blick ich das nochned ganz, habs versucht so zu machen, wie gesagt:

Code:

(L.L.bremse_halte)
   {if}
      (S.L.bremse_p_balg_1_R) 100 >
      {if}

      (S.L.bremse_p_balg_1_R) - (L.S.Timegap) * 100 (S.L.bremse_p_balg_1_R)
      (S.L.bremse_p_balg_0_R) - (L.S.Timegap) * 100 (S.L.bremse_p_balg_0_R)
      {endif}
{endif}

Das Script sollte bewirken, dass die Druckluft in den Bälgen rechts lansam abfällt - bisher ohne Erfolg. Habe ich irgendwo nen Syntax/Realtionsfehler?

Zitat :

(S.L.bremse_p_balg_1_R) - (L.S.Timegap) * 100 (S.L.bremse_p_balg_1_R)

Probier's mal mit
(L.L.bremse_p_balg_1_R) (L.S.Timegap) * 100 - (S.L.bremse_p_balg_1_R)

L.L = Local Leech?

Sozusagen, aber eigentlich "load local"

Nochmal zu deinem Script; Heißt das übersetzt so viel wie:

(L.L.bremse_p_balg_1_R) = (L.S.Timegap) * 1 - (S.L.bremse_p_balg_1_R)

?

Irgendwie durchsteige ich das ned ganz, ich meine unter S.L wird gespeichert, was aber in ner Subtraktion verbunden ist. Wird der wert dann unter L.L.bremse gespeichert? Liest man hier von rechts nach links?

Das Ganze ist wie gesagt umgekehrt-polnisch notiert. Heißt, der Operator steht immer hinten.

(L.L.bremse_p_balg_1_R) (L.S.Timegap) * 1 - (S.L.bremse_p_balg_1_R)

würde in anderen Sprachen so aussehen:

bremse_p_balg_1_R := bremse_p_balg_1_R - (Timegap*1)

Nochmal:
(L.L.bremse_p_balg_1_R) (L.S.Timegap) * 1 - (S.L.bremse_p_balg_1_R)
p_balg laden, Timegap laden, mit 1 multiplizieren und von p_balg abziehen, das Resultat wieder als p_balg speichern.

Ah schönlangsam steig ich dahinter, danke. Ist nur so, dass ich es von anderen Sprachen ein bisschen anders gewohnt bin. Dann wollen wir mal die Kneel-Funktion testen

Servus,

also, ich habs nochmal probiert, allerdings wird das Kneelen weder schneller noch langsamer, egal wie ich den Wer (gerade jetzt 0.1) ändere. Hab ich noch iwas falsch gemacht?

Code:

(L.L.bremse_halte)
{if}
   (L.L.bremse_p_balg_1_R) 0 >   
   {if}
   (L.L.bremse_p_balg_1_R) (L.S.Timegap) * 0.1 - (S.L.bremse_p_balg_1_R)
   {endif}


   (L.L.bremse_p_balg_0_R) 0 >   
   {if}
   (L.L.bremse_p_balg_0_R) (L.S.Timegap) * 0.1 - (S.L.bremse_p_balg_0_R)   
   {endif}

   
{endif}