Port of the programmable signals patch to recent trunk
Also add some additional changes from the SpringPP patch, and make some other minor changes/fixes.
This commit is contained in:
patch-import
committed by
Jonathan G Rennison
Jonathan G Rennison
parent
0b09a7ac61
commit
fc0efe599e
699
src/programmable_signals.cpp
Normal file
699
src/programmable_signals.cpp
Normal file
@@ -0,0 +1,699 @@
|
||||
/* $Id$ */
|
||||
|
||||
/*
|
||||
* This file is part of OpenTTD.
|
||||
* OpenTTD 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, version 2.
|
||||
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/** @file programmable_signals.cpp Programmable Signals */
|
||||
|
||||
#include "stdafx.h"
|
||||
#include "programmable_signals.h"
|
||||
#include "debug.h"
|
||||
#include "command_func.h"
|
||||
#include "table/strings.h"
|
||||
#include "window_func.h"
|
||||
#include "company_func.h"
|
||||
#include "cmd_helper.h"
|
||||
#include <assert.h>
|
||||
|
||||
ProgramList _signal_programs;
|
||||
|
||||
SignalProgram::SignalProgram(TileIndex tile, Track track, bool raw)
|
||||
{
|
||||
this->tile = tile;
|
||||
this->track = track;
|
||||
if (!raw) {
|
||||
this->first_instruction = new SignalSpecial(this, PSO_FIRST);
|
||||
this->last_instruction = new SignalSpecial(this, PSO_LAST);
|
||||
SignalSpecial::link(this->first_instruction, this->last_instruction);
|
||||
}
|
||||
}
|
||||
|
||||
SignalProgram::~SignalProgram()
|
||||
{
|
||||
this->DebugPrintProgram();
|
||||
this->first_instruction->Remove();
|
||||
delete this->first_instruction;
|
||||
delete this->last_instruction;
|
||||
}
|
||||
|
||||
struct SignalVM {
|
||||
// Initial information
|
||||
uint num_exits; ///< Number of exits from block
|
||||
uint num_green; ///< Number of green exits from block
|
||||
SignalProgram *program; ///< The program being run
|
||||
|
||||
// Current state
|
||||
SignalInstruction *instruction; ///< Instruction to execute next
|
||||
|
||||
// Output state
|
||||
SignalState state;
|
||||
|
||||
void Execute()
|
||||
{
|
||||
DEBUG(misc, 6, "Begining execution of programmable signal on tile %x, track %d",
|
||||
this->program->tile, this->program->track);
|
||||
do {
|
||||
DEBUG(misc, 10, " Executing instruction %d, opcode %d", this->instruction->Id(), this->instruction->Opcode());
|
||||
this->instruction->Evaluate(*this);
|
||||
} while (this->instruction);
|
||||
|
||||
DEBUG(misc, 6, "Completed");
|
||||
}
|
||||
};
|
||||
|
||||
// -- Conditions
|
||||
|
||||
SignalCondition::~SignalCondition()
|
||||
{}
|
||||
|
||||
SignalSimpleCondition::SignalSimpleCondition(SignalConditionCode code)
|
||||
: SignalCondition(code)
|
||||
{}
|
||||
|
||||
/* virtual */ bool SignalSimpleCondition::Evaluate(SignalVM &vm)
|
||||
{
|
||||
switch (this->cond_code) {
|
||||
case PSC_ALWAYS: return true;
|
||||
case PSC_NEVER: return false;
|
||||
default: NOT_REACHED();
|
||||
}
|
||||
}
|
||||
|
||||
SignalVariableCondition::SignalVariableCondition(SignalConditionCode code)
|
||||
: SignalCondition(code)
|
||||
{
|
||||
switch (this->cond_code) {
|
||||
case PSC_NUM_GREEN: comparator = SGC_NOT_EQUALS; break;
|
||||
case PSC_NUM_RED: comparator = SGC_EQUALS; break;
|
||||
default: NOT_REACHED();
|
||||
}
|
||||
value = 0;
|
||||
}
|
||||
|
||||
/*virtual*/ bool SignalVariableCondition::Evaluate(SignalVM &vm)
|
||||
{
|
||||
uint32 var_val;
|
||||
switch (this->cond_code) {
|
||||
case PSC_NUM_GREEN: var_val = vm.num_green; break;
|
||||
case PSC_NUM_RED: var_val = vm.num_exits - vm.num_green; break;
|
||||
default: NOT_REACHED();
|
||||
}
|
||||
|
||||
switch (this->comparator) {
|
||||
case SGC_EQUALS: return var_val == this->value;
|
||||
case SGC_NOT_EQUALS: return var_val != this->value;
|
||||
case SGC_LESS_THAN: return var_val < this->value;
|
||||
case SGC_LESS_THAN_EQUALS: return var_val <= this->value;
|
||||
case SGC_MORE_THAN: return var_val > this->value;
|
||||
case SGC_MORE_THAN_EQUALS: return var_val >= this->value;
|
||||
case SGC_IS_TRUE: return var_val != 0;
|
||||
case SGC_IS_FALSE: return !var_val;
|
||||
default: NOT_REACHED();
|
||||
}
|
||||
}
|
||||
|
||||
SignalStateCondition::SignalStateCondition(SignalReference this_sig,
|
||||
TileIndex sig_tile, Trackdir sig_track)
|
||||
: SignalCondition(PSC_SIGNAL_STATE), this_sig(this_sig), sig_tile(sig_tile)
|
||||
, sig_track(sig_track)
|
||||
{
|
||||
if (this->IsSignalValid())
|
||||
AddSignalDependency(SignalReference(this->sig_tile, TrackdirToTrack(sig_track)),
|
||||
this->this_sig);
|
||||
}
|
||||
|
||||
bool SignalStateCondition::IsSignalValid()
|
||||
{
|
||||
if (IsValidTile(this->sig_tile)) {
|
||||
if (HasSignalOnTrackdir(this->sig_tile, this->sig_track)) {
|
||||
return true;
|
||||
} else {
|
||||
Invalidate();
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void SignalStateCondition::Invalidate()
|
||||
{
|
||||
this->sig_tile = INVALID_TILE;
|
||||
}
|
||||
|
||||
|
||||
void SignalStateCondition::SetSignal(TileIndex tile, Trackdir track)
|
||||
{
|
||||
if (this->IsSignalValid())
|
||||
RemoveSignalDependency(SignalReference(this->sig_tile, TrackdirToTrack(sig_track)),
|
||||
this->this_sig);
|
||||
this->sig_tile = tile;
|
||||
this->sig_track = track;
|
||||
if (this->IsSignalValid())
|
||||
AddSignalDependency(SignalReference(this->sig_tile, TrackdirToTrack(sig_track)),
|
||||
this->this_sig);
|
||||
}
|
||||
|
||||
/*virtual*/ SignalStateCondition::~SignalStateCondition()
|
||||
{
|
||||
if (this->IsSignalValid())
|
||||
RemoveSignalDependency(SignalReference(this->sig_tile, TrackdirToTrack(sig_track)),
|
||||
this->this_sig);
|
||||
}
|
||||
|
||||
/*virtual*/ bool SignalStateCondition::Evaluate(SignalVM& vm)
|
||||
{
|
||||
if (!this->IsSignalValid()) {
|
||||
DEBUG(misc, 1, "Signal (%x, %d) has an invalid condition", this->this_sig.tile, this->this_sig.track);
|
||||
return false;
|
||||
}
|
||||
|
||||
return GetSignalStateByTrackdir(this->sig_tile, this->sig_track) == SIGNAL_STATE_GREEN;
|
||||
}
|
||||
|
||||
// -- Instructions
|
||||
SignalInstruction::SignalInstruction(SignalProgram *prog, SignalOpcode op)
|
||||
: opcode(op), previous(NULL), program(prog)
|
||||
{
|
||||
*program->instructions.Append() = this;
|
||||
}
|
||||
|
||||
SignalInstruction::~SignalInstruction()
|
||||
{
|
||||
SignalInstruction** pthis = program->instructions.Find(this);
|
||||
assert(pthis != program->instructions.End());
|
||||
program->instructions.Erase(pthis);
|
||||
}
|
||||
|
||||
void SignalInstruction::Insert(SignalInstruction *before_insn)
|
||||
{
|
||||
this->previous = before_insn->Previous();
|
||||
before_insn->Previous()->SetNext(this);
|
||||
before_insn->SetPrevious(this);
|
||||
this->SetNext(before_insn);
|
||||
}
|
||||
|
||||
SignalSpecial::SignalSpecial(SignalProgram *prog, SignalOpcode op)
|
||||
: SignalInstruction(prog, op)
|
||||
{
|
||||
assert(op == PSO_FIRST || op == PSO_LAST);
|
||||
this->next = NULL;
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalSpecial::Remove()
|
||||
{
|
||||
if (opcode == PSO_FIRST) {
|
||||
while (this->next->Opcode() != PSO_LAST) this->next->Remove();
|
||||
} else if (opcode == PSO_LAST) {
|
||||
} else NOT_REACHED();
|
||||
}
|
||||
|
||||
/*static*/ void SignalSpecial::link(SignalSpecial *first, SignalSpecial *last)
|
||||
{
|
||||
assert(first->opcode == PSO_FIRST && last->opcode == PSO_LAST);
|
||||
first->next = last;
|
||||
last->previous = first;
|
||||
}
|
||||
|
||||
void SignalSpecial::Evaluate(SignalVM &vm)
|
||||
{
|
||||
if (this->opcode == PSO_FIRST) {
|
||||
DEBUG(misc, 7, " Executing First");
|
||||
vm.instruction = this->next;
|
||||
} else {
|
||||
DEBUG(misc, 7, " Executing Last");
|
||||
vm.instruction = NULL;
|
||||
}
|
||||
}
|
||||
/*virtual*/ void SignalSpecial::SetNext(SignalInstruction *next_insn)
|
||||
{
|
||||
this->next = next_insn;
|
||||
}
|
||||
|
||||
SignalIf::PseudoInstruction::PseudoInstruction(SignalProgram *prog, SignalOpcode op)
|
||||
: SignalInstruction(prog, op)
|
||||
{}
|
||||
|
||||
SignalIf::PseudoInstruction::PseudoInstruction(SignalProgram *prog, SignalIf *block, SignalOpcode op)
|
||||
: SignalInstruction(prog, op)
|
||||
{
|
||||
this->block = block;
|
||||
if (op == PSO_IF_ELSE) {
|
||||
previous = block;
|
||||
} else if (op == PSO_IF_ENDIF) {
|
||||
previous = block->if_true;
|
||||
} else NOT_REACHED();
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalIf::PseudoInstruction::Remove()
|
||||
{
|
||||
if (opcode == PSO_IF_ELSE) {
|
||||
this->block->if_true = NULL;
|
||||
while(this->block->if_false) this->block->if_false->Remove();
|
||||
} else if (opcode == PSO_IF_ENDIF) {
|
||||
this->block->if_false = NULL;
|
||||
} else NOT_REACHED();
|
||||
delete this;
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalIf::PseudoInstruction::Evaluate(SignalVM &vm)
|
||||
{
|
||||
DEBUG(misc, 7, " Executing If Pseudo Instruction %s", opcode == PSO_IF_ELSE ? "Else" : "Endif");
|
||||
vm.instruction = this->block->after;
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalIf::PseudoInstruction::SetNext(SignalInstruction *next_insn)
|
||||
{
|
||||
if (this->opcode == PSO_IF_ELSE) {
|
||||
this->block->if_false = next_insn;
|
||||
} else if (this->opcode == PSO_IF_ENDIF) {
|
||||
this->block->after = next_insn;
|
||||
} else NOT_REACHED();
|
||||
}
|
||||
|
||||
SignalIf::SignalIf(SignalProgram *prog, bool raw)
|
||||
: SignalInstruction(prog, PSO_IF)
|
||||
{
|
||||
if (!raw) {
|
||||
this->condition = new SignalSimpleCondition(PSC_ALWAYS);
|
||||
this->if_true = new PseudoInstruction(prog, this, PSO_IF_ELSE);
|
||||
this->if_false = new PseudoInstruction(prog, this, PSO_IF_ENDIF);
|
||||
this->after = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalIf::Remove()
|
||||
{
|
||||
delete this->condition;
|
||||
while (this->if_true) this->if_true->Remove();
|
||||
|
||||
this->previous->SetNext(this->after);
|
||||
this->after->SetPrevious(this->previous);
|
||||
delete this;
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalIf::Insert(SignalInstruction *before_insn)
|
||||
{
|
||||
this->previous = before_insn->Previous();
|
||||
before_insn->Previous()->SetNext(this);
|
||||
before_insn->SetPrevious(this->if_false);
|
||||
this->after = before_insn;
|
||||
}
|
||||
|
||||
void SignalIf::SetCondition(SignalCondition *cond)
|
||||
{
|
||||
assert(cond != this->condition);
|
||||
delete this->condition;
|
||||
this->condition = cond;
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalIf::Evaluate(SignalVM &vm)
|
||||
{
|
||||
bool is_true = this->condition->Evaluate(vm);
|
||||
DEBUG(misc, 7, " Executing If, taking %s branch", is_true ? "then" : "else");
|
||||
if (is_true) {
|
||||
vm.instruction = this->if_true;
|
||||
} else {
|
||||
vm.instruction = this->if_false;
|
||||
}
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalIf::SetNext(SignalInstruction *next_insn)
|
||||
{
|
||||
this->if_true = next_insn;
|
||||
}
|
||||
|
||||
|
||||
|
||||
SignalSet::SignalSet(SignalProgram *prog, SignalState state)
|
||||
: SignalInstruction(prog, PSO_SET_SIGNAL)
|
||||
{
|
||||
this->to_state = state;
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalSet::Remove()
|
||||
{
|
||||
this->next->SetPrevious(this->previous);
|
||||
this->previous->SetNext(this->next);
|
||||
delete this;
|
||||
}
|
||||
|
||||
/*virtual*/ void SignalSet::Evaluate(SignalVM &vm)
|
||||
{
|
||||
DEBUG(misc, 7, " Executing SetSignal, making %s", this->to_state? "green" : "red");
|
||||
vm.state = this->to_state;
|
||||
vm.instruction = NULL;
|
||||
}
|
||||
|
||||
|
||||
/*virtual*/ void SignalSet::SetNext(SignalInstruction *next_insn)
|
||||
{
|
||||
this->next = next_insn;
|
||||
}
|
||||
|
||||
SignalProgram *GetExistingSignalProgram(SignalReference ref)
|
||||
{
|
||||
ProgramList::iterator i = _signal_programs.find(ref);
|
||||
if (i != _signal_programs.end()) {
|
||||
assert(i->first == ref);
|
||||
return i->second;
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SignalProgram *GetSignalProgram(SignalReference ref)
|
||||
{
|
||||
SignalProgram *pr = GetExistingSignalProgram(ref);
|
||||
if (!pr) {
|
||||
pr = new SignalProgram(ref.tile, ref.track);
|
||||
_signal_programs[ref] = pr;
|
||||
} else assert(pr->tile == ref.tile && pr->track == ref.track);
|
||||
return pr;
|
||||
}
|
||||
|
||||
void FreeSignalProgram(SignalReference ref)
|
||||
{
|
||||
DeleteWindowById(WC_SIGNAL_PROGRAM, (ref.tile << 3) | ref.track);
|
||||
ProgramList::iterator i = _signal_programs.find(ref);
|
||||
if (i != _signal_programs.end()) {
|
||||
delete i->second;
|
||||
_signal_programs.erase(i);
|
||||
}
|
||||
}
|
||||
|
||||
void FreeSignalPrograms()
|
||||
{
|
||||
ProgramList::iterator i, e;
|
||||
for (i = _signal_programs.begin(), e = _signal_programs.end(); i != e;) {
|
||||
delete i->second;
|
||||
// Must postincrement here to avoid iterator invalidation
|
||||
_signal_programs.erase(i++);
|
||||
}
|
||||
}
|
||||
|
||||
SignalState RunSignalProgram(SignalReference ref, uint num_exits, uint num_green)
|
||||
{
|
||||
SignalProgram *program = GetSignalProgram(ref);
|
||||
SignalVM vm;
|
||||
vm.program = program;
|
||||
vm.num_exits = num_exits;
|
||||
vm.num_green = num_green;
|
||||
|
||||
vm.instruction = program->first_instruction;
|
||||
vm.state = SIGNAL_STATE_RED;
|
||||
|
||||
DEBUG(misc, 7, "%d exits, of which %d green", vm.num_exits, vm.num_green);
|
||||
vm.Execute();
|
||||
DEBUG(misc, 7, "Returning %s", vm.state == SIGNAL_STATE_GREEN ? "green" : "red");
|
||||
return vm.state;
|
||||
}
|
||||
|
||||
void RemoveProgramDependencies(SignalReference by, SignalReference on)
|
||||
{
|
||||
SignalProgram *prog = GetSignalProgram(by);
|
||||
for (SignalInstruction **b = prog->instructions.Begin(), **i = b, **e = prog->instructions.End();
|
||||
i != e; i++) {
|
||||
SignalInstruction *insn = *i;
|
||||
if (insn->Opcode() == PSO_IF) {
|
||||
SignalIf* ifi = static_cast<SignalIf*>(insn);
|
||||
if (ifi->condition->ConditionCode() == PSC_SIGNAL_STATE) {
|
||||
SignalStateCondition* c = static_cast<SignalStateCondition*>(ifi->condition);
|
||||
if(c->sig_tile == by.tile && TrackdirToTrack(c->sig_track) == by.track)
|
||||
c->Invalidate();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
AddTrackToSignalBuffer(by.tile, by.track, GetTileOwner(by.tile));
|
||||
UpdateSignalsInBuffer();
|
||||
}
|
||||
|
||||
void SignalProgram::DebugPrintProgram()
|
||||
{
|
||||
DEBUG(misc, 5, "Program %p listing", this);
|
||||
for (SignalInstruction **b = this->instructions.Begin(), **i = b, **e = this->instructions.End();
|
||||
i != e; i++)
|
||||
{
|
||||
SignalInstruction *insn = *i;
|
||||
DEBUG(misc, 5, " %ld: Opcode %d, prev %d", long(i - b), int(insn->Opcode()),
|
||||
int(insn->Previous() ? insn->Previous()->Id() : -1));
|
||||
}
|
||||
}
|
||||
|
||||
/** Insert a signal instruction into the signal program.
|
||||
*
|
||||
* @param tile The Tile on which to perform the operation
|
||||
* @param p1 Flags and information
|
||||
* - Bits 0-2 Which track the signal sits on
|
||||
* - Bits 3-18 ID of instruction to insert before
|
||||
* - Bits 19-26 Which opcode to create
|
||||
* - Bits 27-31 Reserved
|
||||
* @param p2 Depends upon instruction
|
||||
* - PSO_SET_SIGNAL:
|
||||
* - Colour to set the signal to
|
||||
* @param text unused
|
||||
*/
|
||||
CommandCost CmdInsertSignalInstruction(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
||||
{
|
||||
Track track = Extract<Track, 0, 3>(p1);
|
||||
uint instruction_id = GB(p1, 3, 16);
|
||||
SignalOpcode op = Extract<SignalOpcode, 19, 8>(p1);
|
||||
|
||||
if (!IsValidTrack(track) || !IsPlainRailTile(tile) || !HasTrack(tile, track)) {
|
||||
return CMD_ERROR;
|
||||
}
|
||||
|
||||
if (!IsTileOwner(tile, _current_company))
|
||||
return_cmd_error(STR_ERROR_AREA_IS_OWNED_BY_ANOTHER);
|
||||
|
||||
SignalProgram *prog = GetExistingSignalProgram(SignalReference(tile, track));
|
||||
if (!prog)
|
||||
return_cmd_error(STR_ERR_PROGSIG_NOT_THERE);
|
||||
if (instruction_id > prog->instructions.Length())
|
||||
return_cmd_error(STR_ERR_PROGSIG_INVALID_INSTRUCTION);
|
||||
|
||||
bool exec = (flags & DC_EXEC) != 0;
|
||||
|
||||
SignalInstruction *insert_before = prog->instructions[instruction_id];
|
||||
switch (op) {
|
||||
case PSO_IF: {
|
||||
if (!exec) return CommandCost();
|
||||
SignalIf *if_ins = new SignalIf(prog);
|
||||
if_ins->Insert(insert_before);
|
||||
break;
|
||||
}
|
||||
|
||||
case PSO_SET_SIGNAL: {
|
||||
SignalState ss = (SignalState) p2;
|
||||
if (ss > SIGNAL_STATE_MAX) return_cmd_error(STR_ERR_PROGSIG_INVALID_OPCODE);
|
||||
if (!exec) return CommandCost();
|
||||
|
||||
SignalSet *set = new SignalSet(prog, ss);
|
||||
set->Insert(insert_before);
|
||||
break;
|
||||
}
|
||||
|
||||
case PSO_FIRST:
|
||||
case PSO_LAST:
|
||||
case PSO_IF_ELSE:
|
||||
case PSO_IF_ENDIF:
|
||||
default:
|
||||
return_cmd_error(STR_ERR_PROGSIG_INVALID_OPCODE);
|
||||
}
|
||||
|
||||
if (!exec) return CommandCost();
|
||||
AddTrackToSignalBuffer(tile, track, GetTileOwner(tile));
|
||||
UpdateSignalsInBuffer();
|
||||
InvalidateWindowData(WC_SIGNAL_PROGRAM, (tile << 3) | track);
|
||||
return CommandCost();
|
||||
}
|
||||
|
||||
/** Modify a singal instruction
|
||||
*
|
||||
* @param tile The Tile on which to perform the operation
|
||||
* @param p1 Flags and information
|
||||
* - Bits 0-2 Which track the signal sits on
|
||||
* - Bits 3-18 ID of instruction to insert before
|
||||
* @param p2 Depends upon instruction
|
||||
* - PSO_SET_SIGNAL:
|
||||
* - Colour to set the signal to
|
||||
* - PSO_IF:
|
||||
* - Bit 0 If 0, set the condidion code:
|
||||
* - Bit 1-8: Conditon code to change to
|
||||
* - Otherwise, if SignalVariableCondition:
|
||||
* - Bits 1-2: Which field to change (ConditionField)
|
||||
* - Bits 3-31: Value to set field to
|
||||
* - Otherwise, if SignalStateCondition:
|
||||
* - Bits 1-4: Trackdir on which signal is located
|
||||
* - Bits 5-31: Tile on which signal is located
|
||||
* @param text unused
|
||||
*/
|
||||
CommandCost CmdModifySignalInstruction(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
||||
{
|
||||
Track track = Extract<Track, 0, 3 >(p1);
|
||||
uint instruction_id = GB(p1, 3, 16);
|
||||
|
||||
if (!IsValidTrack(track) || !IsPlainRailTile(tile) || !HasTrack(tile, track)) {
|
||||
return CMD_ERROR;
|
||||
}
|
||||
|
||||
if (!IsTileOwner(tile, _current_company))
|
||||
return_cmd_error(STR_ERROR_AREA_IS_OWNED_BY_ANOTHER);
|
||||
|
||||
SignalProgram *prog = GetExistingSignalProgram(SignalReference(tile, track));
|
||||
if (!prog)
|
||||
return_cmd_error(STR_ERR_PROGSIG_NOT_THERE);
|
||||
|
||||
if (instruction_id > prog->instructions.Length())
|
||||
return_cmd_error(STR_ERR_PROGSIG_INVALID_INSTRUCTION);
|
||||
|
||||
bool exec = (flags & DC_EXEC) != 0;
|
||||
|
||||
SignalInstruction *insn = prog->instructions[instruction_id];
|
||||
switch (insn->Opcode()) {
|
||||
case PSO_SET_SIGNAL: {
|
||||
SignalState state = (SignalState) p2;
|
||||
if (state > SIGNAL_STATE_MAX)
|
||||
return_cmd_error(STR_ERR_PROGSIG_INVALID_SIGNAL_STATE);
|
||||
if (!exec)
|
||||
return CommandCost();
|
||||
SignalSet *ss = static_cast<SignalSet*>(insn);
|
||||
ss->to_state = state;
|
||||
} break;
|
||||
|
||||
case PSO_IF: {
|
||||
SignalIf *si = static_cast<SignalIf*>(insn);
|
||||
byte act = GB(p2, 0, 1);
|
||||
if (act == 0) { // Set code
|
||||
SignalConditionCode code = (SignalConditionCode) GB(p2, 1, 8);
|
||||
if (code > PSC_MAX)
|
||||
return_cmd_error(STR_ERR_PROGSIG_INVALID_CONDITION);
|
||||
if (!exec) return CommandCost();
|
||||
|
||||
SignalCondition *cond;
|
||||
switch (code) {
|
||||
case PSC_ALWAYS:
|
||||
case PSC_NEVER:
|
||||
cond = new SignalSimpleCondition(code);
|
||||
break;
|
||||
|
||||
case PSC_NUM_GREEN:
|
||||
case PSC_NUM_RED:
|
||||
cond = new SignalVariableCondition(code);
|
||||
break;
|
||||
|
||||
case PSC_SIGNAL_STATE:
|
||||
cond = new SignalStateCondition(SignalReference(tile, track), INVALID_TILE, INVALID_TRACKDIR);
|
||||
break;
|
||||
|
||||
default: NOT_REACHED();
|
||||
}
|
||||
si->SetCondition(cond);
|
||||
} else { // modify condition
|
||||
switch (si->condition->ConditionCode()) {
|
||||
case PSC_ALWAYS:
|
||||
case PSC_NEVER:
|
||||
return CommandCost(STR_ERR_PROGSIG_INVALID_CONDITION_FIELD);
|
||||
|
||||
case PSC_NUM_GREEN:
|
||||
case PSC_NUM_RED: {
|
||||
SignalVariableCondition *vc = static_cast<SignalVariableCondition*>(si->condition);
|
||||
SignalConditionField f = (SignalConditionField) GB(p2, 1, 2);
|
||||
uint32 val = GB(p2, 3, 27);
|
||||
if (f == SCF_COMPARATOR) {
|
||||
if (val > SGC_LAST) return_cmd_error(STR_ERR_PROGSIG_INVALID_COMPARATOR);
|
||||
if (!exec) return CommandCost();
|
||||
vc->comparator = (SignalComparator) val;
|
||||
} else if (f == SCF_VALUE) {
|
||||
if (!exec) return CommandCost();
|
||||
vc->value = val;
|
||||
} else CommandCost(STR_ERR_PROGSIG_INVALID_CONDITION_FIELD);
|
||||
} break;
|
||||
|
||||
case PSC_SIGNAL_STATE: {
|
||||
SignalStateCondition *sc = static_cast<SignalStateCondition*>(si->condition);
|
||||
Trackdir td = (Trackdir) GB(p2, 1, 4);
|
||||
TileIndex ti = (TileIndex) GB(p2, 5, 27);
|
||||
|
||||
if (!IsValidTile(ti) || !IsValidTrackdir(td) || !HasSignalOnTrackdir(ti, td)
|
||||
|| GetTileOwner(ti) != _current_company)
|
||||
return_cmd_error(STR_ERR_PROGSIG_INVALID_SIGNAL);
|
||||
if (!exec) return CommandCost();
|
||||
sc->SetSignal(ti, td);
|
||||
} break;
|
||||
}
|
||||
}
|
||||
} break;
|
||||
|
||||
case PSO_FIRST:
|
||||
case PSO_LAST:
|
||||
case PSO_IF_ELSE:
|
||||
case PSO_IF_ENDIF:
|
||||
default:
|
||||
return CommandCost(STR_ERR_PROGSIG_INVALID_OPCODE);
|
||||
}
|
||||
|
||||
if (!exec) return CommandCost();
|
||||
|
||||
AddTrackToSignalBuffer(tile, track, GetTileOwner(tile));
|
||||
UpdateSignalsInBuffer();
|
||||
InvalidateWindowData(WC_SIGNAL_PROGRAM, (tile << 3) | track);
|
||||
return CommandCost();
|
||||
}
|
||||
|
||||
/** Remove an instruction from a signal program
|
||||
*
|
||||
* @param tile The Tile on which to perform the operation
|
||||
* @param p1 Flags and information
|
||||
* - Bits 0-2 Which track the signal sits on
|
||||
* - Bits 3-18 ID of instruction to insert before
|
||||
* @param p2 unused
|
||||
* @param text unused
|
||||
*/
|
||||
CommandCost CmdRemoveSignalInstruction(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
||||
{
|
||||
Track track = Extract<Track, 0, 3 >(p1);
|
||||
uint instruction_id = GB(p1, 3, 16);
|
||||
|
||||
if (!IsValidTrack(track) || !IsPlainRailTile(tile) || !HasTrack(tile, track)) {
|
||||
return CMD_ERROR;
|
||||
}
|
||||
|
||||
if (!IsTileOwner(tile, _current_company))
|
||||
return_cmd_error(STR_ERROR_AREA_IS_OWNED_BY_ANOTHER);
|
||||
|
||||
SignalProgram *prog = GetExistingSignalProgram(SignalReference(tile, track));
|
||||
if (!prog)
|
||||
return_cmd_error(STR_ERR_PROGSIG_NOT_THERE);
|
||||
|
||||
if (instruction_id > prog->instructions.Length())
|
||||
return_cmd_error(STR_ERR_PROGSIG_INVALID_INSTRUCTION);
|
||||
|
||||
bool exec = (flags & DC_EXEC) != 0;
|
||||
|
||||
SignalInstruction *insn = prog->instructions[instruction_id];
|
||||
switch (insn->Opcode()) {
|
||||
case PSO_SET_SIGNAL:
|
||||
case PSO_IF:
|
||||
if (!exec) return CommandCost();
|
||||
insn->Remove();
|
||||
break;
|
||||
|
||||
case PSO_FIRST:
|
||||
case PSO_LAST:
|
||||
case PSO_IF_ELSE:
|
||||
case PSO_IF_ENDIF:
|
||||
default:
|
||||
return_cmd_error(STR_ERR_PROGSIG_INVALID_OPCODE);
|
||||
}
|
||||
|
||||
if (!exec) return CommandCost();
|
||||
AddTrackToSignalBuffer(tile, track, GetTileOwner(tile));
|
||||
UpdateSignalsInBuffer();
|
||||
InvalidateWindowData(WC_SIGNAL_PROGRAM, (tile << 3) | track);
|
||||
return CommandCost();
|
||||
}
|
||||
Reference in New Issue
Block a user