miguel.horta/openttd-cmclient
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reimplement station building previews

Browse Source
This commit is contained in:
dP
2025-06-26 18:24:01 +05:00
parent c219bf3e4f
commit b2737fe293
20 changed files with 1587 additions and 1057 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
gen_commands.py
View File

@@ -24,6 +24,17 @@ FILES = [
'script/script_cmd.h',
]
BASE_CLASS = {
'BuildDock': 'StationBuildCommand',
'BuildRailStation': 'StationBuildCommand',
'BuildAirport': 'StationBuildCommand',
'BuildRoadStop': 'StationBuildCommand',
}
BASE_FIELDS = {
'StationBuildCommand': ['station_to_join', 'adjacent'],
}
BASE_DIR = Path(__file__).parent
OUTPUT = BASE_DIR / 'src/citymania/generated/cm_gen_commands'
GLOBAL_TYPES = set(('GoalType', 'GoalTypeID', 'GoalID'))
@@ -245,13 +256,20 @@ def run():
)
for cmd in commands:
name = cmd['name']
args_list = ', '.join(f'{at} {an}' for at, an in cmd['args'])
args_init = ', '.join(f'{an}{{{an}}}' for _, an in cmd['args'])
base_class = BASE_CLASS.get(name, 'Command')
base_fields = BASE_FIELDS.get(base_class, [])
f.write(
f'class {name}: public Command {{\n'
f'class {name}: public {base_class} {{\n'
f'public:\n'
)
args_list = ', '.join(f'{at} {an}' for at, an in cmd['args'])
args_init = ', '.join(f'{an}{{{an}}}' for _, an in cmd['args'] if an not in base_fields)
if base_fields:
base_joined = ', '.join(base_fields)
args_init = f'{base_class}{{{base_joined}}}, ' + args_init
for at, an in cmd['args']:
if an in base_fields:
continue
f.write(f' {at} {an};\n')
f.write(f'\n')
if args_init:

10
src/airport_gui.cpp
View File

