# Segnale di avviso da nascondere a valle dei segnali di protezione o partenza per farli
# aprire in deviata anche quando il tracciato è corretto. Tra questo avviso e l'imperativo
# successivo non ci devono essere deviatoi, e prima non ci possono essere avvisi normali,
# perché non possono imporre deviate. Siccome i segnali considerano un solo avviso a valle
# di essi, se dopo questo ne segue un altro (normale o speciale) il suo aspetto va "ripor-
# tato" al segnale precedente. Per questo gli aspetti sono vari, anche se il segnale appa-
# re sempre spento in quanto da nascondere:

# block              (blocca l'apertura del segnale precedente)
# thrown             (deviata forzata senza altri avvisi; considerare l'imperativo che segue)
# red_short_thrown   (deviata forzata su binario (forzato) corto e segnale chiuso: richiede RGG)
# yellow_thrown      (deviata forzata verso GG: richiede RG)
# flashing_thrown    (deviata forzata verso G vicino o avviso di deviata vicino - richiede RGx)
# green_thrown       (deviata forzata verso Gx o V - richiede RV)

# ATTENZIONE: per la corretta inizializzazione del segnale, eventuali avvisi che lo seguono devono
#             essere inseriti nel tracciato DOPO di esso, in modo che si aggiornino prima.

# Special distant signal to be hidden after a main signal to force the latter to show diverging
# aspects even when the route is straight. No other distants can precede this signal, as distants
# cannot show diverging aspects, and no switches can be present between this distant and the main
# signal that follows. As only one pure distant is considered by previuos signals, if the next sig-
# nal is another distant (normal or special), this signal must "report" back its aspect to the pre-
# vious signal, so many aspects are used, eveb if the signal remains unlit, as it should be hidden:

# block              (prevent the previous signal from clearing)
# thrown             (force diverging; next isn't a pure distant, so consider its aspect)
# red_short_thrown   (force diverging on a short (forced) track and an unclear signal: requires RYY)
# yellow_thrown      (force diverging; next pure distant shows YY: requires RY)
# flashing_thrown    (force diverging on a near Y or on a near prepare to slow - requires RYx)
# green_thrown       (force diverging; next pure distant shows Yx or G: requires RG)

# WARNING: For this signal to be initialized correctly, any other distant following this signal
#          should be placed in the layout AFTER this one, so they will be updated before.

# P.Rosati  21/01/2021 (Versione 5.1)

Aspect: block
	IconE: NN_b_E.xpm
	IconW: NN_b_W.xpm
	IconN: NN_b_N.xpm
	IconS: NN_b_S.xpm
	Action: none

Aspect: thrown
	IconE: NN_b_E.xpm
	IconW: NN_b_W.xpm
	IconN: NN_b_N.xpm
	IconS: NN_b_S.xpm
	Action: none

Aspect: red_short_thrown
	IconE: NN_b_E.xpm
	IconW: NN_b_W.xpm
	IconN: NN_b_N.xpm
	IconS: NN_b_S.xpm
	Action: none

Aspect: yellow_thrown
	IconE: NN_b_E.xpm
	IconW: NN_b_W.xpm
	IconN: NN_b_N.xpm
	IconS: NN_b_S.xpm
	Action: none

Aspect: flashing_thrown
	IconE: NN_b_E.xpm
	IconW: NN_b_W.xpm
	IconN: NN_b_N.xpm
	IconS: NN_b_S.xpm
	Action: none

Aspect: green_thrown
	IconE: NN_b_E.xpm
	IconW: NN_b_W.xpm
	IconN: NN_b_N.xpm
	IconS: NN_b_S.xpm
	Action: none

# initial aspect

OnInit:
	if nextApproach.aspect = red_short		# Avviso speciale che richiede GG o RGG (forzo questo) se l'imperativo che segue è chiuso
		.aspect = red_short_thrown			# A special distant follows, requiring GG or RYY (force this) if next main is unclear
		return
	end
	if nextApproach.aspect = yellow_yellow
		.aspect = yellow_thrown				# Avviso che richiede RG: GG - Distant requiring RY: YY
		return
	end
	# Avvisi che richiedono RGx: (G | GV | GxVx | Gx/Vx) se vicini al successivo
	# Distants requiring RYx: (Y | YG | YxGx | Yx/Gx) if near the next signal
	if nextApproach.aspect > short and nextApproach.aspect < shoru
		.aspect = flashing_thrown
		return
	end
	# Avvisi che richiedono V: (G | GV | GxVx | Gx/Vx) a distanza normale o (Gx | V)
	# Distant aspects requiring G: (Y | YG | YxGx | Yx/Gx) at normal distance or (Yx | V)
	if nextApproach.aspect = yellow_green or nextApproach.aspect = yellow_green_flashing or nextApproach.aspect = yellow_green_switching
		.aspect = green_thrown
		return
	end
	if nextApproach.aspect = yellow or nextApproach.aspect = yellow_flashing or nextApproach.aspect = green
		.aspect = green_thrown
		return
	end
	.aspect = thrown						# Non segue avviso: forza solo la deviata - No distant follows: just force diverging
end

# the player or a script cleared the signal

OnCleared:
	return
end

# this or another signal changed its aspect

OnUpdate:
	if nextApproach.aspect = block			# Avviso speciale che blocca l'apertura del segnale precedente
		.aspect = block						# A special distant follows, preventing the previous signal from clearing
		return
	end
	if nextApproach.aspect = red_short		# Avviso speciale che richiede GG o RGG (forzo questo) se l'imperativo che segue è chiuso
		.aspect = red_short_thrown			# A special distant follows, requiring GG or RYY (force this) if next main is unclear
		return
	end
	if nextApproach.aspect = yellow_yellow
		.aspect = yellow_thrown				# Avviso che richiede RG: GG - Distant requiring RY: YY
		return
	end
	# Avvisi che richiedono RGx: (G | GV | GxVx | Gx/Vx) se vicini al successivo
	# Distants requiring RYx: (Y | YG | YxGx | Yx/Gx) if near the next signal
	if nextApproach.aspect > short and nextApproach.aspect < shoru
		.aspect = flashing_thrown
		return
	end
	# Avvisi che richiedono V: (G | GV | GxVx | Gx/Vx) a distanza normale o (Gx | V)
	# Distant aspects requiring G: (Y | YG | YxGx | Yx/Gx) at normal distance or (Yx | V)
	if nextApproach.aspect = yellow_green or nextApproach.aspect = yellow_green_flashing or nextApproach.aspect = yellow_green_switching
		.aspect = green_thrown
		return
	end
	if nextApproach.aspect = yellow or nextApproach.aspect = yellow_flashing or nextApproach.aspect = green
		.aspect = green_thrown
		return
	end
	.aspect = thrown						# Non segue avviso: forza solo la deviata - No distant follows: just force diverging
end

# a train passed the signal

OnCross:
	return
end
