Le seguenti procedure presuppongono che abbiate preparato una base per test, TestBase.RW (o come avete scelto chiamarla), nel modo descritto nella procedura della base per test.

Queste procedure dimostrano la disposizione dei binari. Aggiungono curve, pendenze, binari supplementari e scambi ad una sezione di linea a binario semplice della base di test. Queste procedure discutono anche alcune questioni importanti, come i cicli di rotazione. Potete riferirvi alle istruzioni di formazione dei binari nel Riferimento 1 , specificamente a @RailStart, @rail, @RailType, @RailEnd, @pitch e @curve. Si noti che i comandi sono "case-insensitive".

Aggiungere una curva ad S.

1. Usando Notepad, inserite le seguenti righe in ordine progressivo. (non pensiate che BVE elabori correttamente istruzioni che non siano nell'ordine corretto. In ogni caso, mantenere le cose disposte correttamente vi aiuterà a non diventare matto.)

   150@curve(-800,5) ; ab curva sinistra, raggio 800M, inclinazione 5

   225@curve(800,5) ; ab curva deistra, raggio 800M, inclinazione 5

   300@curve(0,0) ; ab diritto

   Le istruzione curve prende due parametri. Il primo è il raggio in metri, un numero negativo indica a sinistra e un numero positivo indica a destra. Il secondo parametro è l'altezza nei millimetri della rotaia esterna rispetto a quella interna alla curva (cioè la sopraelevazione). Numeri più alti sono adatti per curve ad alta-velocità e/o a piccolo-raggio.

   Potete calcolare la sopraelevazione (H) così:

   H (mm) = 1.37 x velocità (Km/h) x velocità (Km/h) / raggio (m)

   In unità britanniche:

   H (in) = 4 x speed (MPH) x speed (MPH) / radius (Ft)

   La U.S. Federal Railway Agency stabilisce una sopraelevazione massima di 6" (147mm).

   Da notare che un comando come @curve resta valido finchè è impostato. Così il 200@curve(0,0) riporta il binario diritto. Senza questa istruzione il treno viaggerebbe in un cerchio continuo. (potrebbe essere un divertimento da provare se desiderate simulare il vostro trenino Lionel.)

2. Lanciate BVE e provate il vostro lavoro lavoro. Potete anche desiderare di variare i parametri per vedere i loro effetti.

Aggiungere le pendenze.

1. Continuando, aggiungete ciò che segue:

   350@pitch(20) ; ab salita 2%

   425@pitch(-20) ; ab discesa 2%

   500@pitch(0) ; ab in piano

   Il parametro è in unità per mille, così 20 rappresenta una pendenza del 2% in su e -20 rappresenta una pendenza del 2% in giù. come il comando curve, 300@pitch(0) livella il binario.

2. Di nuovo, provate i risultati. Provare pitch differenti. Vedete quale pendenza il vostro treno può superare.

Aggiungere gli scambi.

1. Commentate via i curve e i pitch che avete appena inserito e scrivete ciò che segue:

   125@RailStart(2,0,0,0) ; ab inizio scambio destro

   150@rail(2,4,0,0) ; ab fine scambio destro

   RailStart definisce l'inizio di nuovo binario. Il primo parametro in entrambe le istruzione (2) è il nuovo binario. (il binario su cui si corre è sempre quello 0.) I secondo parametro (0) e (4) sono lo spostamento laterale, che è zero nella prima istruzione e di 4 metri a destra nella seconda e crea la divergenza, quindi lo scambio. Il terzo e il quarto parametro (0) e (0) sono gli stessi del binario corrente.

   Quando verificherete le nuove aggiunte, noterete che il nuovo binario corre accanto a quello corrente. Il nuovo binario è un grafico e prende la sua posizione sotto forma di spostamenti laterali dal binario di corsa.

   Tentiamo ora di rendere lo scambio più graduale espandendo la distanza fra i comandi RailStart e Rail. Il punto seguente dimostra qualcosa di molto importante sul modo con cui BVE tratta le curve.

2. Espandere la distanza fra i comandi RailStart e Rail ed aggiungere gli indicatori per mostrare la posizione esatta dello scambio. (ho preso in prestito il segnale del limite di velocità di 15 MPH definito come freeobject 95 nella sezione Object del route file. Ho omesso l'istruzione @limit delle righe di codice perché qui è irrilevante per la nostra discussione.)

   130@freeObj(0,95,1.70,1.0,0) ; segnale - ab

   130@RailStart(2,0,0,0) ; ab inizio dello scambio destro

   140@freeObj(0,95,1.70,1.0,0) ; segnale - ab

   150@freeObj(0,95,1.70,1.0,0) ; segnale - ab

   160@freeObj(0,95,1.70,1.0,0) ; segnale - ab

   170@freeObj(0,95,1.70,1.0,0) ; segnale - ab

   180@freeObj(0,95,1.70,1.0,0) ; segnale - ab

   190@freeObj(0,95,1.70,1.0,0) ; segnale - ab

   200@freeObj(0,95,1.70,1.0,0) ; segnale - ab

   200@rail(2,4,0,0) ; ab fine dello scambio destro

   Quando fate funzionare questo itinerario trovate che lo scambio inizia circa al quinto indicatore e finisce all'ultimo. La distanza è di 25 metri per uno spostamento di 4. Potete aumentare/diminuire lo spostamento nel comando 200@rail, ma i punti iniziale e finale dello scambio rimangono invariati. Non sono considerati nè lo spostamento, nè il grado di spostamento. La lezione è che qualsiasi sezione del binario torna ad uno stato di parallelo dopo 25 metri, misurati lungo il binario corrente. Inoltre, BVE tratta le curve come tratti diritti di 25 metri. Potete dimostrare ciò da voi stessi costruendo una curva ad S che cambia il senso ogni 5 metri. Quando la proverete, troverete che BVE fa la media e raddrizza ogni tratto fino a 25 metri, quindi fa la media e raddrizza i 25 metri successivi, e così via.

   Per ottenere uno scambio graduale, dovete aggiungere dei punti intermedi allo scambio originale, come in quanto segue (ma in primo luogo rimuovete o commentate via le 10 righe precedenti):

   125@RailStart(2,0,0,0) ; ab inizio dello scambio destro

   150@rail(2,2,0,0) ; ab

   175@rail(2,4,0,0) ; ab fine dello scambio destro

3. 3. Per creare un incrocio fra due binari, usate un terzo binario per un tratto corto che collega i primi due. Aggiungete quanto segue:

   220@railstart(3,0,0,0) ; ab inizio incrocio

   245@railend(3,4,0,0) ; ab fine incrocio

   I binario 3 comincia con lo spostamento di (0), coincidendo col binario corrente e finisce con uno spostamento di (4), coincidente col binario 2.

   Considerate che questo è un incrocio visivo. Il vostro treno rimane sul binario corrente.

4. 4. Per creare un binario divergente, aggiungete quanto segue:

   300@RailStart(4,0,0,0) ; ab inizio diversione

   325@Rail(4,-6,0,0) ; ab

   350@Rail(4,-13,0,0) ; ab

   375@Rail(4,-36,0,0) ; ab

   400@RailEnd(4,-100,0,0) ; ab fine diversione breakaway

   La tendenza di qualsiasi binario è di essere in parallelo con quello corrente. Per costruire un binario divergente che continui ad allontanarsi senza che torni allo stato di parallelo, anche per una piccola sezione, occorre qualche accorgimento. Diventa più complicato quando il vostro binario di corsa sta egualmente curvando. Di nuovo, il binario divergente è soltanto visivo.

5. Per fare attraversare ad un binario quello corrente da un lato all'altro, occorre una sezione da 25 metri per il binario 4. Il prossimo set di istruzioni è per attraversare uniformemente da uno spostamento di 4 metri ad uno spostamento di -4 metri (totale 8). Se credete commentate via lo scambio che inizia a 125 e finisce a 175, solo per mantenere le cose riordinate.

   75@RailStart(4,4,0,0) ; ab posizione binario 4

   140@rail(4,0,0,0) ; ab inizio incrocio a 115

   165@rail(4,-4,0,0) ; ab fine incrocio

6. Per creare l'impressione di spostarsi lungo uno scambio su un "diverso" binario, usate il comando @turn. Questo comando diventa disponibile con BVE2 e non è compreso nel Reference 1. Dal punto in cui è richiamato, il comando @turn gira il piano della vista. Se usate una grande curva, potete vedere una spaccatura nel paesaggio. Commentate via le righe del punto 5 e aggiungete quanto segue:

   100@turn(0.8) ; ab

   Notare la spaccatura a sinistra quando provate questo scenario.

   Ora provate qualcosa di più ragionevole.

   100@turn(0.08) ; ab

   125@turn(-0.08) ; ab

   Quando lo provate, l'effetto è simile a quello del comando @curve.

   Il trucco sta ora nel combinare il @turn con l'attraversamento del punto 5 per permettere al treno di passare apparentemente da un binario all'altro. Iniziamo semplicemente col binario corrente che si sposta a destra per unirsi a quello attiguo (ma in primo luogo togliete o commentate via le due righe precedenti).

   75@RailStart(4,4,0,0) ; ab posizionamento binario 4

   140@turn(.08) ; ab turn a destra

   140@rail(4,4,0,0) ; ab

   165@rail(4,2,0,0) ; ab mantiene diritto il binario 4

   190@turn(-.08) ; ab turn a sinistra

   190@rail(4,0,0,0) ; ab

   Ora aggiungete il binario 5 (in grassetto) per proseguire la linea sulla quale eravamo in origine.

   75@RailStart(4,4,0,0) ; ab posizionamento binario 4

   75@RailStart(5,0,0,0) ; ab posizionamento binario 5

   140@turn(.08) ; ab svolta a destra

   140@rail(4,4,0,0) ; ab

   165@rail(4,2,0,0) ; ab raddrizzamento binario 4

   165@rail(5,-2,0,0) ; ab raddrizzamento binario 5

   190@turn(-.08) ; ab svolta a sinistra

   190@rail(4,0,0,0) ; ab

   190@rail(5,-4,0,0) ; ab posizionamento binario 5

   300@RailEnd(5,-4,0,0) ; ab fine del binario 5

   Se gli inserimenti alla posizione 165 sono poco chiari, provare a rimuoverli. I binari 4 e 5 tenteranno di seguire il binario corrente. Riducendo le lunghezze del binario a 25 metri fra le posizioni, si mantengono le lunghezze diritte.

   Il parametro nell' istruzione del @turn corrisponde alla deviazione. È lo spostamento laterale diviso dalla lunghezza della sezione. Cioè se una sezione di 25 metri gira in modo che la sua estremità libera si sposti lateralmente di 4 metri, la deviazione è 4/25, o 0,08.

Viaggi di ritorno. Chiunque riproducendo una linea tranviaria o una piccola linea, ad un certo punto vorrebbe creare un anello di ritorno. Ci sono parecchie cose da considerare. In primo luogo, BVE può creare le curve strette tipiche dei tram e dei veicoli a carrelli leggeri, ma ciò viene fatto con elementi di binario diritti lunghi 25 metri. Le curve risultanti sono un po' brutte nell' apparenza. Daltronde ci sono considerazioni più importanti: BVE visualizza il binario davanti al treno nel route file, ma non quello dietro. Inoltre BVE non visualizza il binario su cui si trova il treno, anche se il binario da percorrere, dopo aver invertito la marcia, è coincidente con la sezione percorsa in precedenza. Esso visualizza due versioni dello stesso parallele. Quindi, per avere una speranza di creare un cappio di ritorno, dovrete ricorrere a metodi indiretti.

Il codice seguente esegue un ciclo di rotazione in cui il binario di ritorno è parallelo a quello originale di andata:

Commentate via il vostro lavoro precedente ed inserite quanto segue:

200@curve(-31.73,10) ; ab - inizio anello di ritorno

250@curve(0,0) ; ab - breve tratto diritto per separare il ritorno

254@curve(-31.73,10) ; ab

354@curve(31.73,10) ; ab - anello di inversione

404@curve(0,10) ; fine dell'anello