@@ -37,6 +37,7 @@
#include "widgets/airport_widget.h"
#include "citymania/cm_hotkeys.hpp"
#include "citymania/cm_highlight.hpp"
#include "citymania/cm_station_gui.hpp"
#include "safeguards.h"
@@ -64,11 +65,7 @@ void CcBuildAirport(Commands, const CommandCost &result, TileIndex tile)
*/
static void PlaceAirport(TileIndex tile)
{
if (citymania::UseImprovedStationJoin()) {
citymania::PlaceAirport(tile);
return;
}
NOT_REACHED(); // CityMania uses tools
if (_selected_airport_index == -1) return;
byte airport_type = AirportClass::Get(_selected_airport_class)->GetSpec(_selected_airport_index)->GetIndex();
@@ -130,7 +127,8 @@ struct BuildAirToolbarWindow : Window {
{
switch (widget) {
case WID_AT_AIRPORT:
if (HandlePlacePushButton(this, WID_AT_AIRPORT, SPR_CURSOR_AIRPORT, HT_RECT, CM_DDSP_BUILD_AIRPORT)) {
// if (HandlePlacePushButton(this, WID_AT_AIRPORT, SPR_CURSOR_AIRPORT, HT_RECT, CM_DDSP_BUILD_AIRPORT)) {
if (citymania::HandlePlacePushButton(this, WID_AT_AIRPORT, std::make_unique<citymania::AirportBuildTool>())) {
ShowBuildAirportPicker(this);
this->last_user_action = widget;
}

9
src/citymania/cm_command_type.hpp
View File

@@ -94,6 +94,15 @@ public:
}
};
class StationBuildCommand : public Command {
public:
StationID station_to_join;
bool adjacent;
StationBuildCommand(StationID station_to_join, bool adjacent)
:station_to_join{station_to_join}, adjacent{adjacent} {}
};
} // namaespace citymania
#endif

170
src/citymania/cm_highlight.cpp
View File

@@ -188,7 +188,6 @@ struct TileZoning {
static TileZoning *_mz = nullptr;
static IndustryType _industry_forbidden_tiles = INVALID_INDUSTRYTYPE;
extern StationBuildingStatus _station_building_status;
extern const Station *_station_to_join;
extern const Station *_highlight_station_to_join;
extern TileArea _highlight_join_area;
@@ -509,6 +508,13 @@ ObjectHighlight ObjectHighlight::make_industry(TileIndex tile, IndustryType ind_
return oh;
}
ObjectHighlight ObjectHighlight::make_dock(TileIndex tile, DiagDirection orientation) {
auto oh = ObjectHighlight{ObjectHighlight::Type::DOCK};
oh.tile = tile;
oh.ddir = orientation;
return oh;
}
/**
* Try to add an additional rail-track at the entrance of a depot
* @param tile Tile to use for adding the rail-track
@@ -561,12 +567,12 @@ void ObjectHighlight::AddStationOverlayData(int w, int h, int rad, StationCovera
if (cs == nullptr) continue;
if (!has_header) {
this->overlay_data.emplace_back(PAL_NONE, GetString(CM_STR_BUILD_INFO_OVERLAY_STATION_SUPPLIES));
this->overlay_data.emplace_back(0, PAL_NONE, GetString(CM_STR_BUILD_INFO_OVERLAY_STATION_SUPPLIES));
has_header = true;
}
SetDParam(0, i);
SetDParam(1, production[i] >> 8);
this->overlay_data.emplace_back(cs->GetCargoIcon(), GetString(CM_STR_BUILD_INFO_OVERLAY_STATION_CARGO));
this->overlay_data.emplace_back(1, cs->GetCargoIcon(), GetString(CM_STR_BUILD_INFO_OVERLAY_STATION_CARGO));
}
}
@@ -802,6 +808,20 @@ void ObjectHighlight::UpdateTiles() {
}
break;
}
case Type::DOCK: {
this->cost = cmd::BuildDock(
this->tile,
NEW_STATION,
true
).test();
auto palette = (cost.Succeeded() ? CM_PALETTE_TINT_WHITE : CM_PALETTE_TINT_RED_DEEP);
this->AddTile(this->tile, ObjectTileHighlight::make_dock_slope(palette, this->ddir));
if (this->ddir != INVALID_DIAGDIR) {
TileIndex tile_to = TileAddByDiagDir(this->tile, this->ddir);
this->AddTile(tile_to, ObjectTileHighlight::make_dock_flat(palette, DiagDirToAxis(this->ddir)));
}
break;
}
default:
NOT_REACHED();
}
@@ -818,11 +838,12 @@ void ObjectHighlight::UpdateOverlay() {
HideBuildInfoOverlay();
return;
}
auto err = this->cost.GetErrorMessage();
// auto extra_err = this->cost.GetExtraErrorMessage();
bool no_money = (err == STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY);
SetDParam(0, this->cost.GetCost());
this->overlay_data.emplace_back(PAL_NONE, GetString(no_money ? CM_STR_BUILD_INFO_OVERLAY_COST_NO_MONEY : CM_STR_BUILD_INFO_OVERLAY_COST_OK));
this->overlay_data.emplace_back(0, PAL_NONE, GetString(no_money ? CM_STR_BUILD_INFO_OVERLAY_COST_NO_MONEY : CM_STR_BUILD_INFO_OVERLAY_COST_OK));
// if (this->cost.Failed() && err != STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY) {
// if (err == INVALID_STRING_ID) {
// this->overlay_data.emplace_back(PAL_NONE, GetString(CM_STR_BUILD_INFO_OVERLAY_ERROR_UNKNOWN));
@@ -1619,6 +1640,44 @@ TileHighlight ObjectHighlight::GetTileHighlight(const TileInfo *ti) {
return th;
}
HighlightMap ObjectHighlight::GetHighlightMap(SpriteID palette) {
// TODO remove the need to convert (maybe replace HighlightMap with multimap?)
HighlightMap res;
for (auto &[tile, oth] : this->tiles) {
auto othp = oth;
othp.palette = palette;
res.Add(tile, othp);
}
return res;
}
std::optional<TileArea> ObjectHighlight::GetArea() {
switch(this->type) {
case Type::NONE:
case Type::BLUEPRINT:
case Type::POLYRAIL:
case Type::INDUSTRY:
return std::nullopt;
case Type::RAIL_DEPOT:
case Type::ROAD_DEPOT:
return TileArea{this->tile, 1, 1};
case Type::RAIL_STATION:
case Type::ROAD_STOP:
return TileArea{this->tile, this->end_tile};
case Type::AIRPORT: {
const AirportSpec *as = AirportSpec::Get(this->airport_type);
if (!as->IsAvailable() || this->airport_layout >= as->num_table) return std::nullopt;
return TileArea{this->tile, as->size_x, as->size_y};
}
case Type::DOCK: {
if (this->ddir == INVALID_DIAGDIR) return std::nullopt;
return TileArea{this->tile, TileAddByDiagDir(this->tile, this->ddir)};
}
default:
NOT_REACHED();
}
}
static void DrawObjectTileHighlight(const TileInfo *ti, const ObjectTileHighlight &oth) {
switch (oth.type) {
case ObjectTileHighlight::Type::RAIL_DEPOT:
@@ -1917,7 +1976,7 @@ void CalcCBTownLimitBorder(TileHighlight &th, TileIndex tile, SpriteID border_pa
TileHighlight GetTileHighlight(const TileInfo *ti, TileType tile_type) {
TileHighlight th;
auto hl = _ap.tiles.GetForTile(ti->tile);
auto hl = _at.tiles.GetForTile(ti->tile);
if (hl.has_value()) {
for (auto &oth : hl.value().get()) {
oth.SetTileHighlight(th, ti);
@@ -2046,7 +2105,7 @@ void DrawTileZoning(const TileInfo *ti, const TileHighlight &th, TileType tile_t
bool DrawTileSelection(const TileInfo *ti, [[maybe_unused]] const TileHighlightType &tht) {
if (ti->tile == INVALID_TILE || IsTileType(ti->tile, MP_VOID)) return false;
auto hl = _ap.tiles.GetForTile(ti->tile);
auto hl = _at.tiles.GetForTile(ti->tile);
if (hl.has_value()) {
for (auto &oth : hl.value().get()) {
DrawObjectTileHighlight(ti, oth);
@@ -2376,7 +2435,8 @@ PaletteID GetTreeShadePal(TileIndex tile) {
}
}
ActivePreview _ap;
ActiveTool _at;
static void ResetVanillaHighlight() {
if (_thd.window_class != WC_INVALID) {
@@ -2402,34 +2462,81 @@ static void ResetVanillaHighlight() {
_thd.make_square_red = false;
}
void SetActivePreview(up<Preview> &&preview) {
void SetActiveTool(up<Tool> &&tool) {
ResetVanillaHighlight();
ResetActivePreview();
_ap.preview = std::move(preview);
ResetActiveTool();
_at.tool = std::move(tool);
}
void ResetActivePreview() {
for (auto t : _ap.tiles.GetAllTiles()) {
void ResetActiveTool() {
for (auto t : _at.tiles.GetAllTiles()) {
MarkTileDirtyByTile(t);
}
_ap.preview = nullptr;
_ap.tiles = {};
_at.tool = nullptr;
_at.tiles = {};
}
const up<Preview> &GetActivePreview() {
return _ap.preview;
const up<Tool> &GetActiveTool() {
return _at.tool;
}
void UpdateActivePreview() {
if (_ap.preview == nullptr) return;
void UpdateActiveTool() {
Point pt = GetTileBelowCursor();
auto tile = pt.x == -1 ? INVALID_TILE : TileVirtXY(pt.x, pt.y);
_ap.preview->Update(pt, tile);
auto tiles_changed = _ap.tiles.UpdateWithMap(_ap.preview->GetHighlightMap());
ToolGUIInfo info;
if (citymania::StationBuildTool::active_highlight.has_value()) {
info = GetSelectedStationGUIInfo();
} else if (_at.tool != nullptr) {
_at.tool->Update(pt, tile);
info = _at.tool->GetGUIInfo();
}
auto [hlmap, overlay_data, cost] = info;
auto tiles_changed = _at.tiles.UpdateWithMap(hlmap);
for (auto t : tiles_changed)
MarkTileDirtyByTile(t);
if (cost.GetExpensesType() != INVALID_EXPENSES || cost.GetErrorMessage() != INVALID_STRING_ID) {
// Add CommandCost info
auto err = cost.GetErrorMessage();
if (cost.Succeeded()) {
auto money = cost.GetCost();
if (money != 0) {
SetDParam(0, money);
overlay_data.emplace_back(0, PAL_NONE, GetString(CM_STR_BUILD_INFO_OVERLAY_COST_OK));
}
} else if (err == STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY) {
SetDParam(0, cost.GetCost());
overlay_data.emplace_back(0, PAL_NONE, GetString(CM_STR_BUILD_INFO_OVERLAY_COST_NO_MONEY));
} else {
if (err == INVALID_STRING_ID) {
overlay_data.emplace_back(0, PAL_NONE, GetString(CM_STR_BUILD_INFO_OVERLAY_ERROR_UNKNOWN));
} else {
SetDParam(0, err);
overlay_data.emplace_back(0, PAL_NONE, GetString(CM_STR_BUILD_INFO_OVERLAY_ERROR));
}
auto extra_err = cost.GetExtraErrorMessage();
if (extra_err != INVALID_STRING_ID) {
SetDParam(0, extra_err);
overlay_data.emplace_back(0, PAL_NONE, GetString(CM_STR_BUILD_INFO_OVERLAY_ERROR));
}
}
}
/* Update overlay */
if (overlay_data.size() > 0) {
auto w = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
if (w == nullptr) { HideBuildInfoOverlay(); return; }
auto vp = IsPtInWindowViewport(w, _cursor.pos.x, _cursor.pos.y);
if (vp == nullptr) { HideBuildInfoOverlay(); return; }
Point pto = RemapCoords2(TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE);
pto.x = UnScaleByZoom(pto.x - vp->virtual_left, vp->zoom) + vp->left;
pto.y = UnScaleByZoom(pto.y - vp->virtual_top, vp->zoom) + vp->top;
ShowBuildInfoOverlay(pto.x, pto.y, overlay_data);
} else {
HideBuildInfoOverlay();
}
}
bool _prev_left_button_down = false;
@@ -2444,35 +2551,35 @@ bool HandleMouseMove() {
bool released = !_left_button_down && changed && _keep_mouse_click;
if (!_left_button_down) _keep_mouse_click = false;
if (_ap.preview == nullptr) return false;
if (_at.tool == nullptr) return false;
// Viewport *vp = IsPtInWindowViewport(w, );
auto pt = GetTileBelowCursor();
if (pt.x == -1) return false;
auto tile = pt.x == -1 ? INVALID_TILE : TileVirtXY(pt.x, pt.y);
_ap.preview->Update(pt, tile);
_ap.preview->HandleMouseMove();
_at.tool->Update(pt, tile);
_at.tool->HandleMouseMove();
if (_left_button_down) {
if (changed && _ap.preview->HandleMousePress()) {
if (changed && _at.tool->HandleMousePress()) {
_keep_mouse_click = true;
}
if (_keep_mouse_click) return true;
}
if (released) {
_ap.preview->HandleMouseRelease();
_at.tool->HandleMouseRelease();
}
return false;
}
bool HandleMouseClick(Viewport *vp, bool double_click) {
if (_ap.preview == nullptr) return false;
if (_at.tool == nullptr) return false;
auto pt = GetTileBelowCursor();
auto tile = pt.x == -1 ? INVALID_TILE : TileVirtXY(pt.x, pt.y);
_ap.preview->Update(pt, tile);
return _ap.preview->HandleMouseClick(vp, pt, tile, double_click);
_at.tool->Update(pt, tile);
return _at.tool->HandleMouseClick(vp, pt, tile, double_click);
}
bool HandlePlacePushButton(Window *w, WidgetID widget, up<Preview> preview) {
bool HandlePlacePushButton(Window *w, WidgetID widget, up<Tool> tool) {
if (w->IsWidgetDisabled(widget)) return false;
if (_settings_client.sound.click_beep) SndPlayFx(SND_15_BEEP);
@@ -2485,13 +2592,13 @@ bool HandlePlacePushButton(Window *w, WidgetID widget, up<Preview> preview) {
w->LowerWidget(widget);
auto icon = preview->GetCursor();
auto icon = tool->GetCursor();
if ((icon & ANIMCURSOR_FLAG) != 0) {
SetAnimatedMouseCursor(_animcursors[icon & ~ANIMCURSOR_FLAG]);
} else {
SetMouseCursor(icon, PAL_NONE);
}
citymania::SetActivePreview(std::move(preview));
citymania::SetActiveTool(std::move(tool));
_thd.window_class = w->window_class;
_thd.window_number = w->window_number;
@@ -2499,5 +2606,4 @@ bool HandlePlacePushButton(Window *w, WidgetID widget, up<Preview> preview) {
}
} // namespace citymania

10
src/citymania/cm_highlight.hpp
View File

@@ -57,13 +57,13 @@ PaletteID GetTreeShadePal(TileIndex tile);
void RotateAutodetection();
void ResetRotateAutodetection();
void ResetActivePreview();
void SetActivePreview(up<Preview> &&preview);
void UpdateActivePreview();
const up<Preview> &GetActivePreview();
void ResetActiveTool();
void SetActiveTool(up<Tool> &&tool);
void UpdateActiveTool();
const up<Tool> &GetActiveTool();
bool HandlePlacePushButton(Window *w, WidgetID widget, up<Preview> preview);
bool HandlePlacePushButton(Window *w, WidgetID widget, up<Tool> tool);
bool HandleMouseMove();
bool HandleMouseClick(Viewport *vp, bool double_click);

86
src/citymania/cm_highlight_type.hpp
View File

@@ -23,6 +23,7 @@
#include <vector>
#include "cm_command_type.hpp"
#include "cm_overlays.hpp"
namespace citymania {
@@ -313,6 +314,26 @@ public:
std::multimap<TileIndex, ObjectTileHighlight> GetTiles(TileIndex tile);
};
class HighlightMap {
public:
typedef std::map<TileIndex, std::vector<ObjectTileHighlight>> MapType;
typedef decltype(std::views::keys(std::declval<const MapType &>())) MapTypeKeys;
protected:
MapType map;
public:
const MapType &GetMap() const;
void Add(TileIndex tile, ObjectTileHighlight oth);
bool Contains(TileIndex tile) const;
std::optional<std::reference_wrapper<const std::vector<ObjectTileHighlight>>> GetForTile(TileIndex tile) const;
MapTypeKeys GetAllTiles() const;
std::vector<TileIndex> UpdateWithMap(const HighlightMap &update);
void AddTileArea(const TileArea &area, SpriteID palette);
void AddTileAreaWithBorder(const TileArea &area, SpriteID palette);
void AddTilesBorder(const std::set<TileIndex> &tiles, SpriteID palette);
};
class ObjectHighlight {
public:
enum class Type : byte {
@@ -325,6 +346,7 @@ public:
BLUEPRINT = 6,
POLYRAIL = 7,
INDUSTRY = 8,
DOCK = 9,
};
Type type = Type::NONE;
@@ -352,7 +374,7 @@ protected:
bool tiles_updated = false;
std::multimap<TileIndex, ObjectTileHighlight> tiles;
std::vector<DetachedHighlight> sprites = {};
std::vector<std::pair<SpriteID, std::string>> overlay_data = {};
BuildInfoOverlayData overlay_data = {};
// Point overlay_pos = {0, 0};
void AddTile(TileIndex tile, ObjectTileHighlight &&oh);
// void AddSprite(TileIndex tile, ObjectTileHighlight &&oh);
@@ -373,8 +395,11 @@ public:
TileIndex start_tile2, TileIndex end_tile2, Trackdir trackdir2);
static ObjectHighlight make_industry(TileIndex tile, IndustryType ind_type, uint32 ind_layout);
static ObjectHighlight make_dock(TileIndex tile, DiagDirection orientation);
TileHighlight GetTileHighlight(const TileInfo *ti);
HighlightMap GetHighlightMap(SpriteID palette);
std::optional<TileArea> GetArea();
void Draw(const TileInfo *ti);
void DrawSelectionOverlay(DrawPixelInfo *dpi);
void DrawOverlay(DrawPixelInfo *dpi);
@@ -384,24 +409,7 @@ public:
void MarkDirty();
};
class HighlightMap {
public:
typedef std::map<TileIndex, std::vector<ObjectTileHighlight>> MapType;
typedef decltype(std::views::keys(std::declval<const MapType &>())) MapTypeKeys;
protected:
MapType map;
public:
const MapType &GetMap() const;
void Add(TileIndex tile, ObjectTileHighlight oth);
bool Contains(TileIndex tile) const;
std::optional<std::reference_wrapper<const std::vector<ObjectTileHighlight>>> GetForTile(TileIndex tile) const;
MapTypeKeys GetAllTiles() const;
std::vector<TileIndex> UpdateWithMap(const HighlightMap &update);
void AddTileArea(const TileArea &area, SpriteID palette);
void AddTileAreaWithBorder(const TileArea &area, SpriteID palette);
void AddTilesBorder(const std::set<TileIndex> &tiles, SpriteID palette);
};
typedef std::tuple<HighlightMap, BuildInfoOverlayData, CommandCost> ToolGUIInfo;
class Preview {
public:
@@ -411,7 +419,38 @@ public:
virtual bool HandleMousePress() { return false; };
virtual void HandleMouseRelease() {};
virtual bool HandleMouseClick(Viewport* /* vp */, Point /* pt */, TileIndex /* tile */, bool /* double_click */) { return false; };
virtual HighlightMap GetHighlightMap() = 0;
virtual std::pair<HighlightMap, BuildInfoOverlayData> GetGUIInfo() = 0;
virtual CursorID GetCursor() = 0;
virtual void OnStationRemoved(const Station* /* station */) {};
};
class Action {
public:
virtual ~Action() = default;
virtual void Update(Point pt, TileIndex tile) = 0;
virtual std::optional<TileArea> GetArea() const { return std::nullopt; };
virtual void HandleMouseMove() {};
virtual bool HandleMousePress() { return false; };
virtual void HandleMouseRelease() {};
virtual bool HandleMouseClick(Viewport* vp, Point pt, TileIndex tile, bool double_click) {
(void)vp; (void)pt; (void)tile; (void)double_click;
return false;
};
virtual ToolGUIInfo GetGUIInfo() = 0;
virtual void OnStationRemoved(const Station *);
};
class Tool {
protected:
up<Action> action = nullptr;
public:
virtual ~Tool() = default;
virtual void Update(Point pt, TileIndex tile) = 0;
virtual void HandleMouseMove() { if(this->action) this->action->HandleMouseMove(); };
virtual bool HandleMousePress() { return this->action ? this->action->HandleMousePress() : false; }
virtual void HandleMouseRelease() { if(this->action) this->action->HandleMouseRelease(); };
virtual bool HandleMouseClick(Viewport* vp, Point pt, TileIndex tile, bool double_click) { return this->action ? this->action->HandleMouseClick(vp, pt, tile, double_click) : false; };
virtual ToolGUIInfo GetGUIInfo() = 0;
virtual CursorID GetCursor() = 0;
virtual void OnStationRemoved(const Station* /* station */) {};
};
@@ -423,12 +462,13 @@ public:
// DragStop,
// };
struct ActivePreview {
up<Preview> preview;
struct ActiveTool {
up<Tool> tool;
HighlightMap tiles;
};
extern ActivePreview _ap;
extern ActiveTool _at;
} // namespace citymania

24
src/citymania/cm_overlays.cpp
View File

@@ -62,7 +62,7 @@ public:
}
void UpdateSize() {
this->padding = ScaleGUITrad(3);
this->padding = ScaleGUITrad(5);
auto dim = this->GetContentDimension();
this->box.width = dim.width + 2 * this->padding;
this->box.height = dim.height + 2 * this->padding;
@@ -181,8 +181,9 @@ public:
Dimension text_dim{0, 0};
Dimension icon_dim{0, 0};
for (const auto &[icon, s] : data) {
for (const auto &[indent, icon, s] : data) {
text_dim = maxdim(text_dim, GetStringBoundingBox(s));
text_dim.width += WidgetDimensions::scaled.hsep_indent * indent;
if (icon != PAL_NONE)
icon_dim = maxdim(icon_dim, GetSpriteSize(icon));
}
@@ -192,25 +193,26 @@ public:
if (icon_dim.width > 0)
this->text_ofs_x = icon_dim.width + this->padding;
return {
text_dim.width + this->text_ofs_x,
std::min<uint>(text_dim.width + this->text_ofs_x, ScaleGUITrad(500)),
(uint)data.size() * this->line_height - padding
};
}
std::pair<Point, Rect> GetPositions(Rect rect, int row, SpriteID icon) {
std::pair<Point, Rect> GetPositions(Rect rect, int row, uint indent, SpriteID icon) {
auto icon_height = this->max_height;
auto ofs_x = 0;
int ind = WidgetDimensions::scaled.hsep_indent * indent;
if (icon != PAL_NONE) {
icon_height = GetSpriteSize(icon).height;
ofs_x = this->text_ofs_x;
}
return {
{
rect.left,
rect.left + ind,
rect.top + row * this->line_height + (this->max_height - icon_height) / 2,
},
{
rect.left + ofs_x,
rect.left + ofs_x + ind,
rect.top + row * this->line_height + this->text_ofs_y,
rect.right,
rect.bottom
@@ -227,6 +229,11 @@ public:
~BuildInfoOverlay() override {}
void Show(int x, int y, BuildInfoOverlayData data) {
if (data.size() == 0) {
this->visible = false;
return;
}
if (this->visible && this->x == x && this->y == y && this->data == data) return;
this->x = x;
this->y = y;
this->data = data;
@@ -248,9 +255,8 @@ public:
void DrawContent(Rect rect) override {
int row = 0;
for (const auto &[icon, s] : this->data) {
auto [ipos, srect] = this->aligner.GetPositions(rect, row, icon);
for (const auto &[indent, icon, s] : this->data) {
auto [ipos, srect] = this->aligner.GetPositions(rect, row, indent, icon);
DrawString(srect.left, srect.right, srect.top, s);
if (icon != PAL_NONE)
DrawSprite(icon, PAL_NONE, ipos.x, ipos.y);

2
src/citymania/cm_overlays.hpp
View File

@@ -6,7 +6,7 @@
namespace citymania {
typedef std::vector<std::pair<SpriteID, std::string>> BuildInfoOverlayData;
typedef std::vector<std::tuple<uint, SpriteID, std::string>> BuildInfoOverlayData;
void UndrawOverlays(int left, int top, int right, int bottom);
void DrawOverlays();

1702
src/citymania/cm_station_gui.cpp
View File

File diff suppressed because it is too large Load Diff

408
src/citymania/cm_station_gui.hpp
View File

@@ -1,6 +1,7 @@
#ifndef CM_STATION_GUI_HPP
#define CM_STATION_GUI_HPP
#include "cm_command_type.hpp"
#include "cm_highlight_type.hpp"
#include "../core/geometry_type.hpp"
@@ -9,6 +10,9 @@
#include "../station_gui.h"
#include "../station_type.h"
#include <concepts>
#include <optional>
namespace citymania {
const DiagDirection DEPOTDIR_AUTO = DIAGDIR_END;
@@ -26,29 +30,15 @@ struct RailStationGUISettings {
uint16_t station_count; ///< Number of custom stations (if newstations is \c true )
};
enum class StationBuildingStatus {
IMPOSSIBLE = 0,
QUERY = 1,
JOIN = 2,
NEW = 3,
};
// void SetStationBiildingStatus(StationBuildingStatus status);
// void SetStationTileSelectSize(int w, int h, int catchment);
bool UseImprovedStationJoin();
void OnStationTileSetChange(const Station *station, bool adding, StationType type);
void OnStationPartBuilt(const Station *station);
void OnStationRemoved(const Station *station);
void PlaceRoadStop(TileIndex start_tile, TileIndex end_tile, RoadStopType stop_type, bool adjacent, RoadType rt, StringID err_msg);
void HandleStationPlacement(TileIndex start, TileIndex end);
void PlaceRail_Station(TileIndex tile);
void PlaceDock(TileIndex tile, TileIndex tile_to);
void PlaceAirport(TileIndex tile);
void SelectStationToJoin(const Station *station);
// void SelectStationToJoin(const Station *station);
// const Station *GetStationToJoin();
void MarkCoverageHighlightDirty();
bool CheckRedrawStationCoverage();
void AbortStationPlacement();
std::optional<std::string> GetStationCoverageAreaText(TileIndex tile, int w, int h, int rad, StationCoverageType sct, bool supplies);
@@ -58,6 +48,7 @@ DiagDirection AutodetectRoadObjectDirection(TileIndex tile, Point pt, RoadType r
DiagDirection AutodetectDriveThroughRoadStopDirection(TileArea area, Point pt, RoadType roadtype);
DiagDirection AutodetectRailObjectDirection(TileIndex tile, Point pt);
void SetSelectedStationToJoin(StationID station_id);
void ResetJoinStationHighlight();
struct OverlayParams {
@@ -66,144 +57,305 @@ struct OverlayParams {
StationCoverageType coverage_type;
};
class PreviewStationType {
// Remove action classes
class RemoveHandler {
public:
virtual ~RemoveHandler() = default;
virtual up<Command> GetCommand(TileArea area) = 0;
virtual bool Execute(TileArea area) = 0;
};
template<typename Handler>
concept ImplementsRemoveHandler = std::derived_from<Handler, RemoveHandler>;
template<ImplementsRemoveHandler Handler>
class RemoveAction : public Action {
private:
Handler handler;
TileIndex start_tile = INVALID_TILE;
TileIndex cur_tile = INVALID_TILE;
virtual ~PreviewStationType() {};
TileIndex GetStartTile() const { return start_tile == INVALID_TILE ? cur_tile : start_tile; }
virtual bool IsDragDrop() const { return true; };
virtual CursorID GetCursor() const =0;
virtual TileArea GetArea(bool remove_mode) const =0;
virtual void Update(Point /* pt */, TileIndex /* tile */) {};
virtual up<Command> GetCommand(bool adjacent, StationID join_to) const =0;
virtual up<Command> GetRemoveCommand() const =0;
virtual void AddPreviewTiles(HighlightMap &hlmap, SpriteID palette) const =0;
virtual bool Execute(up<Command> cmd, bool remove_mode) const =0;
virtual OverlayParams GetOverlayParams() const =0;
};
class RailStationPreview : public PreviewStationType {
public:
virtual ~RailStationPreview() {};
// RailPreviewStation(RailStationGUISettings &settings) :settings{settings} {}
bool IsDragDrop() const override;
CursorID GetCursor() const override;
TileArea GetArea(bool remove_mode) const override;
up<Command> GetCommand(bool adjacent, StationID join_to) const override;
up<Command> GetRemoveCommand() const override;
void AddPreviewTiles(HighlightMap &hlmap, SpriteID palette) const override;
bool Execute(up<Command> cmd, bool remove_mode) const override;
OverlayParams GetOverlayParams() const override;
};
class RoadStationPreview : public PreviewStationType {
protected:
DiagDirection ddir;
RoadStopType stop_type;
public:
RoadStationPreview(RoadStopType stop_type) :stop_type{stop_type} {}
virtual ~RoadStationPreview() {};
bool IsDragDrop() const override;
CursorID GetCursor() const override;
TileArea GetArea(bool remove_mode) const override;
RemoveAction(const Handler &handler) : handler{handler} {}
~RemoveAction() override = default;
void Update(Point pt, TileIndex tile) override;
up<Command> GetCommand(bool adjacent, StationID join_to) const override;
up<Command> GetRemoveCommand() const override;
void AddPreviewTiles(HighlightMap &hlmap, SpriteID palette) const override;
bool Execute(up<Command> cmd, bool remove_mode) const override;
OverlayParams GetOverlayParams() const override;
std::optional<TileArea> GetArea() const override;
bool HandleMousePress() override;
void HandleMouseRelease() override;
ToolGUIInfo GetGUIInfo() override;
void OnStationRemoved(const Station *) override;
};
class DockPreview : public PreviewStationType {
protected:
DiagDirection ddir;
// StationSelect classes
class StationSelectHandler {
public:
DockPreview() {}
virtual ~DockPreview() {};
bool IsDragDrop() const override;
CursorID GetCursor() const override;
TileArea GetArea(bool remove_mode) const override;
void Update(Point pt, TileIndex tile) override;
up<Command> GetCommand(bool adjacent, StationID join_to) const override;
up<Command> GetRemoveCommand() const override;
void AddPreviewTiles(HighlightMap &hlmap, SpriteID palette) const override;
bool Execute(up<Command> cmd, bool remove_mode) const override;
OverlayParams GetOverlayParams() const override;
virtual ~StationSelectHandler() = default;
virtual void SelectStationToJoin(StationID station_id) = 0;
};
template<typename Handler>
concept ImplementsStationSelectHandler = std::derived_from<Handler, StationSelectHandler>;
class StationPreviewBase : public Preview {
protected:
sp<PreviewStationType> type;
bool remove_mode = false;
bool keep_rail = true; // whether to keep rail in remove mode
StationID station_to_join = INVALID_STATION;
bool adjacent_stations = false;
bool show_coverage = true;
void AddAreaTiles(HighlightMap &hlmap, bool add_current, bool show_join_area);
virtual void Execute() = 0;
up<Command> GetCommand(bool adjacent, StationID join_to);
void AddStationPreview(HighlightMap &hlmap, SpriteID palette);
template<ImplementsStationSelectHandler Handler>
class StationSelectAction : public Action {
private:
Handler handler;
TileIndex cur_tile = INVALID_TILE;
StationID selected_station = INVALID_STATION;
public:
StationPreviewBase(sp<PreviewStationType> type) :type{type} {};
CursorID GetCursor() override { return this->type->GetCursor(); };
StationSelectAction(const Handler &handler) : handler{handler} {}
~StationSelectAction() override = default;
void Update(Point pt, TileIndex tile) override;
bool HandleMousePress() override;
void HandleMouseRelease() override;
std::optional<std::string> GetStationCoverageAreaText(int rad, StationCoverageType sct, bool supplies);
std::vector<std::pair<SpriteID, std::string>> GetOverlayData();
};
class VanillaStationPreview : public StationPreviewBase {
protected:
SpriteID palette;
void Execute() override;
public:
StationID selected_station_to_join = INVALID_STATION;
VanillaStationPreview(sp<PreviewStationType> type) :StationPreviewBase{type} {};
virtual ~VanillaStationPreview() {};
void Update(Point pt, TileIndex tile) override;
HighlightMap GetHighlightMap() override;
ToolGUIInfo GetGUIInfo() override;
void OnStationRemoved(const Station *station) override;
};
class StationPreview : public StationPreviewBase {
protected:
bool select_mode = false;
void Execute() override;
up<Command> GetCommand();
// PlacementAction
class PlacementAction : public Action {
public:
StationPreview(sp<PreviewStationType> type);
virtual ~StationPreview();
~PlacementAction() override = default;
ToolGUIInfo PrepareGUIInfo(std::optional<ObjectHighlight> ohl, up<Command> cmd, StationCoverageType sct, uint rad);
};
// SizedPlacement classes
class SizedPlacementHandler {
public:
virtual ~SizedPlacementHandler() = default;
virtual up<Command> GetCommand(TileIndex tile, StationID to_join) = 0;
virtual bool Execute(TileIndex tile) = 0;
virtual std::optional<ObjectHighlight> GetObjectHighlight(TileIndex tile) = 0;
virtual std::pair<StationCoverageType, uint> GetCatchmentParams() = 0;
};
template<typename Handler>
concept ImplementsSizedPlacementHandler = std::derived_from<Handler, SizedPlacementHandler>;
template<ImplementsSizedPlacementHandler Handler>
class SizedPlacementAction : public PlacementAction {
private:
Handler handler;
TileIndex cur_tile = INVALID_TILE;
public:
SizedPlacementAction(const Handler &handler) : handler{handler} {}
~SizedPlacementAction() override = default;
void Update(Point pt, TileIndex tile) override;
std::optional<TileArea> GetArea() const override { return std::nullopt; };
bool HandleMousePress() override;
HighlightMap GetHighlightMap() override;
void OnStationRemoved(const Station *station) override;
void HandleMouseRelease() override;
ToolGUIInfo GetGUIInfo() override;
void OnStationRemoved(const Station *) override;
};
// SPR_CURSOR_BUS_STATION SPR_CURSOR_TRUCK_STATION
// DragNDropPlacement classes
class DragNDropPlacementHandler {
public:
virtual ~DragNDropPlacementHandler() = default;
virtual up<Command> GetCommand(TileArea area, StationID to_join) = 0;
virtual bool Execute(TileArea area) = 0;
virtual std::optional<ObjectHighlight> GetObjectHighlight(TileArea area) = 0;
virtual std::pair<StationCoverageType, uint> GetCatchmentParams() = 0;
};
template<typename Handler>
concept ImplementsDragNDropPlacementHandler = std::derived_from<Handler, DragNDropPlacementHandler>;
bool HandleStationPlacePushButton(Window *w, WidgetID widget, sp<PreviewStationType> type);
template<ImplementsDragNDropPlacementHandler Handler>
class DragNDropPlacementAction : public PlacementAction {
private:
TileIndex start_tile = INVALID_TILE;
TileIndex cur_tile = INVALID_TILE;
Handler handler;
public:
DragNDropPlacementAction(const Handler &handler) :handler{handler} {};
~DragNDropPlacementAction() override = default;
void Update(Point pt, TileIndex tile) override;
std::optional<TileArea> GetArea() const override;
bool HandleMousePress() override;
void HandleMouseRelease() override;
ToolGUIInfo GetGUIInfo() override;
void OnStationRemoved(const Station *) override;
};
class StationBuildTool : public Tool {
public:
static StationID station_to_join;
static StationID current_selected_station;
static std::optional<ObjectHighlight> active_highlight;
class StationSelectHandler : public citymania::StationSelectHandler {
public:
StationBuildTool &tool;
StationSelectHandler(StationBuildTool &tool) : tool(tool) {}
~StationSelectHandler() {}
void SelectStationToJoin(StationID station_id) override { this->tool.SelectStationToJoin(station_id); };
};
~StationBuildTool() override = default;
void SelectStationToJoin(StationID station_id) { StationBuildTool::station_to_join = station_id; };
ToolGUIInfo GetGUIInfo() override {
if (!this->action) return {};
return this->action->GetGUIInfo();
}
void OnStationRemoved(const Station *station) override {
if (this->action) this->action->OnStationRemoved(station);
}
protected:
template<typename Thandler, typename Tcallback, typename Targ>
bool ExecuteBuildCommand(Thandler *handler, Tcallback callback, Targ arg);
};
// RailStationBuildTool
class RailStationBuildTool : public StationBuildTool {
private:
class RemoveHandler : public citymania::RemoveHandler {
public:
RailStationBuildTool &tool;
RemoveHandler(RailStationBuildTool &tool) : tool(tool) {}
~RemoveHandler() override = default;
up<Command> GetCommand(TileArea area) override;
bool Execute(TileArea area) override;
};
class SizedPlacementHandler : public citymania::SizedPlacementHandler {
public:
RailStationBuildTool &tool;
SizedPlacementHandler(RailStationBuildTool &tool) : tool(tool) {}
~SizedPlacementHandler() override = default;
up<Command> GetCommand(TileIndex tile, StationID to_join) override;
bool Execute(TileIndex tile) override;
std::optional<ObjectHighlight> GetObjectHighlight(TileIndex tile) override;
std::pair<StationCoverageType, uint> GetCatchmentParams() override { return {this->tool.GetCatchmentParams()}; };
};
class DragNDropPlacementHandler: public citymania::DragNDropPlacementHandler {
public:
RailStationBuildTool &tool;
DragNDropPlacementHandler(RailStationBuildTool &tool) :tool{tool} {}
~DragNDropPlacementHandler() override = default;
up<Command> GetCommand(TileArea area, StationID to_join) override;
bool Execute(TileArea area) override;
std::optional<ObjectHighlight> GetObjectHighlight(TileArea area) override;
std::pair<StationCoverageType, uint> GetCatchmentParams() override { return {this->tool.GetCatchmentParams()}; };
};
std::optional<ObjectHighlight> GetStationObjectHighlight(TileIndex start_tile, TileIndex end_tile) const;
std::pair<StationCoverageType, uint> GetCatchmentParams() { return {SCT_ALL, CA_TRAIN}; };
public:
RailStationBuildTool();
~RailStationBuildTool() override = default;
void Update(Point pt, TileIndex tile) override;
CursorID GetCursor() override;
private:
enum class Mode { REMOVE, SELECT, DRAGDROP, SIZED };
Mode mode;
};
// RoadStopBuildTool
class RoadStopBuildTool : public StationBuildTool {
private:
class RemoveHandler : public citymania::RemoveHandler {
public:
RoadStopBuildTool &tool;
RemoveHandler(RoadStopBuildTool &tool) : tool(tool) {}
~RemoveHandler() override = default;
up<Command> GetCommand(TileArea area) override;
bool Execute(TileArea area) override;
};
class DragNDropPlacementHandler: public citymania::DragNDropPlacementHandler {
public:
RoadStopBuildTool &tool;
DragNDropPlacementHandler(RoadStopBuildTool &tool) :tool{tool} {}
~DragNDropPlacementHandler() override = default;
up<Command> GetCommand(TileArea area, StationID to_join) override;
bool Execute(TileArea area) override;
std::optional<ObjectHighlight> GetObjectHighlight(TileArea area) override;
std::pair<StationCoverageType, uint> GetCatchmentParams() override { return this->tool.GetCatchmentParams(); };
};
std::pair<StationCoverageType, uint> GetCatchmentParams() {
if (this->stop_type == ROADSTOP_BUS) return {SCT_PASSENGERS_ONLY, CA_BUS};
else return {SCT_NON_PASSENGERS_ONLY, CA_TRUCK};
};
public:
RoadStopBuildTool(RoadStopType stop_type);
~RoadStopBuildTool() override = default;
void Update(Point pt, TileIndex tile) override;
CursorID GetCursor() override;
private:
enum class Mode { REMOVE, SELECT, DRAGDROP };
Mode mode;
RoadStopType stop_type;
DiagDirection ddir = DIAGDIR_NE;
};
// --- DockBuildTool ---
class DockBuildTool : public StationBuildTool {
private:
class RemoveHandler : public citymania::RemoveHandler {
public:
DockBuildTool &tool;
RemoveHandler(DockBuildTool &tool) : tool(tool) {}
~RemoveHandler() override = default;
up<Command> GetCommand(TileArea area) override;
bool Execute(TileArea area) override;
};
class SizedPlacementHandler : public citymania::SizedPlacementHandler {
public:
DockBuildTool &tool;
SizedPlacementHandler(DockBuildTool &tool) : tool(tool) {}
~SizedPlacementHandler() override = default;
up<Command> GetCommand(TileIndex tile, StationID to_join) override;
bool Execute(TileIndex tile) override;
std::optional<ObjectHighlight> GetObjectHighlight(TileIndex tile) override;
std::pair<StationCoverageType, uint> GetCatchmentParams() override { return {SCT_ALL, CA_DOCK}; };
};
public:
DockBuildTool();
~DockBuildTool() override = default;
void Update(Point pt, TileIndex tile) override;
CursorID GetCursor() override;
private:
enum class Mode { REMOVE, SELECT, SIZED };
Mode mode;
DiagDirection ddir;
};
// --- AirportBuildTool ---
class AirportBuildTool : public StationBuildTool {
private:
class RemoveHandler : public citymania::RemoveHandler {
public:
AirportBuildTool &tool;
RemoveHandler(AirportBuildTool &tool) : tool(tool) {}
~RemoveHandler() override = default;
up<Command> GetCommand(TileArea area) override;
bool Execute(TileArea area) override;
};
class SizedPlacementHandler : public citymania::SizedPlacementHandler {
public:
AirportBuildTool &tool;
SizedPlacementHandler(AirportBuildTool &tool) : tool(tool) {}
~SizedPlacementHandler() override = default;
up<Command> GetCommand(TileIndex tile, StationID to_join) override;
bool Execute(TileIndex tile) override;
std::optional<ObjectHighlight> GetObjectHighlight(TileIndex tile) override;
std::pair<StationCoverageType, uint> GetCatchmentParams() override;
};
public:
AirportBuildTool();
~AirportBuildTool() override = default;
void Update(Point pt, TileIndex tile) override;
CursorID GetCursor() override;
private:
enum class Mode { REMOVE, SELECT, SIZED };
Mode mode;
};
ToolGUIInfo GetSelectedStationGUIInfo();
} // namespace citymania

51
src/citymania/cm_type.hpp
View File

@@ -6,6 +6,7 @@
#include <cstddef>
#include <memory>
#include <sstream>
#include <type_traits>
#include <utility>
@@ -72,6 +73,56 @@ enum class ControllerType: uint8_t {
TOWN_DEFENCE = 6,
};
// Some utility funcitons for strings
namespace string {
template<typename T>
static inline std::string join(T strings, std::string separator) {
// TODO add map function (can be used in ListGameModeCodes)?
std::ostringstream res;
bool first = true;
for (auto s: strings) {
if (!first)res << separator;
res << s;
first = false;
}
return res.str();
}
static inline void iltrim(std::string &s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int c) {
return !std::isspace(c);
}));
}
static inline void irtrim(std::string &s) {
s.erase(std::find_if(s.rbegin(), s.rend(), [](int c) {
return !std::isspace(c);
}).base(), s.end());
}
static inline void itrim(std::string &s) {
iltrim(s);
irtrim(s);
}
static inline std::string ltrim(std::string s) {
iltrim(s);
return s;
}
static inline std::string rtrim(std::string s) {
irtrim(s);
return s;
}
static inline std::string trim(std::string s) {
itrim(s);
return s;
}
}; // namespace string
} // namespace citymania

24
src/citymania/generated/cm_gen_commands.hpp
View File

@@ -237,16 +237,14 @@ public:
Commands get_command() override;
};
class BuildAirport: public Command {
class BuildAirport: public StationBuildCommand {
public:
TileIndex tile;
byte airport_type;
byte layout;
StationID station_to_join;
bool adjacent;
BuildAirport(TileIndex tile, byte airport_type, byte layout, StationID station_to_join, bool adjacent)
:tile{tile}, airport_type{airport_type}, layout{layout}, station_to_join{station_to_join}, adjacent{adjacent} {}
:StationBuildCommand{station_to_join, adjacent}, tile{tile}, airport_type{airport_type}, layout{layout} {}
~BuildAirport() override {}
bool _post(::CommandCallback * callback) override;
@@ -254,14 +252,12 @@ public:
Commands get_command() override;
};
class BuildDock: public Command {
class BuildDock: public StationBuildCommand {
public:
TileIndex tile;
StationID station_to_join;
bool adjacent;
BuildDock(TileIndex tile, StationID station_to_join, bool adjacent)
:tile{tile}, station_to_join{station_to_join}, adjacent{adjacent} {}
:StationBuildCommand{station_to_join, adjacent}, tile{tile} {}
~BuildDock() override {}
bool _post(::CommandCallback * callback) override;
@@ -269,7 +265,7 @@ public:
Commands get_command() override;
};
class BuildRailStation: public Command {
class BuildRailStation: public StationBuildCommand {
public:
TileIndex tile_org;
RailType rt;
@@ -278,11 +274,9 @@ public:
byte plat_len;
StationClassID spec_class;
uint16_t spec_index;
StationID station_to_join;
bool adjacent;
BuildRailStation(TileIndex tile_org, RailType rt, Axis axis, byte numtracks, byte plat_len, StationClassID spec_class, uint16_t spec_index, StationID station_to_join, bool adjacent)
:tile_org{tile_org}, rt{rt}, axis{axis}, numtracks{numtracks}, plat_len{plat_len}, spec_class{spec_class}, spec_index{spec_index}, station_to_join{station_to_join}, adjacent{adjacent} {}
:StationBuildCommand{station_to_join, adjacent}, tile_org{tile_org}, rt{rt}, axis{axis}, numtracks{numtracks}, plat_len{plat_len}, spec_class{spec_class}, spec_index{spec_index} {}
~BuildRailStation() override {}
bool _post(::CommandCallback * callback) override;
@@ -305,7 +299,7 @@ public:
Commands get_command() override;
};
class BuildRoadStop: public Command {
class BuildRoadStop: public StationBuildCommand {
public:
TileIndex tile;
uint8_t width;
@@ -316,11 +310,9 @@ public:
RoadType rt;
RoadStopClassID spec_class;
uint16_t spec_index;
StationID station_to_join;
bool adjacent;
BuildRoadStop(TileIndex tile, uint8_t width, uint8_t length, RoadStopType stop_type, bool is_drive_through, DiagDirection ddir, RoadType rt, RoadStopClassID spec_class, uint16_t spec_index, StationID station_to_join, bool adjacent)
:tile{tile}, width{width}, length{length}, stop_type{stop_type}, is_drive_through{is_drive_through}, ddir{ddir}, rt{rt}, spec_class{spec_class}, spec_index{spec_index}, station_to_join{station_to_join}, adjacent{adjacent} {}
:StationBuildCommand{station_to_join, adjacent}, tile{tile}, width{width}, length{length}, stop_type{stop_type}, is_drive_through{is_drive_through}, ddir{ddir}, rt{rt}, spec_class{spec_class}, spec_index{spec_index} {}
~BuildRoadStop() override {}
bool _post(::CommandCallback * callback) override;

17
src/dock_gui.cpp
View File

@@ -38,10 +38,12 @@
#include "table/sprites.h"
#include "table/strings.h"
#include "citymania/cm_highlight.hpp"
#include "citymania/cm_hotkeys.hpp"
#include "citymania/cm_station_gui.hpp"
#include "safeguards.h"
#include <memory>
static void ShowBuildDockStationPicker(Window *parent);
static void ShowBuildDocksDepotPicker(Window *parent);
@@ -171,8 +173,8 @@ struct BuildDocksToolbarWindow : Window {
break;
case WID_DT_STATION: // Build station button
// if (HandlePlacePushButton(this, WID_DT_STATION, SPR_CURSOR_DOCK, HT_SPECIAL, CM_DDSP_BUILD_DOCK)) ShowBuildDockStationPicker(this);
if (citymania::HandleStationPlacePushButton(this, WID_DT_STATION, std::make_shared<citymania::DockPreview>())) {
// if (HandlePlacePushButton(this, WID_DT_STATION, SPR_CURSOR_DOCK, HT_SPECIAL, CM_DDSP_BUILD_DOCK)) {
if (citymania::HandlePlacePushButton(this, WID_DT_STATION, std::make_unique<citymania::DockBuildTool>())) {
ShowBuildDockStationPicker(this);
}
@@ -218,14 +220,13 @@ struct BuildDocksToolbarWindow : Window {
break;
case WID_DT_STATION: { // Build station button
NOT_REACHED(); // CityMania uses tools
/* Determine the watery part of the dock. */
/*
DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile));
TileIndex tile_to = (dir != INVALID_DIAGDIR ? TileAddByDiagDir(tile, ReverseDiagDir(dir)) : tile);
if (citymania::UseImprovedStationJoin()) {
citymania::PlaceDock(tile, tile_to);
break;
}
bool adjacent = citymania::_fn_mod;
auto proc = [=](bool test, StationID to_join) -> bool {
@@ -237,7 +238,7 @@ struct BuildDocksToolbarWindow : Window {
};
ShowSelectStationIfNeeded(TileArea(tile, tile_to), proc);
break;
break; */
}
case WID_DT_BUOY: // Build buoy button
@@ -290,7 +291,7 @@ struct BuildDocksToolbarWindow : Window {
CloseWindowById(WC_BUILD_DEPOT, TRANSPORT_WATER);
CloseWindowById(WC_SELECT_STATION, 0);
CloseWindowByClass(WC_BUILD_BRIDGE);
citymania::AbortStationPlacement();
}

22
src/lang/english.txt
View File

@@ -6298,13 +6298,26 @@ CM_BUILDING_PREVIEW_COST_ENOUGH :Cost
CM_STR_NO_BLUEPRINT_IN_SLOT :{WHITE}No blueprint in slot {NUM}
CM_STR_ABOUT_MENU_LOGIN_WINDOW :CityMania server login
CM_STR_BUILD_INFO_OVERLAY_COST_OK :{WHITE}Cost: {CURRENCY_LONG}
CM_STR_BUILD_INFO_OVERLAY_COST_OK :{GREEN}Cost: {CURRENCY_LONG}
CM_STR_BUILD_INFO_OVERLAY_COST_NO_MONEY :{RED}Cost: {CURRENCY_LONG}
CM_STR_BUILD_INFO_OVERLAY_STATION_ACCEPTS :{WHITE}Accepts:
CM_STR_BULID_INFO_OVERLAY_ACCEPTS_CARGO_PARTIAL :{SILVER}{CARGO_LIST}({NUM}/8)
CM_STR_BULID_INFO_OVERLAY_ACCEPTS_CARGO_FULL :{GOLD}{CARGO_LIST}({NUM}/8)
CM_STR_BULID_INFO_OVERLAY_ACCEPTS_CARGO :{GOLD}{CARGO_LIST}
CM_STR_BULID_INFO_OVERLAY_ACCEPTS :{WHITE}Accepts: {GOLD}{RAW_STRING}
CM_STR_BUILD_INFO_OVERLAY_STATION_SUPPLIES :{WHITE}Supplies:
CM_STR_BUILD_INFO_OVERLAY_STATION_CARGO :{WHITE}{CARGO_LONG}
CM_STR_BUILD_INFO_OVERLAY_ERROR :{RED}{STRING}
CM_STR_BUILD_INFO_OVERLAY_STATION_CARGO :{GOLD}{CARGO_LONG}
CM_STR_BUILD_INFO_OVERLAY_ERROR :{RED}Error: {STRING}
CM_STR_BUILD_INFO_OVERLAY_ERROR_UNKNOWN :{RED}Unknown Error!
CM_STR_BULID_INFO_OVERLAY_JOIN_STATION :{LTBLUE}Join {STATION}
CM_STR_BULID_INFO_OVERLAY_NEW_STATION :{GOLD}New station
CM_STR_BULID_INFO_OVERLAY_TOWN_NONE :{WHITE}Town: {GOLD}None
CM_STR_BULID_INFO_OVERLAY_TOWN_ALLOWS :{WHITE}Town: {GREEN}{TOWN}[{NUM}], {STRING}
CM_STR_BULID_INFO_OVERLAY_TOWN_DENIES :{WHITE}Town: {RED}{TOWN}[{NUM}], {STRING}
CM_STR_BULID_INFO_OVERLAY_TOWN_NO_ADS :{WHITE}no ad zone
CM_STR_BULID_INFO_OVERLAY_TOWN_L_ADS :{GOLD}large {WHITE}ad zone
CM_STR_BULID_INFO_OVERLAY_TOWN_M_ADS :{GOLD}medium {WHITE}ad zone
CM_STR_BULID_INFO_OVERLAY_TOWN_S_ADS :{GOLD}small {WHITE}ad zone
CM_STR_BULID_INFO_OVERLAY_STATION_SIZE :{WHITE}Size: {GOLD}{NUM}x{NUM}
CM_STR_VEHICLE_INFO_BUILT_VALUE_WITH_ID :{LTBLUE}{ENGINE} {BLACK}Built: {LTBLUE}{NUM}{BLACK} Value: {LTBLUE}{CURRENCY_LONG}{BLACK} ID: {LTBLUE}{NUM}
@@ -6316,3 +6329,4 @@ CM_STR_SHOW_HIDDEN_ENGINES_VEHICLE_TRAIN :{BLACK}Show
CM_STR_SHOW_HIDDEN_ENGINES_VEHICLE_ROAD_VEHICLE :{BLACK}Show hidden ({NUM})
CM_STR_SHOW_HIDDEN_ENGINES_VEHICLE_SHIP :{BLACK}Show hidden ({NUM})
CM_STR_SHOW_HIDDEN_ENGINES_VEHICLE_AIRCRAFT :{BLACK}Show hidden ({NUM})

7
src/main_gui.cpp
View File

@@ -81,13 +81,6 @@ bool HandlePlacePushButton(Window *w, WidgetID widget, CursorID cursor, HighLigh
}
SetObjectToPlace(cursor, PAL_NONE, mode, w->window_class, w->window_number, cm_process);
// if (cm_process == DDSP_BUILD_STATION) {
// if (citymania::UseImprovedStationJoin()) {
// citymania::SetActivePreview(std::make_unique<citymania::StationPreview>());
// } else {
// citymania::SetActivePreview(std::make_unique<citymania::VanillaStationPreview>());
// }
// }
w->LowerWidget(widget);
return true;
}

17
src/rail_gui.cpp
View File

@@ -202,6 +202,7 @@ void CcStation(Commands, const CommandCost &result, TileIndex tile)
*/
static void PlaceRail_Station(TileIndex tile)
{
NOT_REACHED(); // CityMania uses tools
if (_remove_button_clicked) {
VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_BUILD_STATION);
VpSetPlaceSizingLimit(-1);
@@ -209,10 +210,6 @@ static void PlaceRail_Station(TileIndex tile)
VpStartPlaceSizing(tile, VPM_X_AND_Y_LIMITED, DDSP_BUILD_STATION);
VpSetPlaceSizingLimit(_settings_game.station.station_spread);
} else {
if (citymania::UseImprovedStationJoin()) {
citymania::PlaceRail_Station(tile);
return;
}
int w = _settings_client.gui.station_numtracks;
int h = _settings_client.gui.station_platlength;
if (!_railstation.orientation) Swap(w, h);
@@ -680,13 +677,13 @@ struct BuildRailToolbarWindow : Window {
if (was_open) ResetObjectToPlace();
if (!was_open || dragdrop != _settings_client.gui.station_dragdrop) {
_settings_client.gui.station_dragdrop = dragdrop;
if (citymania::HandleStationPlacePushButton(this, WID_RAT_BUILD_STATION, std::make_shared<citymania::RailStationPreview>()))
if (citymania::HandlePlacePushButton(this, WID_RAT_BUILD_STATION, std::make_unique<citymania::RailStationBuildTool>()))
// if (HandlePlacePushButton(this, WID_RAT_BUILD_STATION, SPR_CURSOR_BRIDGE, HT_RECT, DDSP_BUILD_STATION))
ShowStationBuilder(this);
}
this->last_user_action = WID_RAT_BUILD_STATION;
} else { /* button */
if (citymania::HandleStationPlacePushButton(this, WID_RAT_BUILD_STATION, std::make_shared<citymania::RailStationPreview>())) {
if (citymania::HandlePlacePushButton(this, WID_RAT_BUILD_STATION, std::make_unique<citymania::RailStationBuildTool>())) {
// if (HandlePlacePushButton(this, WID_RAT_BUILD_STATION, SPR_CURSOR_BRIDGE, HT_RECT, DDSP_BUILD_STATION)) {
ShowStationBuilder(this);
this->last_user_action = WID_RAT_BUILD_STATION;
@@ -1043,7 +1040,7 @@ struct BuildRailToolbarWindow : Window {
Hotkey((uint16)0, "cm_blueprint_save_7", HOTKEY_BLUEPRINT_SAVE + 7),
Hotkey((uint16)0, "cm_blueprint_save_8", HOTKEY_BLUEPRINT_SAVE + 8),
Hotkey((uint16)0, "cm_blueprint_save_9", HOTKEY_BLUEPRINT_SAVE + 9),
Hotkey(CM_WKC_MOUSE_MIDDLE, "cm_blueprint_rotate", HOTKEY_BLUEPRINT_ROTATE),
Hotkey(CM_WKC_MOUSE_MIDDLE, "cm_blueprint_rotate", HOTKEY_BLUEPRINT_ROTATE),
}, RailToolbarGlobalHotkeys};
};
@@ -1125,11 +1122,7 @@ Window *ShowBuildRailToolbar(RailType railtype)
static void HandleStationPlacement(TileIndex start, TileIndex end)
{
if (citymania::UseImprovedStationJoin()) {
citymania::HandleStationPlacement(start, end);
return;
}
NOT_REACHED(); // CityMania uses tools
TileArea ta(start, end);
uint numtracks = ta.w;
uint platlength = ta.h;

21
src/road_gui.cpp
View File

@@ -52,6 +52,7 @@
#include "citymania/cm_station_gui.hpp"
#include "safeguards.h"
#include <memory>
static void ShowRVStationPicker(Window *parent, RoadStopType rs);
static void ShowRoadDepotPicker(Window *parent);
@@ -220,11 +221,7 @@ void CcRoadStop(Commands, const CommandCost &result, TileIndex tile, uint8_t wid
*/
static void PlaceRoadStop(TileIndex start_tile, TileIndex end_tile, RoadStopType stop_type, bool adjacent, RoadType rt, StringID err_msg)
{
if (citymania::UseImprovedStationJoin()) {
citymania::PlaceRoadStop(start_tile, end_tile, stop_type, adjacent, rt, err_msg);
return;
}
NOT_REACHED(); // CityMania uses tools
TileArea ta(start_tile, end_tile);
assert(_thd.cm.type == citymania::ObjectHighlight::Type::ROAD_STOP);
// DiagDirection ddir = _roadstop_gui_settings.orientation;
@@ -518,7 +515,8 @@ struct BuildRoadToolbarWindow : Window {
break;
case WID_ROT_BUS_STATION: {
if (citymania::HandleStationPlacePushButton(this, WID_ROT_BUS_STATION, std::make_shared<citymania::RoadStationPreview>(ROADSTOP_BUS))) {
if (citymania::HandlePlacePushButton(this, WID_ROT_BUS_STATION, std::make_unique<citymania::RoadStopBuildTool>(ROADSTOP_BUS))) {
// if (HandlePlacePushButton(this, WID_ROT_BUS_STATION, SPR_CURSOR_BUS_STATION, HT_RECT, DDSP_BUILD_BUSSTOP)) {
ShowRVStationPicker(this, ROADSTOP_BUS);
this->last_started_action = widget;
}
@@ -526,7 +524,8 @@ struct BuildRoadToolbarWindow : Window {
}
case WID_ROT_TRUCK_STATION:
if (citymania::HandleStationPlacePushButton(this, WID_ROT_TRUCK_STATION, std::make_shared<citymania::RoadStationPreview>(ROADSTOP_TRUCK))) {
if (citymania::HandlePlacePushButton(this, WID_ROT_TRUCK_STATION, std::make_unique<citymania::RoadStopBuildTool>(ROADSTOP_TRUCK))) {
// if (HandlePlacePushButton(this, WID_ROT_TRUCK_STATION, SPR_CURSOR_TRUCK_STATION, HT_RECT, DDSP_BUILD_TRUCKSTOP)) {
ShowRVStationPicker(this, ROADSTOP_TRUCK);
this->last_started_action = widget;
}
@@ -660,8 +659,8 @@ struct BuildRoadToolbarWindow : Window {
CloseWindowById(WC_BUILD_DEPOT, TRANSPORT_ROAD);
CloseWindowById(WC_SELECT_STATION, 0);
CloseWindowByClass(WC_BUILD_BRIDGE);
citymania::AbortStationPlacement();
citymania::AbortStationPlacement();
}
void OnPlaceDrag(ViewportPlaceMethod select_method, [[maybe_unused]] ViewportDragDropSelectionProcess select_proc, [[maybe_unused]] Point pt) override
@@ -1176,7 +1175,7 @@ static void ShowRoadDepotPicker(Window *parent)
/** Enum referring to the Hotkeys in the build road stop window */
enum BuildRoadStopHotkeys {
BROSHK_FOCUS_FILTER_BOX, ///< Focus the edit box for editing the filter string
CM_BROSHK_ROTATE,
CM_BROSHK_ROTATE,
};
struct BuildRoadStationWindow : public PickerWindowBase {
@@ -1797,7 +1796,7 @@ static constexpr NWidgetPart _nested_road_station_picker_widgets[] = {
NWidget(NWID_HORIZONTAL), SetPIP(0, WidgetDimensions::unscaled.hsep_normal, 0), SetPIPRatio(1, 0, 1),
NWidget(WWT_TEXTBTN, COLOUR_GREY, CM_WID_BROS_STATION_AUTO), SetMinimalSize(134, 12), SetDataTip(CM_STR_STATION_BUILD_ORIENTATION_AUTO, CM_STR_STATION_BUILD_ORIENTATION_AUTO_TOOLTIP),
NWidget(WWT_TEXTBTN, COLOUR_GREY, CM_WID_BROS_STATION_XY_AUTO), SetMinimalSize(66, 12), SetDataTip(CM_STR_STATION_BUILD_ORIENTATION_AUTO, CM_STR_STATION_BUILD_ORIENTATION_AUTO_TOOLTIP),
EndContainer(),
EndContainer(),
EndContainer(),
NWidget(NWID_SELECTION, INVALID_COLOUR, WID_BROS_SHOW_NEWST_TYPE_SEL),
NWidget(WWT_LABEL, COLOUR_DARK_GREEN, WID_BROS_SHOW_NEWST_TYPE), SetMinimalSize(144, 8), SetDataTip(STR_JUST_STRING, STR_NULL), SetTextStyle(TC_ORANGE), SetFill(1, 0),

21
src/station_gui.cpp
View File

@@ -59,13 +59,6 @@ int DrawStationCoverageAreaText(int left, int right, int top, StationCoverageTyp
{
TileIndex tile = TileVirtXY(_thd.pos.x, _thd.pos.y);
/* CityMania code begin */
auto s = citymania::GetStationCoverageAreaText(tile, _thd.size.x / TILE_SIZE, _thd.size.y / TILE_SIZE, rad, sct, supplies);
if (s.has_value()) {
return DrawStringMultiLine(left, right, top, INT32_MAX, s.value());
}
/* CityMania code end */
CargoTypes cargo_mask = 0;
if (_thd.drawstyle == HT_RECT && tile < Map::Size()) {
CargoArray cargoes;
@@ -156,14 +149,9 @@ void FindStationsAroundSelection()
*/
void CheckRedrawStationCoverage(Window *w)
{
/* CityMania code begin */
if (citymania::UseImprovedStationJoin()) {
if (citymania::CheckRedrawStationCoverage()) w->SetDirty();
return;
}
/* CityMania code end */
/* Test if ctrl state changed */
/* CityMania uses tools and handles redraws differently
static bool _last_fn_pressed;
if (citymania::_fn_mod != _last_fn_pressed) {
_thd.dirty = 0xff;
@@ -178,6 +166,7 @@ void CheckRedrawStationCoverage(Window *w)
FindStationsAroundSelection<Station>();
}
}
*/
}
void CheckRedrawWaypointCoverage(const Window *)
@@ -2351,7 +2340,7 @@ struct SelectStationWindow : WindowPopup {
void Close([[maybe_unused]] int data = 0) override
{
if constexpr (std::is_same_v<T, Waypoint *>) SetViewportCatchmentSpecializedStation<T>(nullptr, true);
else citymania::SetSelectedStationToJoin(INVALID_STATION);
else citymania::ResetJoinStationHighlight();
_thd.freeze = false;
this->Window::Close();
@@ -2448,7 +2437,7 @@ struct SelectStationWindow : WindowPopup {
auto it = this->vscroll->GetScrolledItemFromWidget(_stations_nearby_list, pt.y, this, WID_JS_PANEL, WidgetDimensions::scaled.framerect.top);
const T *st = it == _stations_nearby_list.end() || *it == NEW_STATION ? nullptr : T::Get(*it);
if constexpr (std::is_same_v<T, Waypoint>) SetViewportCatchmentSpecializedStation<T>(st, true);
else citymania::SetSelectedStationToJoin(*it);
else citymania::SetSelectedStationToJoin(st ? st->index : INVALID_STATION);
}
};

7
src/tilearea_type.h
View File

@@ -11,6 +11,7 @@
#define TILEAREA_TYPE_H
#include "map_func.h"
#include "tile_type.h"
class OrthogonalTileIterator;
class DiagonalTileIterator;
@@ -62,6 +63,12 @@ struct OrthogonalTileArea {
return TILE_ADDXY(this->tile, this->w / 2, this->h / 2);
}
TileIndex CMGetEndTile() const
{
if (this->w == 0 || this->h == 0 || this->tile == INVALID_TILE) return INVALID_TILE;
return TILE_ADDXY(this->tile, this->w - 1, this->h - 1);
}
OrthogonalTileIterator begin() const;
OrthogonalTileIterator end() const;

12
src/viewport.cpp
View File

@@ -243,7 +243,7 @@ static Point MapXYZToViewport(const Viewport *vp, int x, int y, int z)
}
void DeleteWindowViewport(Window *w)
{
{
delete w->viewport;
w->viewport = nullptr;
}
@@ -2916,7 +2916,7 @@ void UpdateTileSelection()
if ((new_drawstyle & HT_DRAG_MASK) != HT_NONE) SetSelectionTilesDirty();
}
citymania::UpdateActivePreview();
citymania::UpdateActiveTool();
}
/**
@@ -3645,7 +3645,7 @@ static void CalcRaildirsDrawstyle(int x, int y, int method)
/* CityMania code start */
_thd.dir2 = HT_DIR_END;
ShowLengthMeasurement(b, TileVirtXY(_thd.selstart.x, _thd.selstart.y), TileVirtXY(_thd.selend.x, _thd.selend.y));
ShowLengthMeasurement(b, TileVirtXY(_thd.selstart.x, _thd.selstart.y), TileVirtXY(_thd.selend.x, _thd.selend.y));
/* CityMania code end */
}
@@ -3826,7 +3826,7 @@ calc_heightdiff_single_direction:;
ShowMeasurementTooltips(measure_strings_length[index], index);
}
#endif
#endif
/* With current code passing a HT_LINE style to calculate the height
* difference is enough. However if/when a point-tool is created
* with this method, function should be called with new_style (below)
@@ -3995,7 +3995,7 @@ void SetObjectToPlaceWnd(CursorID icon, PaletteID pal, HighLightStyle mode, Wind
*/
void SetObjectToPlace(CursorID icon, PaletteID pal, HighLightStyle mode, WindowClass window_class, WindowNumber window_num, ViewportDragDropSelectionProcess cm_process)
{
citymania::ResetActivePreview();
citymania::ResetActiveTool();
if (_thd.window_class != WC_INVALID) {
/* Undo clicking on button and drag & drop */
Window *w = _thd.GetCallbackWnd();
@@ -4046,7 +4046,7 @@ void SetObjectToPlace(CursorID icon, PaletteID pal, HighLightStyle mode, WindowC
void ResetObjectToPlace()
{
SetObjectToPlace(SPR_CURSOR_MOUSE, PAL_NONE, HT_NONE, WC_MAIN_WINDOW, 0, CM_DDSP_NONE);
citymania::ResetActivePreview();
citymania::ResetActiveTool();
}
Point GetViewportStationMiddle(const Viewport *vp, const Station *st)