Merge branch 'enhanced_viewport_overlay-sx' into jgrpp
town_gui.cpp updated due to struct CommandContainer change. Conflicts: src/command.cpp src/command_type.h src/gfxinit.cpp src/openttd.cpp src/pbs.cpp src/saveload/extended_ver_sl.cpp src/saveload/extended_ver_sl.h src/saveload/saveload.cpp src/stdafx.h src/train_cmd.cpp src/viewport_type.h src/window_type.hpull/3/head
commit
7ed93f9211
Binary file not shown.
@ -0,0 +1,21 @@
|
||||
/* $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 plans.cpp Handling of plans. */
|
||||
|
||||
#include "stdafx.h"
|
||||
#include "plans_base.h"
|
||||
#include "core/pool_func.hpp"
|
||||
|
||||
/** Initialize the plan-pool */
|
||||
PlanPool _plan_pool("Plan");
|
||||
INSTANTIATE_POOL_METHODS(Plan)
|
||||
|
||||
Plan *_current_plan = NULL;
|
||||
Plan *_new_plan = NULL;
|
@ -0,0 +1,237 @@
|
||||
/* $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 plans_base.h Base class for plans. */
|
||||
|
||||
#ifndef PLANS_BASE_H
|
||||
#define PLANS_BASE_H
|
||||
|
||||
#include "plans_func.h"
|
||||
#include "core/pool_type.hpp"
|
||||
#include "company_type.h"
|
||||
#include "company_func.h"
|
||||
#include "command_func.h"
|
||||
#include "map_func.h"
|
||||
#include "date_func.h"
|
||||
#include "viewport_func.h"
|
||||
#include "core/endian_func.hpp"
|
||||
#include <vector>
|
||||
|
||||
typedef Pool<Plan, PlanID, 16, 64000> PlanPool;
|
||||
typedef std::vector<TileIndex> TileVector;
|
||||
typedef std::vector<PlanLine*> PlanLineVector;
|
||||
extern PlanPool _plan_pool;
|
||||
|
||||
struct PlanLine {
|
||||
bool visible;
|
||||
bool focused;
|
||||
TileVector tiles;
|
||||
|
||||
PlanLine()
|
||||
{
|
||||
this->visible = true;
|
||||
this->focused = false;
|
||||
}
|
||||
|
||||
~PlanLine()
|
||||
{
|
||||
this->Clear();
|
||||
}
|
||||
|
||||
void Clear()
|
||||
{
|
||||
this->tiles.clear();
|
||||
}
|
||||
|
||||
bool AppendTile(TileIndex tile)
|
||||
{
|
||||
const uint cnt = (uint) this->tiles.size();
|
||||
|
||||
if (cnt > 0) {
|
||||
const TileIndex last_tile = this->tiles[cnt - 1];
|
||||
if (last_tile == tile) return false;
|
||||
MarkTileLineDirty(last_tile, tile);
|
||||
|
||||
if (cnt > 1) {
|
||||
const TileIndex t0 = this->tiles[cnt - 2];
|
||||
const int x0 = (int) TileX(t0);
|
||||
const int y0 = (int) TileY(t0);
|
||||
const TileIndex t1 = this->tiles[cnt - 1];
|
||||
const int x1 = (int) TileX(t1);
|
||||
const int y1 = (int) TileY(t1);
|
||||
const int x2 = (int) TileX(tile);
|
||||
const int y2 = (int) TileY(tile);
|
||||
|
||||
if ((y1 - y0) * (x2 - x1) == (y2 - y1) * (x1 - x0)) { // Same direction.
|
||||
if (abs(x2 - x1) <= abs(x2 - x0) && abs(y2 - y1) <= abs(y2 - y0)) { // Tile i+1 is between i and i+2.
|
||||
/* The new tile is in the continuity, just update the last tile. */
|
||||
this->tiles[cnt - 1] = tile;
|
||||
MarkTileLineDirty(t1, tile);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this->tiles.size() * sizeof(TileIndex) >= MAX_CMD_TEXT_LENGTH) return false;
|
||||
|
||||
this->tiles.push_back(tile);
|
||||
return true;
|
||||
}
|
||||
|
||||
void SetFocus(bool focused)
|
||||
{
|
||||
if (this->focused != focused) this->MarkDirty();
|
||||
this->focused = focused;
|
||||
}
|
||||
|
||||
bool ToggleVisibility()
|
||||
{
|
||||
this->SetVisibility(!this->visible);
|
||||
return this->visible;
|
||||
}
|
||||
|
||||
void SetVisibility(bool visible)
|
||||
{
|
||||
if (this->visible != visible) this->MarkDirty();
|
||||
this->visible = visible;
|
||||
}
|
||||
|
||||
void MarkDirty()
|
||||
{
|
||||
const uint sz = (uint) this->tiles.size();
|
||||
for (uint i = 1; i < sz; i++) {
|
||||
MarkTileLineDirty(this->tiles[i-1], this->tiles[i]);
|
||||
}
|
||||
}
|
||||
|
||||
TileIndex *Export(uint *buffer_length)
|
||||
{
|
||||
const uint cnt = (uint) this->tiles.size();
|
||||
const uint datalen = sizeof(TileIndex) * cnt;
|
||||
TileIndex *buffer = (TileIndex *) malloc(datalen);
|
||||
if (buffer) {
|
||||
for (uint i = 0; i < cnt; i++) {
|
||||
buffer[i] = TO_LE32(this->tiles[i]);
|
||||
}
|
||||
if (buffer_length) *buffer_length = datalen;
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
||||
void Import(const TileIndex* data, const uint data_length)
|
||||
{
|
||||
for (uint i = data_length; i != 0; i--, data++) {
|
||||
this->tiles.push_back(FROM_LE32(*data));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct Plan : PlanPool::PoolItem<&_plan_pool> {
|
||||
OwnerByte owner;
|
||||
PlanLineVector lines;
|
||||
PlanLine *temp_line;
|
||||
bool visible;
|
||||
bool visible_by_all;
|
||||
bool show_lines;
|
||||
Date creation_date;
|
||||
|
||||
Plan(Owner owner = INVALID_OWNER)
|
||||
{
|
||||
this->owner = owner;
|
||||
this->creation_date = _date;
|
||||
this->visible = false;
|
||||
this->visible_by_all = false;
|
||||
this->show_lines = false;
|
||||
this->temp_line = new PlanLine();
|
||||
}
|
||||
|
||||
~Plan()
|
||||
{
|
||||
for (PlanLineVector::iterator it = lines.begin(); it != lines.end(); it++) {
|
||||
delete (*it);
|
||||
}
|
||||
this->lines.clear();
|
||||
delete temp_line;
|
||||
}
|
||||
|
||||
void SetFocus(bool focused)
|
||||
{
|
||||
for (PlanLineVector::iterator it = lines.begin(); it != lines.end(); it++) {
|
||||
(*it)->SetFocus(focused);
|
||||
}
|
||||
}
|
||||
|
||||
void SetVisibility(bool visible, bool do_lines = true)
|
||||
{
|
||||
this->visible = visible;
|
||||
|
||||
if (!do_lines) return;
|
||||
for (PlanLineVector::iterator it = lines.begin(); it != lines.end(); it++) {
|
||||
(*it)->SetVisibility(visible);
|
||||
}
|
||||
}
|
||||
|
||||
bool ToggleVisibility()
|
||||
{
|
||||
this->SetVisibility(!this->visible);
|
||||
return this->visible;
|
||||
}
|
||||
|
||||
PlanLine *NewLine()
|
||||
{
|
||||
PlanLine *pl = new PlanLine();
|
||||
if (pl) this->lines.push_back(pl);
|
||||
return pl;
|
||||
}
|
||||
|
||||
bool StoreTempTile(TileIndex tile)
|
||||
{
|
||||
return this->temp_line->AppendTile(tile);
|
||||
}
|
||||
|
||||
bool ValidateNewLine()
|
||||
{
|
||||
bool ret = false;
|
||||
if (this->temp_line->tiles.size() > 1) {
|
||||
uint buffer_length = 0;
|
||||
const TileIndex *buffer = this->temp_line->Export(&buffer_length);
|
||||
if (buffer) {
|
||||
_current_plan->SetVisibility(true, false);
|
||||
ret = DoCommandP(0, _current_plan->index, (uint32) this->temp_line->tiles.size(), CMD_ADD_PLAN_LINE, NULL, (const char *) buffer, true, buffer_length);
|
||||
free(buffer);
|
||||
}
|
||||
_current_plan->temp_line->MarkDirty();
|
||||
this->temp_line->Clear();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool IsListable()
|
||||
{
|
||||
return (this->owner == _local_company || this->visible_by_all);
|
||||
}
|
||||
|
||||
bool IsVisible()
|
||||
{
|
||||
if (!this->IsListable()) return false;
|
||||
return this->visible;
|
||||
}
|
||||
|
||||
bool ToggleVisibilityByAll()
|
||||
{
|
||||
if (_current_plan->owner == _local_company) DoCommandP(0, _current_plan->index, !this->visible_by_all, CMD_CHANGE_PLAN_VISIBILITY);
|
||||
return this->visible_by_all;
|
||||
}
|
||||
};
|
||||
|
||||
#define FOR_ALL_PLANS_FROM(var, start) FOR_ALL_ITEMS_FROM(Plan, plan_index, var, start)
|
||||
#define FOR_ALL_PLANS(var) FOR_ALL_PLANS_FROM(var, 0)
|
||||
|
||||
#endif /* PLANS_BASE_H */
|
@ -0,0 +1,140 @@
|
||||
/* $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 plans_cmd.cpp Handling of plan related commands. */
|
||||
|
||||
#include "stdafx.h"
|
||||
#include "command_func.h"
|
||||
#include "plans_base.h"
|
||||
#include "plans_func.h"
|
||||
#include "window_func.h"
|
||||
#include "company_func.h"
|
||||
#include "window_gui.h"
|
||||
#include "table/strings.h"
|
||||
|
||||
/**
|
||||
* Create a new plan.
|
||||
* @param tile unused
|
||||
* @param flags type of operation
|
||||
* @param p1 owner of the plan
|
||||
* @param p2 unused
|
||||
* @param text unused
|
||||
* @return the cost of this operation or an error
|
||||
*/
|
||||
CommandCost CmdAddPlan(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
||||
{
|
||||
if (!Plan::CanAllocateItem()) return_cmd_error(STR_ERROR_TOO_MANY_PLANS);
|
||||
if (flags & DC_EXEC) {
|
||||
Owner o = (Owner) p1;
|
||||
_new_plan = new Plan(o);
|
||||
if (o == _local_company) {
|
||||
_new_plan->SetVisibility(true);
|
||||
Window *w = FindWindowById(WC_PLANS, 0);
|
||||
if (w) w->InvalidateData(INVALID_PLAN, false);
|
||||
}
|
||||
}
|
||||
return CommandCost();
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new line in a plan.
|
||||
* @param tile unused
|
||||
* @param flags type of operation
|
||||
* @param p1 plan id
|
||||
* @param p2 number of nodes
|
||||
* @param text list of tile indexes that compose the line, encoded in base64
|
||||
* @return the cost of this operation or an error
|
||||
*/
|
||||
CommandCost CmdAddPlanLine(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
||||
{
|
||||
if (flags & DC_EXEC) {
|
||||
Plan *p = Plan::Get(p1);
|
||||
PlanLine *pl = p->NewLine();
|
||||
if (!pl) return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_LINES);
|
||||
if (p2 > (MAX_CMD_TEXT_LENGTH / sizeof(TileIndex))) return_cmd_error(STR_ERROR_TOO_MANY_NODES);
|
||||
pl->Import((const TileIndex *) text, p2);
|
||||
if (p->IsListable()) {
|
||||
pl->SetVisibility(p->visible);
|
||||
if (p->visible) pl->MarkDirty();
|
||||
Window *w = FindWindowById(WC_PLANS, 0);
|
||||
if (w) w->InvalidateData(INVALID_PLAN, false);
|
||||
}
|
||||
}
|
||||
return CommandCost();
|
||||
}
|
||||
|
||||
/**
|
||||
* Edit the visibility of a plan.
|
||||
* @param tile unused
|
||||
* @param flags type of operation
|
||||
* @param p1 plan id
|
||||
* @param p2 visibility
|
||||
* @param text unused
|
||||
* @return the cost of this operation or an error
|
||||
*/
|
||||
CommandCost CmdChangePlanVisibility(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
||||
{
|
||||
if (flags & DC_EXEC) {
|
||||
Plan *p = Plan::Get(p1);
|
||||
p->visible_by_all = p2 != 0;
|
||||
Window *w = FindWindowById(WC_PLANS, 0);
|
||||
if (w) w->InvalidateData(INVALID_PLAN, false);
|
||||
}
|
||||
return CommandCost();
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete a plan.
|
||||
* @param tile unused
|
||||
* @param flags type of operation
|
||||
* @param p1 plan id
|
||||
* @param p2 unused
|
||||
* @param text unused
|
||||
* @return the cost of this operation or an error
|
||||
*/
|
||||
CommandCost CmdRemovePlan(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
||||
{
|
||||
if (flags & DC_EXEC) {
|
||||
Plan *p = Plan::Get(p1);
|
||||
if (p->IsListable()) {
|
||||
p->SetVisibility(false);
|
||||
Window *w = FindWindowById(WC_PLANS, 0);
|
||||
if (w) w->InvalidateData(p->index, false);
|
||||
}
|
||||
if (p == _current_plan) _current_plan = NULL;
|
||||
delete p;
|
||||
}
|
||||
return CommandCost();
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove a line from a plan.
|
||||
* @param tile unused
|
||||
* @param flags type of operation
|
||||
* @param p1 plan id
|
||||
* @param p2 line id
|
||||
* @param text unused
|
||||
* @return the cost of this operation or an error
|
||||
*/
|
||||
CommandCost CmdRemovePlanLine(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
||||
{
|
||||
if (flags & DC_EXEC) {
|
||||
Plan *p = Plan::Get(p1);
|
||||
PlanLineVector::iterator it = p->lines.begin();
|
||||
std::advance(it, p2);
|
||||
(*it)->SetVisibility(false);
|
||||
delete *it;
|
||||
p->lines.erase(it);
|
||||
if (p->IsListable()) {
|
||||
Window *w = FindWindowById(WC_PLANS, 0);
|
||||
if (w) w->InvalidateData(p->index, false);
|
||||
}
|
||||
}
|
||||
return CommandCost();
|
||||
}
|
@ -0,0 +1,22 @@
|
||||
/* $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 plans_func.h Functions related to plans. */
|
||||
|
||||
#ifndef PLANS_FUNC_H
|
||||
#define PLANS_FUNC_H
|
||||
|
||||
#include "plans_type.h"
|
||||
|
||||
void ShowPlansWindow();
|
||||
|
||||
extern Plan *_new_plan;
|
||||
extern Plan *_current_plan;
|
||||
|
||||
#endif /* PLANS_FUNC_H */
|
@ -0,0 +1,366 @@
|
||||
/* $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 plans_gui.cpp The GUI for planning. */
|
||||
|
||||
#include "stdafx.h"
|
||||
#include "plans_func.h"
|
||||
#include "plans_base.h"
|
||||
#include "command_func.h"
|
||||
#include "company_func.h"
|
||||
#include "company_gui.h"
|
||||
#include "settings_gui.h"
|
||||
#include "window_gui.h"
|
||||
#include "window_func.h"
|
||||
#include "viewport_func.h"
|
||||
#include "gfx_func.h"
|
||||
#include "tilehighlight_func.h"
|
||||
#include "strings_func.h"
|
||||
#include "core/pool_func.hpp"
|
||||
#include "widgets/plans_widget.h"
|
||||
#include "table/strings.h"
|
||||
#include "table/sprites.h"
|
||||
|
||||
static const NWidgetPart _nested_plans_widgets[] = {
|
||||
NWidget(NWID_HORIZONTAL),
|
||||
NWidget(WWT_CLOSEBOX, COLOUR_GREY),
|
||||
NWidget(WWT_CAPTION, COLOUR_GREY, WID_PLN_CAPTION), SetDataTip(STR_PLANS_CAPTION, STR_NULL),
|
||||
NWidget(WWT_SHADEBOX, COLOUR_GREY),
|
||||
NWidget(WWT_DEFSIZEBOX, COLOUR_GREY),
|
||||
NWidget(WWT_STICKYBOX, COLOUR_GREY),
|
||||
EndContainer(),
|
||||
|
||||
NWidget(NWID_HORIZONTAL),
|
||||
NWidget(WWT_PANEL, COLOUR_GREY),
|
||||
NWidget(NWID_HORIZONTAL),
|
||||
NWidget(WWT_INSET, COLOUR_GREY, WID_PLN_LIST), SetFill(1, 1), SetPadding(2, 1, 2, 2), SetResize(1, 0), SetScrollbar(WID_PLN_SCROLLBAR), SetDataTip(STR_NULL, STR_PLANS_LIST_TOOLTIP),
|
||||
EndContainer(),
|
||||
EndContainer(),
|
||||
EndContainer(),
|
||||
NWidget(NWID_VSCROLLBAR, COLOUR_GREY, WID_PLN_SCROLLBAR),
|
||||
EndContainer(),
|
||||
|
||||
NWidget(WWT_PANEL, COLOUR_GREY),
|
||||
NWidget(NWID_HORIZONTAL),
|
||||
NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_PLN_NEW), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_PLANS_NEW_PLAN, STR_NULL),
|
||||
NWidget(WWT_TEXTBTN_2, COLOUR_GREY, WID_PLN_ADD_LINES), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_PLANS_ADD_LINES, STR_PLANS_ADDING_LINES),
|
||||
NWidget(WWT_TEXTBTN, COLOUR_GREY, WID_PLN_VISIBILITY), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_PLANS_VISIBILITY_PUBLIC, STR_PLANS_VISIBILITY_TOOLTIP),
|
||||
NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_PLN_HIDE_ALL), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_PLANS_HIDE_ALL, STR_NULL),
|
||||
NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_PLN_DELETE), SetResize(1, 0), SetFill(1, 0), SetDataTip(STR_PLANS_DELETE, STR_PLANS_DELETE_TOOLTIP),
|
||||
NWidget(WWT_RESIZEBOX, COLOUR_GREY),
|
||||
EndContainer(),
|
||||
EndContainer(),
|
||||
};
|
||||
|
||||
static WindowDesc _plans_desc(
|
||||
WDP_AUTO, "plans", 300, 100,
|
||||
WC_PLANS, WC_NONE,
|
||||
WDF_CONSTRUCTION,
|
||||
_nested_plans_widgets, lengthof(_nested_plans_widgets)
|
||||
);
|
||||
|
||||
struct PlansWindow : Window {
|
||||
typedef struct {
|
||||
bool is_plan;
|
||||
int plan_id;
|
||||
int line_id;
|
||||
} ListItem;
|
||||
|
||||
Scrollbar *vscroll;
|
||||
int text_offset;
|
||||
std::vector<ListItem> list; ///< The translation table linking panel indices to their related PlanID.
|
||||
int selected; ///< What item is currently selected in the panel.
|
||||
|
||||
PlansWindow(WindowDesc *desc) : Window(desc)
|
||||
{
|
||||
this->CreateNestedTree();
|
||||
this->vscroll = this->GetScrollbar(WID_PLN_SCROLLBAR);
|
||||
this->FinishInitNested();
|
||||
|
||||
Dimension spr_dim = GetSpriteSize(SPR_COMPANY_ICON);
|
||||
this->text_offset = WD_FRAMETEXT_LEFT + spr_dim.width + 2 + SETTING_BUTTON_WIDTH;
|
||||
|
||||
this->selected = INT_MAX;
|
||||
RebuildList();
|
||||
}
|
||||
|
||||
~PlansWindow()
|
||||
{
|
||||
this->list.clear();
|
||||
_current_plan = NULL;
|
||||
}
|
||||
|
||||
virtual void OnClick(Point pt, int widget, int click_count)
|
||||
{
|
||||
switch (widget) {
|
||||
case WID_PLN_NEW:
|
||||
DoCommandP(0, _local_company, 0, CMD_ADD_PLAN, CcAddPlan);
|
||||
break;
|
||||
case WID_PLN_ADD_LINES:
|
||||
if (_current_plan) HandlePlacePushButton(this, widget, SPR_CURSOR_MOUSE, HT_POINT);
|
||||
break;
|
||||
case WID_PLN_DELETE:
|
||||
if (this->selected != INT_MAX) {
|
||||
if (this->list[this->selected].is_plan) {
|
||||
DoCommandP(0, this->list[this->selected].plan_id, 0, CMD_REMOVE_PLAN);
|
||||
} else {
|
||||
DoCommandP(0, this->list[this->selected].plan_id, this->list[this->selected].line_id, CMD_REMOVE_PLAN_LINE);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case WID_PLN_HIDE_ALL: {
|
||||
Plan *p;
|
||||
FOR_ALL_PLANS(p) {
|
||||
if (p->IsListable()) p->SetVisibility(false);
|
||||
}
|
||||
this->SetWidgetDirty(WID_PLN_LIST);
|
||||
break;
|
||||
}
|
||||
case WID_PLN_VISIBILITY:
|
||||
if (_current_plan) _current_plan->ToggleVisibilityByAll();
|
||||
break;
|
||||
case WID_PLN_LIST: {
|
||||
int new_selected = this->vscroll->GetScrolledRowFromWidget(pt.y, this, WID_PLN_LIST, WD_FRAMERECT_TOP);
|
||||
if (this->selected != INT_MAX) {
|
||||
_current_plan->SetFocus(false);
|
||||
}
|
||||
if (new_selected != INT_MAX) {
|
||||
if (this->list[new_selected].is_plan) {
|
||||
_current_plan = Plan::Get(this->list[new_selected].plan_id);
|
||||
_current_plan->SetFocus(true);
|
||||
if (pt.x >= 22 && pt.x < 41) _current_plan->ToggleVisibility();
|
||||
} else {
|
||||
_current_plan = Plan::Get(this->list[new_selected].plan_id);
|
||||
PlanLine *pl = _current_plan->lines[this->list[new_selected].line_id];
|
||||
pl->SetFocus(true);
|
||||
if (pt.x >= 22 && pt.x < 41) {
|
||||
if (pl->ToggleVisibility()) _current_plan->SetVisibility(true, false);
|
||||
}
|
||||
}
|
||||
if (click_count > 1 && (pt.x < 22 || pt.x >= 41)) {
|
||||
_current_plan->show_lines = !_current_plan->show_lines;
|
||||
this->InvalidateData(INVALID_PLAN);
|
||||
}
|
||||
} else {
|
||||
if (_current_plan) {
|
||||
_current_plan->SetFocus(false);
|
||||
_current_plan = NULL;
|
||||
}
|
||||
}
|
||||
this->selected = new_selected;
|
||||
this->SetDirty();
|
||||
break;
|
||||
}
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
virtual void OnPaint()
|
||||
{
|
||||
this->SetWidgetDisabledState(WID_PLN_HIDE_ALL, this->vscroll->GetCount() == 0);
|
||||
if (_current_plan) {
|
||||
this->SetWidgetsDisabledState(_current_plan->owner != _local_company, WID_PLN_ADD_LINES, WID_PLN_VISIBILITY, WID_PLN_DELETE, WIDGET_LIST_END);
|
||||
this->GetWidget<NWidgetCore>(WID_PLN_VISIBILITY)->widget_data = _current_plan->visible_by_all ? STR_PLANS_VISIBILITY_PRIVATE : STR_PLANS_VISIBILITY_PUBLIC;
|
||||
} else {
|
||||
this->SetWidgetsDisabledState(true, WID_PLN_ADD_LINES, WID_PLN_VISIBILITY, WID_PLN_DELETE, WIDGET_LIST_END);
|
||||
}
|
||||
this->DrawWidgets();
|
||||
}
|
||||
|
||||
virtual void DrawWidget(const Rect &r, int widget) const
|
||||
{
|
||||
switch (widget) {
|
||||
case WID_PLN_LIST: {
|
||||
uint y = r.top + WD_FRAMERECT_TOP; // Offset from top of widget.
|
||||
if (this->vscroll->GetCount() == 0) {
|
||||
DrawString(r.left + WD_FRAMETEXT_LEFT, r.right - WD_FRAMETEXT_RIGHT, y, STR_STATION_LIST_NONE);
|
||||
return;
|
||||
}
|
||||
|
||||
bool rtl = _current_text_dir == TD_RTL;
|
||||
uint icon_left = 4 + (rtl ? r.right - this->text_offset : r.left);
|
||||
uint btn_left = (rtl ? icon_left - SETTING_BUTTON_WIDTH + 4 : icon_left + SETTING_BUTTON_WIDTH - 4);
|
||||
uint text_left = r.left + (rtl ? WD_FRAMERECT_LEFT : this->text_offset);
|
||||
uint text_right = r.right - (rtl ? this->text_offset : WD_FRAMERECT_RIGHT);
|
||||
|
||||
for (uint16 i = this->vscroll->GetPosition(); this->vscroll->IsVisible(i) && i < this->vscroll->GetCount(); i++) {
|
||||
Plan *p = Plan::Get(list[i].plan_id);
|
||||
|
||||
if (i == this->selected) GfxFillRect(r.left + 1, y, r.right, y + this->resize.step_height, PC_DARK_GREY);
|
||||
|
||||
if (list[i].is_plan) {
|
||||
DrawCompanyIcon(p->owner, icon_left, y + (FONT_HEIGHT_NORMAL - 10) / 2 + 1);
|
||||
DrawBoolButton(btn_left, y + (FONT_HEIGHT_NORMAL - 10) / 2, p->visible, true);
|
||||
SetDParam(0, list[i].plan_id + 1);
|
||||
SetDParam(1, p->lines.size());
|
||||
SetDParam(2, p->creation_date);
|
||||
DrawString(text_left, text_right, y, STR_PLANS_LIST_ITEM_PLAN, p->visible_by_all ? TC_LIGHT_BLUE : TC_YELLOW);
|
||||
} else {
|
||||
PlanLine *pl = p->lines[list[i].line_id];
|
||||
DrawBoolButton(btn_left, y + (FONT_HEIGHT_NORMAL - 10) / 2, pl->visible, true);
|
||||
SetDParam(0, list[i].line_id + 1);
|
||||
SetDParam(1, pl->tiles.size() - 1);
|
||||
DrawString(text_left, text_right, y, STR_PLANS_LIST_ITEM_LINE, TC_WHITE);
|
||||
}
|
||||
y += this->resize.step_height;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
virtual void OnResize()
|
||||
{
|
||||
this->vscroll->SetCapacityFromWidget(this, WID_PLN_LIST, WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM);
|
||||
}
|
||||
|
||||
virtual void UpdateWidgetSize(int widget, Dimension *size, const Dimension &padding, Dimension *fill, Dimension *resize)
|
||||
{
|
||||
switch (widget) {
|
||||
case WID_PLN_LIST:
|
||||
resize->height = FONT_HEIGHT_NORMAL;
|
||||
size->height = resize->height * 5 + WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/** The drawing of a line starts. */
|
||||
virtual void OnPlaceObject(Point pt, TileIndex tile)
|
||||
{
|
||||
/* A player can't add lines to a public plan of another company. */
|
||||
if (_current_plan && _current_plan->owner == _local_company) VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_DRAW_PLANLINE);
|
||||
}
|
||||
|
||||
/** The drawing of a line is in progress. */
|
||||
virtual void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt)
|
||||
{
|
||||
const Point p = GetTileBelowCursor();
|
||||
const TileIndex tile = TileVirtXY(p.x, p.y);
|
||||
if (_current_plan && tile < MapSize()) {
|
||||
_current_plan->StoreTempTile(tile);
|
||||
_thd.selstart = _thd.selend;
|
||||
}
|
||||
}
|
||||
|
||||
/** The drawing of a line ends up normally. */
|
||||
virtual void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile)
|
||||
{
|
||||
if (_current_plan) _current_plan->ValidateNewLine();
|
||||
}
|
||||
|
||||
/** The drawing of a line is aborted. */
|
||||
virtual void OnPlaceObjectAbort()
|
||||
{
|
||||
if (_current_plan) {
|
||||
_current_plan->temp_line->MarkDirty();
|
||||
_current_plan->temp_line->Clear();
|
||||
}
|
||||
|
||||
this->RaiseWidget(WID_PLN_ADD_LINES);
|
||||
this->SetWidgetDirty(WID_PLN_ADD_LINES);
|
||||
}
|
||||
|
||||
void RebuildList()
|
||||
{
|
||||
int old_focused_plan_id = this->selected == INT_MAX ? INT_MAX : this->list[this->selected].plan_id;
|
||||
|
||||
int sbcnt = 0;
|
||||
this->list.clear();
|
||||
Plan *p;
|
||||
FOR_ALL_PLANS(p) {
|
||||
if (!p->IsListable()) continue;
|
||||
|
||||
ListItem li;
|
||||
li.is_plan = true;
|
||||
li.plan_id = p->index;
|
||||
this->list.push_back(li);
|
||||
if (old_focused_plan_id == p->index) this->selected = sbcnt;
|
||||
sbcnt++;
|
||||
|
||||
if (p->show_lines) {
|
||||
const int sz = (int) p->lines.size();
|
||||
sbcnt += sz;
|
||||
li.is_plan = false;
|
||||
for (int i = 0; i < sz; i++) {
|
||||
li.line_id = i;
|
||||
this->list.push_back(li);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this->selected == INT_MAX) ResetObjectToPlace();
|
||||
|
||||
this->vscroll->SetCount(sbcnt);
|
||||
}
|
||||
|
||||
virtual void OnInvalidateData(int data = 0, bool gui_scope = true)
|
||||
{
|
||||
if (data != INVALID_PLAN && this->selected != INT_MAX) {
|
||||
if (this->list[this->selected].plan_id == data) {
|
||||
/* Invalidate the selection if the selected plan has been modified or deleted. */
|
||||
this->selected = INT_MAX;
|
||||
|
||||
/* Cancel drawing associated to the deleted plan. */
|
||||
ResetObjectToPlace();
|
||||
}
|
||||
}
|
||||
|
||||
RebuildList();
|
||||
}
|
||||
|
||||
void SelectPlan(PlanID plan_index)
|
||||
{
|
||||
if (this->selected != INT_MAX) {
|
||||
if (plan_index == this->list[this->selected].plan_id) return;
|
||||
Plan::Get(this->list[this->selected].plan_id)->SetFocus(false);
|
||||
}
|
||||
|
||||
if (plan_index == INVALID_PLAN) {
|
||||
this->selected = INT_MAX;
|
||||
return;
|
||||
}
|
||||
Plan::Get(plan_index)->SetFocus(true);
|
||||
|
||||
for (size_t i = 0; i < this->list.size(); i++) {
|
||||
if (this->list[i].is_plan && this->list[i].plan_id == plan_index) {
|
||||
this->selected = (int) i;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/** Show the window to manage plans. */
|
||||
void ShowPlansWindow()
|
||||
{
|
||||
if (BringWindowToFrontById(WC_PLANS, 0) != NULL) return;
|
||||
new PlansWindow(&_plans_desc);
|
||||
}
|
||||
|
||||
/**
|
||||
* Only the creator of a plan executes this function.
|
||||
* The other players should not be bothered with these changes.
|
||||
*/
|
||||
void CcAddPlan(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2)
|
||||
{
|
||||
if (result.Failed()) return;
|
||||
|
||||
_current_plan = _new_plan;
|
||||
_current_plan->SetVisibility(true);
|
||||
|
||||
Window *w = FindWindowById(WC_PLANS, 0);
|
||||
if (w) {
|
||||
w->InvalidateData(INVALID_PLAN, false);
|
||||
((PlansWindow *) w)->SelectPlan(_current_plan->index);
|
||||
if (!w->IsWidgetLowered(WID_PLN_ADD_LINES)) {
|
||||
w->SetWidgetDisabledState(WID_PLN_ADD_LINES, false);
|
||||
HandlePlacePushButton(w, WID_PLN_ADD_LINES, SPR_CURSOR_MOUSE, HT_POINT);
|
||||
}
|
||||
}
|
||||
}
|
@ -0,0 +1,25 @@
|
||||
/* $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 plans_type.h Types related to planning. */
|
||||
|
||||
#ifndef PLANS_TYPE_H
|
||||
#define PLANS_TYPE_H
|
||||
|
||||
#include "stdafx.h"
|
||||
#include "core/smallvec_type.hpp"
|
||||
#include "tile_type.h"
|
||||
|
||||
typedef uint16 PlanID;
|
||||
struct PlanLine;
|
||||
struct Plan;
|
||||
|
||||
static const PlanID INVALID_PLAN = 0xFFFF; ///< Sentinel for an invalid plan.
|
||||
|
||||
#endif /* PLANS_TYPE_H */
|
@ -0,0 +1,87 @@
|
||||
/* $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 plans_sl.cpp Code handling saving and loading of plans data. */
|
||||
|
||||
#include "../stdafx.h"
|
||||
#include "../plans_base.h"
|
||||
#include "../fios.h"
|
||||
|
||||
#include "saveload.h"
|
||||
|
||||
/** Description of a plan within the savegame. */
|
||||
static const SaveLoad _plan_desc[] = {
|
||||
SLE_VAR(Plan, owner, SLE_UINT8),
|
||||
SLE_VAR(Plan, visible, SLE_BOOL),
|
||||
SLE_VAR(Plan, visible_by_all, SLE_BOOL),
|
||||
SLE_VAR(Plan, creation_date, SLE_INT32),
|
||||
SLE_END()
|
||||
};
|
||||
|
||||
/** Save all plans. */
|
||||
static void Save_PLAN()
|
||||
{
|
||||
Plan *p;
|
||||
FOR_ALL_PLANS(p) {
|
||||
SlSetArrayIndex(p->index);
|
||||
SlObject(p, _plan_desc);
|
||||
}
|
||||
}
|
||||
|
||||
/** Load all plans. */
|
||||
static void Load_PLAN()
|
||||
{
|
||||
int index;
|
||||
while ((index = SlIterateArray()) != -1) {
|
||||
Plan *p = new (index) Plan();
|
||||
SlObject(p, _plan_desc);
|
||||
}
|
||||
}
|
||||
|
||||
/** Save all plan lines. */
|
||||
static void Save_PLANLINE()
|
||||
{
|
||||
Plan *p;
|
||||
FOR_ALL_PLANS(p) {
|
||||
for (size_t i = 0; i < p->lines.size(); i++) {
|
||||
SlSetArrayIndex((uint) p->index << 16 | (uint) i);
|
||||
PlanLine *pl = p->lines[i];
|
||||
size_t plsz = pl->tiles.size();
|
||||
SlSetLength(plsz * sizeof(TileIndex));
|
||||
SlArray(&pl->tiles[0], plsz, SLE_UINT32);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Load all plan lines. */
|
||||
static void Load_PLANLINE()
|
||||
{
|
||||
int index;
|
||||
while ((index = SlIterateArray()) != -1) {
|
||||
Plan *p = Plan::Get((uint) index >> 16);
|
||||
uint line_index = index & 0xFFFF;
|
||||
if (p->lines.size() <= line_index) p->lines.resize(line_index + 1);
|
||||
PlanLine *pl = new PlanLine();
|
||||
p->lines[line_index] = pl;
|
||||
size_t plsz = SlGetFieldLength() / sizeof(TileIndex);
|
||||
pl->tiles.resize(plsz);
|
||||
SlArray(&pl->tiles[0], plsz, SLE_UINT32);
|
||||
}
|
||||
|
||||
Plan *p;
|
||||
FOR_ALL_PLANS(p) {
|
||||
p->SetVisibility(false);
|
||||
}
|
||||
}
|
||||
|
||||
/** Chunk handlers related to plans. */
|
||||
extern const ChunkHandler _plan_chunk_handlers[] = {
|
||||
{ 'PLAN', Save_PLAN, Load_PLAN, NULL, NULL, CH_ARRAY},
|
||||
{ 'PLLN', Save_PLANLINE, Load_PLANLINE, NULL, NULL, CH_ARRAY | CH_LAST},
|
||||
};
|
@ -0,0 +1,106 @@
|
||||
/* $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 smallmap_colours.h Colours used by smallmap. */
|
||||
|
||||
#ifndef SMALLMAP_COLOURS_H
|
||||
#define SMALLMAP_COLOURS_H
|
||||
|
||||
#include "core/endian_func.hpp"
|
||||
|
||||
static const uint8 PC_ROUGH_LAND = 0x52; ///< Dark green palette colour for rough land.
|
||||
static const uint8 PC_GRASS_LAND = 0x54; ///< Dark green palette colour for grass land.
|
||||
static const uint8 PC_BARE_LAND = 0x37; ///< Brown palette colour for bare land.
|
||||
static const uint8 PC_FIELDS = 0x25; ///< Light brown palette colour for fields.
|
||||
static const uint8 PC_TREES = 0x57; ///< Green palette colour for trees.
|
||||
static const uint8 PC_WATER = 0xCA; ///< Dark blue palette colour for water.
|
||||
|
||||
#define MKCOLOUR(x) TO_LE32X(x)
|
||||
|
||||
#define MKCOLOUR_XXXX(x) (MKCOLOUR(0x01010101) * (uint)(x))
|
||||
#define MKCOLOUR_X0X0(x) (MKCOLOUR(0x01000100) * (uint)(x))
|
||||
#define MKCOLOUR_0X0X(x) (MKCOLOUR(0x00010001) * (uint)(x))
|
||||
#define MKCOLOUR_0XX0(x) (MKCOLOUR(0x00010100) * (uint)(x))
|
||||
#define MKCOLOUR_X00X(x) (MKCOLOUR(0x01000001) * (uint)(x))
|
||||
|
||||
#define MKCOLOUR_XYXY(x, y) (MKCOLOUR_X0X0(x) | MKCOLOUR_0X0X(y))
|
||||
#define MKCOLOUR_XYYX(x, y) (MKCOLOUR_X00X(x) | MKCOLOUR_0XX0(y))
|
||||
|
||||
#define MKCOLOUR_0000 MKCOLOUR_XXXX(0x00)
|
||||
#define MKCOLOUR_0FF0 MKCOLOUR_0XX0(0xFF)
|
||||
#define MKCOLOUR_F00F MKCOLOUR_X00X(0xFF)
|
||||
#define MKCOLOUR_FFFF MKCOLOUR_XXXX(0xFF)
|
||||
|
||||
#include "table/heightmap_colours.h"
|
||||
#include "table/darklight_colours.h"
|
||||
|
||||
/** Colour scheme of the smallmap. */
|
||||
struct SmallMapColourScheme {
|
||||
uint32 *height_colours; ///< Cached colours for each level in a map.
|
||||
const uint32 *height_colours_base; ///< Base table for determining the colours
|
||||
size_t colour_count; ///< The number of colours.
|
||||
uint32 default_colour; ///< Default colour of the land.
|
||||
};
|
||||
|
||||
extern SmallMapColourScheme _heightmap_schemes[];
|
||||
|
||||
struct AndOr {
|
||||
uint32 mor;
|
||||
uint32 mand;
|
||||
};
|
||||
|
||||
static inline uint32 ApplyMask(uint32 colour, const AndOr *mask)
|
||||
{
|
||||
return (colour & mask->mand) | mask->mor;
|
||||
}
|
||||
|
||||
/** Colour masks for "Contour" and "Routes" modes. */
|
||||
static const AndOr _smallmap_contours_andor[] = {
|
||||
{MKCOLOUR_0000 , MKCOLOUR_FFFF}, // MP_CLEAR
|
||||
{MKCOLOUR_0XX0(PC_GREY ), MKCOLOUR_F00F}, // MP_RAILWAY
|
||||
{MKCOLOUR_0XX0(PC_BLACK ), MKCOLOUR_F00F}, // MP_ROAD
|
||||
{MKCOLOUR_0XX0(PC_DARK_RED ), MKCOLOUR_F00F}, // MP_HOUSE
|
||||
{MKCOLOUR_0000 , MKCOLOUR_FFFF}, // MP_TREES
|
||||
{MKCOLOUR_XXXX(PC_LIGHT_BLUE), MKCOLOUR_0000}, // MP_STATION
|
||||
{MKCOLOUR_XXXX(PC_WATER ), MKCOLOUR_0000}, // MP_WATER
|
||||
{MKCOLOUR_0000 , MKCOLOUR_FFFF}, // MP_VOID
|
||||
{MKCOLOUR_XXXX(PC_DARK_RED ), MKCOLOUR_0000}, // MP_INDUSTRY
|
||||
{MKCOLOUR_0000 , MKCOLOUR_FFFF}, // MP_TUNNELBRIDGE
|
||||
{MKCOLOUR_0XX0(PC_DARK_RED ), MKCOLOUR_F00F}, // MP_OBJECT
|
||||
{MKCOLOUR_0XX0(PC_GREY ), MKCOLOUR_F00F},
|
||||
};
|
||||
|
||||
/** Colour masks for "Vehicles", "Industry", and "Vegetation" modes. */
|
||||
static const AndOr _smallmap_vehicles_andor[] = {
|
||||
{MKCOLOUR_0000 , MKCOLOUR_FFFF}, // MP_CLEAR
|
||||
{MKCOLOUR_0XX0(PC_BLACK ), MKCOLOUR_F00F}, // MP_RAILWAY
|
||||
{MKCOLOUR_0XX0(PC_BLACK ), MKCOLOUR_F00F}, // MP_ROAD
|
||||
{MKCOLOUR_0XX0(PC_DARK_RED ), MKCOLOUR_F00F}, // MP_HOUSE
|
||||
{MKCOLOUR_0000 , MKCOLOUR_FFFF}, // MP_TREES
|
||||
{MKCOLOUR_0XX0(PC_BLACK ), MKCOLOUR_F00F}, // MP_STATION
|
||||
{MKCOLOUR_XXXX(PC_WATER ), MKCOLOUR_0000}, // MP_WATER
|
||||
{MKCOLOUR_0000 , MKCOLOUR_FFFF}, // MP_VOID
|
||||
{MKCOLOUR_XXXX(PC_DARK_RED ), MKCOLOUR_0000}, // MP_INDUSTRY
|
||||
{MKCOLOUR_0000 , MKCOLOUR_FFFF}, // MP_TUNNELBRIDGE
|
||||
{MKCOLOUR_0XX0(PC_DARK_RED ), MKCOLOUR_F00F}, // MP_OBJECT
|
||||
{MKCOLOUR_0XX0(PC_BLACK ), MKCOLOUR_F00F},
|
||||
};
|
||||
|
||||
static const uint32 _vegetation_clear_bits[] = {
|
||||
MKCOLOUR_XXXX(PC_GRASS_LAND), ///< full grass
|
||||
MKCOLOUR_XXXX(PC_ROUGH_LAND), ///< rough land
|
||||
MKCOLOUR_XXXX(PC_GREY), ///< rocks
|
||||
MKCOLOUR_XXXX(PC_FIELDS), ///< fields
|
||||
MKCOLOUR_XXXX(PC_LIGHT_BLUE), ///< snow
|
||||
MKCOLOUR_XXXX(PC_ORANGE), ///< desert
|
||||
MKCOLOUR_XXXX(PC_GRASS_LAND), ///< unused
|
||||
MKCOLOUR_XXXX(PC_GRASS_LAND), ///< unused
|
||||
};
|
||||
|
||||
#endif /* SMALLMAP_COLOURS_H */
|
@ -0,0 +1,52 @@
|
||||
/* $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 darklight_colours.h The colour tables to lighten and darken.
|
||||
*/
|
||||
|
||||
static const byte _lighten_colour[] = {
|
||||
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
||||
0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, // 0
|
||||
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x0F, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x0F, // 1
|
||||
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x0F, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, // 2
|
||||
0x31, 0x0F, 0x33, 0x34, 0x45, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x0F, 0x3D, 0x3E, 0x3F, 0x40, // 3
|
||||
0x41, 0x42, 0x43, 0x44, 0x45, 0x0F, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x0F, // 4
|
||||
0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x0F, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x0F, // 5
|
||||
0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x0F, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x0F, // 6
|
||||
0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x0F, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x0F, // 7
|
||||
0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x0F, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x0F, // 8
|
||||
0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x0F, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, // 9
|
||||
0xA1, 0x0F, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0x0F, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, // A
|
||||
0xB1, 0x0F, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0x0F, // B
|
||||
0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0x0F, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0x0F, 0xCF, 0xD0, // C
|
||||
0xD1, 0x0F, 0x0F, 0xD2, 0xD3, 0xD4, 0xD5, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0x0F, // D
|
||||
0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0x0F, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0x0F, 0xE3, // E
|
||||
0xE8, 0xF2, 0xF3, 0xCE, 0x44, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0x0F, 0xFC, 0xFD, 0xFF, // F
|
||||
};
|
||||
|
||||
static const byte _darken_colour[] = {
|
||||
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
||||
0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, // 0
|
||||
0x02, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x02, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, // 1
|
||||
0x02, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x02, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, // 2
|
||||
0x2F, 0x30, 0x42, 0x32, 0x33, 0x02, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x02, 0x3C, 0x3D, 0x3E, // 3
|
||||
0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x01, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, // 4
|
||||
0x02, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x02, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, // 5
|
||||
0x02, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x02, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, // 6
|
||||
0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0xEF, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, // 7
|
||||
0x02, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x02, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, // 8
|
||||
0x02, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x02, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, // 9
|
||||
0x9F, 0xA0, 0xB4, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0x02, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, // A
|
||||
0xAF, 0xB0, 0x02, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, // B
|
||||
0x3F, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0x02, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xF3, 0xCE, // C
|
||||
0xCF, 0xD0, 0xD3, 0xD4, 0xD5, 0xD6, 0xDF, 0x02, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, // D
|
||||
0xE1, 0xE2, 0x02, 0xEF, 0xE3, 0xE4, 0xE5, 0xE6, 0xB8, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0x02, // E
|
||||
0xB5, 0x02, 0xF1, 0xF2, 0x43, 0x02, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFE, 0xF5, 0x0F // F
|
||||
};
|
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue