rm *.cpp
This commit is contained in:
parent
f2434a5953
commit
8f94811cb0
GPG Key ID:
072D999D60C6473C
@ -1,148 +0,0 @@
|
||||
Language: Cpp
|
||||
AccessModifierOffset: -4
|
||||
AlignAfterOpenBracket: Align
|
||||
AlignArrayOfStructures: Left
|
||||
AlignConsecutiveMacros: None
|
||||
AlignConsecutiveAssignments: None
|
||||
AlignConsecutiveBitFields: None
|
||||
AlignConsecutiveDeclarations: None
|
||||
AlignEscapedNewlines: Left
|
||||
AlignOperands: Align
|
||||
AlignTrailingComments: true
|
||||
AllowAllArgumentsOnNextLine: false
|
||||
AllowAllParametersOfDeclarationOnNextLine: false
|
||||
AllowShortEnumsOnASingleLine: false
|
||||
AllowShortBlocksOnASingleLine: Empty
|
||||
AllowShortCaseLabelsOnASingleLine: false
|
||||
AllowShortFunctionsOnASingleLine: Empty
|
||||
AllowShortLambdasOnASingleLine: All
|
||||
AllowShortIfStatementsOnASingleLine: Never
|
||||
AllowShortLoopsOnASingleLine: false
|
||||
AlwaysBreakAfterDefinitionReturnType: None
|
||||
AlwaysBreakAfterReturnType: None
|
||||
AlwaysBreakBeforeMultilineStrings: false
|
||||
AlwaysBreakTemplateDeclarations: Yes
|
||||
AttributeMacros: []
|
||||
BinPackArguments: false
|
||||
BinPackParameters: false
|
||||
BraceWrapping:
|
||||
AfterCaseLabel: false
|
||||
AfterClass: false
|
||||
AfterControlStatement: Never
|
||||
AfterEnum: false
|
||||
AfterFunction: false
|
||||
AfterNamespace: false
|
||||
AfterObjCDeclaration: false
|
||||
AfterStruct: false
|
||||
AfterUnion: false
|
||||
AfterExternBlock: false
|
||||
BeforeCatch: false
|
||||
BeforeElse: false
|
||||
BeforeLambdaBody: false
|
||||
BeforeWhile: false
|
||||
IndentBraces: false
|
||||
SplitEmptyFunction: false
|
||||
SplitEmptyRecord: false
|
||||
SplitEmptyNamespace: false
|
||||
BreakBeforeBinaryOperators: All
|
||||
BreakBeforeConceptDeclarations: true
|
||||
BreakBeforeBraces: Attach
|
||||
BreakBeforeInheritanceComma: false
|
||||
BreakInheritanceList: BeforeComma
|
||||
BreakBeforeTernaryOperators: true
|
||||
BreakConstructorInitializersBeforeComma: true
|
||||
BreakConstructorInitializers: BeforeComma
|
||||
BreakStringLiterals: true
|
||||
ColumnLimit: 80
|
||||
QualifierAlignment: Left
|
||||
CompactNamespaces: false
|
||||
ConstructorInitializerIndentWidth: 4
|
||||
ContinuationIndentWidth: 4
|
||||
Cpp11BracedListStyle: true
|
||||
DeriveLineEnding: true
|
||||
DerivePointerAlignment: false
|
||||
DisableFormat: false
|
||||
EmptyLineAfterAccessModifier: Never
|
||||
EmptyLineBeforeAccessModifier: Always
|
||||
ExperimentalAutoDetectBinPacking: false
|
||||
PackConstructorInitializers: NextLine
|
||||
ConstructorInitializerAllOnOneLineOrOnePerLine: false
|
||||
AllowAllConstructorInitializersOnNextLine: false
|
||||
FixNamespaceComments: true
|
||||
ForEachMacros: []
|
||||
IfMacros: []
|
||||
IncludeBlocks: Merge
|
||||
IndentAccessModifiers: false
|
||||
IndentCaseLabels: false
|
||||
IndentCaseBlocks: false
|
||||
IndentGotoLabels: false
|
||||
IndentPPDirectives: None
|
||||
IndentExternBlock: AfterExternBlock
|
||||
IndentRequires: false
|
||||
IndentWidth: 4
|
||||
IndentWrappedFunctionNames: false
|
||||
InsertTrailingCommas: Wrapped
|
||||
InsertBraces: false
|
||||
InsertNewlineAtEOF: true
|
||||
KeepEmptyLinesAtTheStartOfBlocks: false
|
||||
LambdaBodyIndentation: Signature
|
||||
MacroBlockBegin: ''
|
||||
MacroBlockEnd: ''
|
||||
MaxEmptyLinesToKeep: 1
|
||||
NamespaceIndentation: None
|
||||
PenaltyBreakAssignment: 2
|
||||
PenaltyBreakBeforeFirstCallParameter: 1
|
||||
PenaltyBreakComment: 300
|
||||
PenaltyBreakFirstLessLess: 120
|
||||
PenaltyBreakOpenParenthesis: 0
|
||||
PenaltyBreakString: 1000
|
||||
PenaltyBreakTemplateDeclaration: 10
|
||||
PenaltyExcessCharacter: 1000000
|
||||
PenaltyReturnTypeOnItsOwnLine: 200
|
||||
PenaltyIndentedWhitespace: 0
|
||||
PointerAlignment: Left
|
||||
PPIndentWidth: -1
|
||||
ReferenceAlignment: Pointer
|
||||
ReflowComments: true
|
||||
RemoveBracesLLVM: false
|
||||
SeparateDefinitionBlocks: Leave
|
||||
ShortNamespaceLines: 1
|
||||
SortIncludes: CaseSensitive
|
||||
SortJavaStaticImport: Before
|
||||
SortUsingDeclarations: true
|
||||
SpaceAfterCStyleCast: false
|
||||
SpaceAfterLogicalNot: false
|
||||
SpaceAfterTemplateKeyword: false
|
||||
SpaceBeforeAssignmentOperators: true
|
||||
SpaceBeforeCaseColon: false
|
||||
SpaceBeforeCpp11BracedList: false
|
||||
SpaceBeforeCtorInitializerColon: false
|
||||
SpaceBeforeInheritanceColon: true
|
||||
SpaceBeforeParens: ControlStatements
|
||||
SpaceBeforeParensOptions:
|
||||
AfterControlStatements: true
|
||||
AfterFunctionDefinitionName: false
|
||||
AfterFunctionDeclarationName: false
|
||||
AfterOverloadedOperator: false
|
||||
BeforeNonEmptyParentheses: false
|
||||
SpaceAroundPointerQualifiers: Default
|
||||
SpaceBeforeRangeBasedForLoopColon: true
|
||||
SpaceInEmptyBlock: false
|
||||
SpaceInEmptyParentheses: false
|
||||
SpacesBeforeTrailingComments: 1
|
||||
SpacesInAngles: Never
|
||||
SpacesInConditionalStatement: false
|
||||
SpacesInContainerLiterals: false
|
||||
SpacesInCStyleCastParentheses: false
|
||||
SpacesInLineCommentPrefix:
|
||||
Minimum: 1
|
||||
Maximum: -1
|
||||
SpacesInParentheses: false
|
||||
SpacesInSquareBrackets: false
|
||||
SpaceBeforeSquareBrackets: false
|
||||
BitFieldColonSpacing: Both
|
||||
Standard: Latest
|
||||
TabWidth: 4
|
||||
UseCRLF: false
|
||||
UseTab: Always
|
||||
|
||||
@ -1,344 +0,0 @@
|
||||
#include "GameBoard.h"
|
||||
#include <algorithm>
|
||||
#include <queue>
|
||||
|
||||
GameBoard::GameBoard(pos_t w, pos_t h, const InitInfo& info)
|
||||
: n(info.n)
|
||||
, t(0)
|
||||
, players(info.n + 1)
|
||||
, w(w)
|
||||
, h(h)
|
||||
, view_radius(1)
|
||||
, board(w * h)
|
||||
, halfturn_id(0) {
|
||||
for (std::uint8_t i = 1; i <= n; ++i) {
|
||||
players[i].id = i;
|
||||
players[i].team = info.player_team[i];
|
||||
t = std::max(t, players[i].team);
|
||||
}
|
||||
diff_tiles.resize(t + 1);
|
||||
cover.resize(t + 1, std::vector(h, std::vector<std::uint8_t>(w)));
|
||||
}
|
||||
|
||||
Tile& GameBoard::at(pos_t x, pos_t y) {
|
||||
return board[x * w + y];
|
||||
}
|
||||
|
||||
const Tile& GameBoard::at(pos_t x, pos_t y) const {
|
||||
return board[x * w + y];
|
||||
}
|
||||
|
||||
void GameBoard::setOwner(pos_t x, pos_t y, Player p) {
|
||||
auto flip = [&](int team, Point pos) {
|
||||
if (!team)
|
||||
return;
|
||||
auto pr = diff_tiles[team].insert(pos);
|
||||
if (!pr.second)
|
||||
diff_tiles[team].erase(pr.first);
|
||||
};
|
||||
auto t1 = players[at(x, y).owner].team, t2 = players[p].team;
|
||||
if (t1 != t2) {
|
||||
pos_t sx = x - std::min(x, view_radius),
|
||||
tx = x + std::min<pos_t>(h - x, view_radius),
|
||||
sy = y - std::min(y, view_radius),
|
||||
ty = y + std::min<pos_t>(w - y, view_radius);
|
||||
for (pos_t xx = sx; xx <= tx; xx++) {
|
||||
for (pos_t yy = sy; yy <= ty; yy++) {
|
||||
cover[t1][xx][yy]--;
|
||||
if (!cover[t1][xx][yy])
|
||||
flip(t1, Point(xx, yy));
|
||||
if (!cover[t2][xx][yy])
|
||||
flip(t2, Point(xx, yy));
|
||||
cover[t2][xx][yy]++;
|
||||
}
|
||||
}
|
||||
}
|
||||
at(x, y).owner = p;
|
||||
updatedPosition(x, y);
|
||||
}
|
||||
|
||||
bool GameBoard::attack(const PlayerMove& o) {
|
||||
if (!o.isValid(w, h))
|
||||
return false;
|
||||
|
||||
auto& sc_tile = at(o.x, o.y);
|
||||
auto& tt_tile = at(o.tx(), o.ty());
|
||||
if (sc_tile.owner != o.player)
|
||||
return false;
|
||||
|
||||
if (sc_tile.unit <= 1)
|
||||
return false;
|
||||
|
||||
if (tt_tile.type == TileType::Mountain)
|
||||
return false;
|
||||
|
||||
auto moving_unit = o.half ? sc_tile.unit - 1 : sc_tile.unit / 2;
|
||||
sc_tile.unit -= moving_unit;
|
||||
auto isfriend = isTeammate(o.player, tt_tile.owner);
|
||||
auto delta
|
||||
= isfriend ? moving_unit + tt_tile.unit : moving_unit - tt_tile.unit;
|
||||
|
||||
updatedPosition(o.x, o.y);
|
||||
updatedPosition(o.ty(), o.ty());
|
||||
|
||||
tt_tile.unit = std::abs(delta);
|
||||
if (delta > 0 && (!isfriend || tt_tile.type != TileType::Capital)) {
|
||||
if (!isfriend && tt_tile.type == TileType::Capital)
|
||||
capitalCaptured(tt_tile.owner, o.player);
|
||||
setOwner(o.tx(), o.ty(), o.player);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void GameBoard::capitalCaptured(Player tt, Player sc) {
|
||||
for (pos_t x = 0; x < h; ++x) {
|
||||
for (pos_t y = 0; y < w; ++y) {
|
||||
auto& tile = at(x, y);
|
||||
if (tile.owner != tt)
|
||||
continue;
|
||||
|
||||
updatedPosition(x, y);
|
||||
if (tile.type == TileType::Capital) {
|
||||
tile.type = TileType::Stronghold;
|
||||
continue;
|
||||
}
|
||||
|
||||
setOwner(x, y, sc);
|
||||
tile.unit = std::max(tile.unit / 2, 1);
|
||||
}
|
||||
}
|
||||
new_defeated_players.push_back(tt);
|
||||
players[tt].is_defeated = 1;
|
||||
}
|
||||
|
||||
bool GameBoard::isTeammate(Player x, Player y) const {
|
||||
return teamOf(x) == teamOf(y);
|
||||
}
|
||||
|
||||
void GameBoard::turnUpdate() {
|
||||
for (pos_t x = 0; x < h; ++x) {
|
||||
for (pos_t y = 0; y < w; ++y) {
|
||||
auto& tile = at(x, y);
|
||||
if (tile.owner == neutral_player)
|
||||
continue;
|
||||
|
||||
if (tile.type == TileType::Stronghold
|
||||
|| tile.type == TileType::Capital)
|
||||
tile.unit += 1;
|
||||
|
||||
if (tile.type == TileType::Swamp) {
|
||||
if (tile.unit > 0)
|
||||
tile.unit -= 1;
|
||||
if (tile.unit == 0)
|
||||
setOwner(x, y, neutral_player);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GameBoard::roundUpdate() {
|
||||
for (pos_t x = 0; x < h; ++x) {
|
||||
for (pos_t y = 0; y < w; ++y) {
|
||||
auto& tile = at(x, y);
|
||||
if (tile.owner == neutral_player)
|
||||
continue;
|
||||
tile.unit += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GameBoard::updatedPosition(pos_t x, pos_t y) {
|
||||
updated_tiles.emplace(x, y);
|
||||
}
|
||||
|
||||
Team GameBoard::teamOf(Player x) const {
|
||||
return players[x].team;
|
||||
}
|
||||
|
||||
bool GameBoard::isDefeated(Player x) const {
|
||||
return players[x].is_defeated;
|
||||
}
|
||||
|
||||
std::uint8_t GameBoard::numPlayers() const {
|
||||
return n;
|
||||
}
|
||||
|
||||
std::uint8_t GameBoard::numTeams() const {
|
||||
return t;
|
||||
}
|
||||
|
||||
void GameBoard::appendOrderQueue(const PlayerMove& p) {
|
||||
if (!players[p.player].is_defeated)
|
||||
players[p.player].orders.emplace_back(p);
|
||||
}
|
||||
|
||||
void GameBoard::clearOrderQueue(Player p) {
|
||||
players[p].orders.clear();
|
||||
}
|
||||
|
||||
void GameBoard::popOrderQueue(Player p) {
|
||||
players[p].orders.pop_front();
|
||||
}
|
||||
|
||||
void GameBoard::setOffline(Player p) {
|
||||
new_offline_players.push_back(p);
|
||||
}
|
||||
|
||||
void GameBoard::offline(Player p) {
|
||||
if (players[p].is_defeated)
|
||||
return;
|
||||
std::vector<std::vector<std::uint8_t>> vis(h, std::vector<std::uint8_t>(w));
|
||||
std::queue<Point> q;
|
||||
for (pos_t i = 0; i < h; i++) {
|
||||
for (pos_t j = 0; j < w; j++) {
|
||||
if (at(i, j).type == TileType::Capital && at(i, j).owner == p) {
|
||||
vis[i][j] = 1;
|
||||
q.emplace(i, j);
|
||||
}
|
||||
}
|
||||
}
|
||||
Player v = neutral_player;
|
||||
while (!q.empty()) {
|
||||
pos_t x = q.front().x, y = q.front().y;
|
||||
q.pop();
|
||||
for (int i = 0; i < 4; i++) {
|
||||
pos_t xx = x + direction_dx[i], yy = y + direction_dy[i];
|
||||
Tile& tile = at(xx, yy);
|
||||
if (xx >= h || yy >= w || tile.type == TileType::Mountain
|
||||
|| tile.type != TileType::Stronghold || vis[xx][yy])
|
||||
continue;
|
||||
if (tile.type == TileType::Capital) {
|
||||
if (players[tile.owner].team != players[p].team)
|
||||
continue;
|
||||
v = tile.owner;
|
||||
break;
|
||||
}
|
||||
vis[xx][yy] = 1;
|
||||
q.emplace(xx, yy);
|
||||
}
|
||||
if (v != neutral_player)
|
||||
break;
|
||||
}
|
||||
for (pos_t i = 0; i < h; i++) {
|
||||
for (pos_t j = 0; j < w; j++) {
|
||||
Tile& tile = at(i, j);
|
||||
if (tile.owner == p) {
|
||||
setOwner(i, j, v);
|
||||
if (tile.type == TileType::Capital)
|
||||
tile.type = TileType::Stronghold;
|
||||
}
|
||||
}
|
||||
}
|
||||
new_defeated_players.push_back(p);
|
||||
players[p].is_defeated = 1;
|
||||
}
|
||||
|
||||
std::vector<TeamRanking> GameBoard::leaderboard() const {
|
||||
std::vector<TeamRanking> res(t);
|
||||
std::vector<PlayerRanking> prank(n);
|
||||
|
||||
for (Player i = 1; i <= n; ++i) {
|
||||
prank[i - 1].player = i;
|
||||
prank[i - 1].is_defeated = players[i].is_defeated;
|
||||
}
|
||||
|
||||
for (Team i = 1; i <= t; ++i)
|
||||
res[i - 1].team = i;
|
||||
|
||||
for (pos_t x = 0; x < h; ++x) {
|
||||
for (pos_t y = 0; y < w; ++y) {
|
||||
auto& tile = at(x, y);
|
||||
if (tile.owner == neutral_player)
|
||||
continue;
|
||||
prank[tile.owner - 1].land += 1;
|
||||
prank[tile.owner - 1].unit += tile.unit;
|
||||
}
|
||||
}
|
||||
|
||||
for (const auto& p : prank)
|
||||
res[teamOf(p.player) - 1].players.push_back(p);
|
||||
for (auto& team : res) {
|
||||
for (const auto& p : team.players) {
|
||||
team.land += p.land;
|
||||
team.unit += p.unit;
|
||||
}
|
||||
sort(team.players.begin(),
|
||||
team.players.end(),
|
||||
[](const PlayerRanking& a, const PlayerRanking& b) {
|
||||
return a.unit != b.unit ? a.unit > b.unit
|
||||
: a.player < b.player;
|
||||
});
|
||||
}
|
||||
sort(res.begin(),
|
||||
res.end(),
|
||||
[](const TeamRanking& a, const TeamRanking& b) {
|
||||
return a.unit != b.unit ? a.unit > b.unit : a.team < b.team;
|
||||
});
|
||||
return res;
|
||||
}
|
||||
|
||||
TeamViewDiff GameBoard::teamViewDiff(Team team) {
|
||||
TeamViewDiff res;
|
||||
res.team = team;
|
||||
for (const auto& pos : updated_tiles) {
|
||||
if (cover[team][pos.x][pos.y])
|
||||
diff_tiles[team].insert(pos);
|
||||
}
|
||||
for (const auto& pos : diff_tiles[team]) {
|
||||
auto x = pos.x, y = pos.y;
|
||||
res.diffs.emplace_back(x, y, cover[team][x][y] ? at(x, y) : Tile());
|
||||
}
|
||||
diff_tiles[team].clear();
|
||||
return res;
|
||||
}
|
||||
|
||||
std::vector<Tile> GameBoard::getViewOf(Team team) const {
|
||||
std::vector<Tile> res(h * w);
|
||||
for (pos_t x = 0; x < h; x++) {
|
||||
for (pos_t y = 0; y < w; y++) {
|
||||
if (cover[team][x][y])
|
||||
res[x * w + y] = at(x, y);
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
GameState GameBoard::tick() {
|
||||
halfturn_id++;
|
||||
|
||||
for (int _i = 1; _i <= n; _i++) {
|
||||
int i = (halfturn_id & 1) ? _i : n - _i + 1;
|
||||
if (!players[i].orders.empty()) {
|
||||
if (!attack(players[i].orders.front()))
|
||||
players[i].orders.clear();
|
||||
}
|
||||
}
|
||||
|
||||
if (!(halfturn_id % 50))
|
||||
roundUpdate();
|
||||
if (!(halfturn_id & 1))
|
||||
turnUpdate();
|
||||
|
||||
for (auto p : new_offline_players)
|
||||
offline(p);
|
||||
new_offline_players.clear();
|
||||
|
||||
GameState res;
|
||||
res.halfturn_id = halfturn_id;
|
||||
res.defeated_players = new_defeated_players;
|
||||
new_defeated_players.clear();
|
||||
for (Player i = 1; i <= n; i++) {
|
||||
if (!players[i].is_defeated)
|
||||
res.alive_players.push_back(i);
|
||||
}
|
||||
res.leaderboard = leaderboard();
|
||||
res.diffs.resize(t);
|
||||
for (Team i = 1; i <= t; i++)
|
||||
res.diffs[i] = teamViewDiff(i);
|
||||
updated_tiles.clear();
|
||||
return res;
|
||||
}
|
||||
|
||||
PlayerState::PlayerState() {
|
||||
is_defeated = false;
|
||||
}
|
||||
@ -1,79 +0,0 @@
|
||||
#ifndef OGLG_GAMEBOARD_H_
|
||||
#define OGLG_GAMEBOARD_H_
|
||||
|
||||
#include "PlayerMove.h"
|
||||
#include "pc/astuple.h"
|
||||
#include "pc/commcode.h"
|
||||
#include "pc/pctypes.h"
|
||||
#include <cstdint>
|
||||
#include <deque>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
|
||||
struct PlayerState {
|
||||
Player id;
|
||||
Team team;
|
||||
bool is_defeated;
|
||||
std::deque<PlayerMove> orders;
|
||||
|
||||
PlayerState();
|
||||
};
|
||||
|
||||
class ImportedTerrain;
|
||||
|
||||
class GameBoard {
|
||||
public:
|
||||
GameBoard(pos_t w, pos_t h, const InitInfo& info);
|
||||
|
||||
friend ImportedTerrain;
|
||||
|
||||
bool isTeammate(Player x, Player y) const;
|
||||
Team teamOf(Player x) const;
|
||||
bool isDefeated(Player x) const;
|
||||
|
||||
std::uint8_t numPlayers() const;
|
||||
std::uint8_t numTeams() const;
|
||||
|
||||
void appendOrderQueue(const PlayerMove& p);
|
||||
void clearOrderQueue(Player p);
|
||||
void popOrderQueue(Player p);
|
||||
void setOffline(Player p);
|
||||
|
||||
std::vector<Tile> getViewOf(Team x) const;
|
||||
GameState tick();
|
||||
|
||||
private:
|
||||
const Tile& at(pos_t x, pos_t y) const;
|
||||
Tile& at(pos_t x, pos_t y);
|
||||
void setOwner(pos_t x, pos_t y, Player p);
|
||||
|
||||
bool attack(const PlayerMove& o);
|
||||
void capitalCaptured(Player target, Player source);
|
||||
|
||||
void turnUpdate();
|
||||
void roundUpdate();
|
||||
void updatedPosition(pos_t x, pos_t y);
|
||||
|
||||
void offline(Player p);
|
||||
|
||||
std::vector<TeamRanking> leaderboard() const;
|
||||
|
||||
TeamViewDiff teamViewDiff(Team team);
|
||||
|
||||
std::uint8_t n, t;
|
||||
std::vector<PlayerState> players;
|
||||
|
||||
pos_t w, h, view_radius;
|
||||
std::vector<Tile> board;
|
||||
|
||||
std::uint32_t halfturn_id;
|
||||
|
||||
std::vector<std::vector<std::vector<std::uint8_t>>> cover;
|
||||
std::vector<std::set<Point>> diff_tiles;
|
||||
|
||||
std::vector<Player> new_offline_players;
|
||||
std::set<Point> updated_tiles;
|
||||
std::vector<Player> new_defeated_players;
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -1,26 +0,0 @@
|
||||
#include <cstdint>
|
||||
#include "PlayerMove.h"
|
||||
#include "pc/commcode.h"
|
||||
|
||||
bool PlayerMove::isValid(pos_t w, pos_t h) const {
|
||||
if (x >= h || y >= w)
|
||||
return false;
|
||||
|
||||
if ((int)dir >= 4)
|
||||
return false;
|
||||
|
||||
auto xx = tx(), yy = ty();
|
||||
if (xx >= h || yy >= w)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
pos_t PlayerMove::tx() const {
|
||||
return x + direction_dx[(std::size_t)dir];
|
||||
}
|
||||
|
||||
pos_t PlayerMove::ty() const {
|
||||
return y + direction_dy[(std::size_t)dir];
|
||||
}
|
||||
|
||||
@ -1,22 +0,0 @@
|
||||
#ifndef OGLG_PLAYERMOVE_H_
|
||||
#define OGLG_PLAYERMOVE_H_
|
||||
|
||||
#include "pc/astuple.h"
|
||||
#include "pc/commcode.h"
|
||||
#include "pc/pctypes.h"
|
||||
|
||||
struct PlayerMove {
|
||||
Player player;
|
||||
pos_t x, y;
|
||||
Direction dir;
|
||||
bool half;
|
||||
|
||||
bool isValid(pos_t w, pos_t h) const;
|
||||
pos_t tx() const;
|
||||
pos_t ty() const;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(player, x, y, dir, half)
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,307 +0,0 @@
|
||||
#include "terrain.h"
|
||||
#include <assert.h>
|
||||
#include <functional>
|
||||
#include <random>
|
||||
using namespace std;
|
||||
|
||||
BadImportTerrainConfig::BadImportTerrainConfig(size_t pt): pt(pt) {}
|
||||
|
||||
const char* BadImportTerrainConfig::what() const noexcept {
|
||||
return ("ImportTerrainConfig " + to_string(pt)).c_str();
|
||||
}
|
||||
|
||||
const char* BadCapitalAssign::what() const noexcept {
|
||||
return "Bad Capital Assign";
|
||||
}
|
||||
|
||||
inline namespace {
|
||||
|
||||
mt19937 rnd(19260817);
|
||||
enum class VertexType : std::uint8_t {
|
||||
Ordinary,
|
||||
Mountain,
|
||||
Capital,
|
||||
Cut
|
||||
};
|
||||
|
||||
bool ban(VertexType t) {
|
||||
return t == VertexType::Mountain || t == VertexType::Capital;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void upmin(T& x, const T& y) {
|
||||
if (y < x)
|
||||
x = y;
|
||||
}
|
||||
|
||||
bool findCut(pos_t w, pos_t h, vector<vector<VertexType>>& vertex_type) {
|
||||
int idx = 0;
|
||||
vector<vector<int>> dfn(h, vector<int>(w)), low = dfn;
|
||||
function<void(pos_t, pos_t, pos_t, pos_t, bool)> tarjan =
|
||||
[&](pos_t x, pos_t y, pos_t fx, pos_t fy, bool rt) {
|
||||
dfn[x][y] = low[x][y] = ++idx;
|
||||
int ch = 0;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
const pos_t xx = x + direction_dx[i], yy = y + direction_dy[i];
|
||||
if (xx >= h || yy >= w)
|
||||
continue;
|
||||
|
||||
if (vertex_type[xx][yy] == VertexType::Capital)
|
||||
vertex_type[x][y] = VertexType::Cut;
|
||||
|
||||
if (ban(vertex_type[xx][yy]) || (xx == fx && yy == fy))
|
||||
continue;
|
||||
|
||||
if (!dfn[xx][yy]) {
|
||||
ch++;
|
||||
tarjan(xx, yy, x, y, 0);
|
||||
upmin(low[x][y], low[xx][yy]);
|
||||
if (!rt && low[xx][yy] >= dfn[x][y])
|
||||
vertex_type[x][y] = VertexType::Cut;
|
||||
} else {
|
||||
upmin(low[x][y], dfn[xx][yy]);
|
||||
}
|
||||
}
|
||||
|
||||
if (rt && ch >= 2)
|
||||
vertex_type[x][y] = VertexType::Cut;
|
||||
};
|
||||
|
||||
bool flag = false;
|
||||
for (pos_t i = 0; i < h; i++) {
|
||||
for (pos_t j = 0; j < w; j++) {
|
||||
if (!ban(vertex_type[i][j]) && !dfn[i][j]) {
|
||||
if (flag)
|
||||
return false;
|
||||
flag = 1;
|
||||
tarjan(i, j, -1, -1, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
};
|
||||
|
||||
pair<bool, vector<Point>> generateCapital(
|
||||
pos_t w,
|
||||
pos_t h,
|
||||
vector<vector<VertexType>>& vertex_type,
|
||||
int r) {
|
||||
vector<Point> res(r);
|
||||
for (int i = 0; i <= r; i++) {
|
||||
if (!findCut(w, h, vertex_type))
|
||||
return {false, vector<Point>()};
|
||||
|
||||
if (i == r)
|
||||
break;
|
||||
vector<Point> options;
|
||||
for (pos_t x = 0; x < h; x++) {
|
||||
for (pos_t y = 0; y < w; y++) {
|
||||
if (vertex_type[x][y] == VertexType::Ordinary)
|
||||
options.emplace_back(x, y);
|
||||
if (vertex_type[x][y] == VertexType::Cut)
|
||||
vertex_type[x][y] = VertexType::Ordinary;
|
||||
}
|
||||
}
|
||||
|
||||
if (options.empty())
|
||||
return {false, {}};
|
||||
|
||||
res[i] = options[rnd() % options.size()];
|
||||
vertex_type[res[i].x][res[i].y] = VertexType::Capital;
|
||||
}
|
||||
return {true, res};
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
GameBoard ImportedTerrain::makeGameBoard(const InitInfo& init_info) {
|
||||
auto perm = [](std::uint8_t n) {
|
||||
vector<std::uint8_t> vec(n);
|
||||
iota(vec.begin(), vec.end(), 0);
|
||||
shuffle(vec.begin(), vec.end(), rnd);
|
||||
return vec;
|
||||
};
|
||||
|
||||
GameBoard g(w, h, init_info);
|
||||
|
||||
auto arrange = [&](const vector<Player>& players,
|
||||
const vector<vector<Point>>& capitals,
|
||||
vector<Player>& rest) {
|
||||
vector<Point> caps;
|
||||
for (const auto& v : capitals) {
|
||||
for (const auto& p : v)
|
||||
caps.push_back(p);
|
||||
if (caps.size() >= players.size())
|
||||
break;
|
||||
}
|
||||
auto C = perm(players.size()), D = perm(caps.size());
|
||||
for (size_t j = D.size(); j < C.size(); j++)
|
||||
rest.push_back(players[C[j]]);
|
||||
for (size_t j = 0; j < min(C.size(), D.size()); j++) {
|
||||
g.at(caps[D[j]].x, caps[D[j]].y).type = TileType::Capital;
|
||||
g.setOwner(caps[D[j]].x, caps[D[j]].y, players[C[j]]);
|
||||
}
|
||||
};
|
||||
|
||||
for (pos_t i = 0; i < h; i++) {
|
||||
for (pos_t j = 0; j < w; j++) {
|
||||
g.at(i, j).type = tiles[i][j].type;
|
||||
g.at(i, j).unit = tiles[i][j].unit;
|
||||
}
|
||||
}
|
||||
|
||||
vector<vector<Player>> players(g.numTeams());
|
||||
for (int i = 1, n = g.numPlayers(); i <= n; i++)
|
||||
players[g.teamOf(i) - 1].push_back(i);
|
||||
auto A = perm(players.size()), B = perm(capitals.size() - 1);
|
||||
vector<Player> rest1;
|
||||
for (size_t i = B.size(); i < A.size(); i++) {
|
||||
for (auto id : players[A[i]])
|
||||
rest1.push_back(id);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < min(A.size(), B.size()); i++)
|
||||
arrange(players[A[i]], capitals[B[i]], rest1);
|
||||
|
||||
vector<Player> rest2;
|
||||
arrange(rest1, capitals.back(), rest2);
|
||||
|
||||
for (pos_t x = 0; x < h; x++) {
|
||||
for (pos_t y = 0; y < w; y++) {
|
||||
if (g.at(x, y).type == TileType::Capital) {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
const pos_t xx = x + direction_dx[i],
|
||||
yy = y + direction_dy[i];
|
||||
if (xx >= h || yy >= w)
|
||||
continue;
|
||||
if (g.at(xx, yy).type == TileType::Capital)
|
||||
throw BadCapitalAssign();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int T = 5;
|
||||
|
||||
while (T--) {
|
||||
vector<vector<VertexType>> vertex_type(
|
||||
h,
|
||||
vector<VertexType>(w, VertexType::Ordinary));
|
||||
for (pos_t i = 0; i < h; i++) {
|
||||
for (pos_t j = 0; j < w; j++) {
|
||||
if (g.at(i, j).type == TileType::Mountain)
|
||||
vertex_type[i][j] = VertexType::Mountain;
|
||||
if (g.at(i, j).type == TileType::Capital)
|
||||
vertex_type[i][j] = VertexType::Capital;
|
||||
}
|
||||
}
|
||||
|
||||
auto pr = generateCapital(w, h, vertex_type, rest2.size());
|
||||
if (!pr.first)
|
||||
continue;
|
||||
|
||||
for (size_t i = 0; i < rest2.size(); i++) {
|
||||
g.at(pr.second[i].x, pr.second[i].y).type = TileType::Capital;
|
||||
g.setOwner(pr.second[i].x, pr.second[i].y, rest2[i]);
|
||||
}
|
||||
return g;
|
||||
}
|
||||
|
||||
throw BadCapitalAssign();
|
||||
}
|
||||
|
||||
ImportedTerrain importTerrain(const ImportTerrainConfig& in) {
|
||||
ImportedTerrain t;
|
||||
t.w = in.w;
|
||||
t.h = in.h;
|
||||
t.tiles.resize(t.h, vector<ImportedTerrain::TerrainTile>(t.w));
|
||||
|
||||
size_t pt = 0;
|
||||
auto error = [&]() { throw BadImportTerrainConfig(pt); };
|
||||
auto view = [&](char c) {
|
||||
return pt < in.value.size() && in.value[pt] == c ? (pt++, true) : false;
|
||||
};
|
||||
|
||||
auto jump = [&](char c) {
|
||||
if (!view(c))
|
||||
error();
|
||||
};
|
||||
|
||||
auto read = [&](int l = -99999, int r = 99999) {
|
||||
bool neg = view('-');
|
||||
if (!(pt < in.value.size() && isdigit(in.value[pt])))
|
||||
error();
|
||||
|
||||
std::int32_t x = 0;
|
||||
while (pt < in.value.size() && isdigit(in.value[pt])) {
|
||||
x = x * 10 + (in.value[pt] ^ '0');
|
||||
if (x > 99999)
|
||||
error();
|
||||
pt++;
|
||||
}
|
||||
if (neg)
|
||||
x = -x;
|
||||
if (x < l || x > r)
|
||||
error();
|
||||
return x;
|
||||
};
|
||||
|
||||
if (t.w < 5 || t.h < 5)
|
||||
error();
|
||||
|
||||
vector<vector<vector<Point>>> vec(27, vector<vector<Point>>(101));
|
||||
vector<vector<VertexType>> vertex_type(
|
||||
t.h,
|
||||
vector<VertexType>(t.w, VertexType::Ordinary));
|
||||
for (pos_t i = 0; i < t.h; i++) {
|
||||
for (pos_t j = 0; j < t.w; j++) {
|
||||
auto& p = t.tiles[i][j];
|
||||
if (view(' ')) {
|
||||
p.type = TileType::Blank;
|
||||
} else if (view('m')) {
|
||||
p.type = TileType::Mountain;
|
||||
vertex_type[i][j] = VertexType::Mountain;
|
||||
} else if (view('n')) {
|
||||
p.type = TileType::Blank;
|
||||
p.unit = read();
|
||||
} else if (view('s')) {
|
||||
p.type = TileType::Swamp;
|
||||
} else if (view('g')) {
|
||||
p.type = TileType::Blank;
|
||||
bool tag = 1;
|
||||
int team = (pt < in.value.size() && isupper(in.value[pt])
|
||||
? in.value[pt++] - 'A'
|
||||
: (tag = view(' '), 26));
|
||||
|
||||
int priority
|
||||
= (tag && pt < in.value.size() && isdigit(in.value[pt])
|
||||
? read(1, 99)
|
||||
: 100);
|
||||
vec[team][priority].emplace_back(i, j);
|
||||
} else {
|
||||
p.type = TileType::Stronghold;
|
||||
p.unit = read();
|
||||
}
|
||||
if (i + 1 < t.h || j + 1 < t.w)
|
||||
jump(',');
|
||||
}
|
||||
}
|
||||
|
||||
if (pt != in.value.size())
|
||||
error();
|
||||
if (!findCut(t.w, t.h, vertex_type))
|
||||
error();
|
||||
t.capitals.emplace_back();
|
||||
|
||||
for (int i = 0; i <= 26; i++) {
|
||||
for (int j = 100; j >= 1; j--) {
|
||||
if (!vec[i][j].empty()) {
|
||||
t.capitals.back().emplace_back().swap(vec[i][j]);
|
||||
}
|
||||
}
|
||||
if (!t.capitals.back().empty() && i != 26) {
|
||||
t.capitals.emplace_back();
|
||||
}
|
||||
}
|
||||
return t;
|
||||
}
|
||||
@ -1,44 +0,0 @@
|
||||
#ifndef OGLG_TERRAIN_H_
|
||||
#define OGLG_TERRAIN_H_
|
||||
|
||||
#include "logic/GameBoard.h"
|
||||
#include "pc/Point.h"
|
||||
#include "pc/commcode.h"
|
||||
#include "pc/pctypes.h"
|
||||
#include <exception>
|
||||
#include <vector>
|
||||
|
||||
class BadImportTerrainConfig : std::exception {
|
||||
public:
|
||||
BadImportTerrainConfig(size_t);
|
||||
virtual ~BadImportTerrainConfig() = default;
|
||||
virtual const char* what() const noexcept override;
|
||||
|
||||
private:
|
||||
size_t pt;
|
||||
};
|
||||
|
||||
class BadCapitalAssign : std::exception {
|
||||
public:
|
||||
virtual ~BadCapitalAssign() = default;
|
||||
virtual const char* what() const noexcept override;
|
||||
};
|
||||
|
||||
class ImportedTerrain {
|
||||
public:
|
||||
friend ImportedTerrain importTerrain(const ImportTerrainConfig& in);
|
||||
GameBoard makeGameBoard(const InitInfo& init_info);
|
||||
|
||||
private:
|
||||
struct TerrainTile {
|
||||
TileType type;
|
||||
std::int32_t unit;
|
||||
};
|
||||
pos_t w, h;
|
||||
std::vector<std::vector<TerrainTile>> tiles;
|
||||
std::vector<std::vector<std::vector<Point>>> capitals;
|
||||
};
|
||||
|
||||
ImportedTerrain importTerrain(const ImportTerrainConfig& in);
|
||||
|
||||
#endif
|
||||
@ -1,47 +0,0 @@
|
||||
#include "BinaryBuffer.h"
|
||||
#include <cstdint>
|
||||
|
||||
BinaryBuffer::BinaryBuffer() {}
|
||||
|
||||
BinaryBuffer::BinaryBuffer(std::size_t n, const byte *buf) {
|
||||
for (std::size_t i = 0; i < n; ++i)
|
||||
data.push_back(buf[i]);
|
||||
}
|
||||
|
||||
BinaryBuffer& BinaryBuffer::operator<<(const std::string_view& x) {
|
||||
std::uint32_t len = x.size();
|
||||
*this << len;
|
||||
for (char c : x)
|
||||
*this << c;
|
||||
return *this;
|
||||
}
|
||||
|
||||
BinaryBuffer& BinaryBuffer::operator>>(std::string& x) {
|
||||
std::uint32_t len;
|
||||
*this >> len;
|
||||
x.resize(len);
|
||||
for (char& c : x)
|
||||
*this >> c;
|
||||
return *this;
|
||||
}
|
||||
|
||||
std::size_t BinaryBuffer::size() const {
|
||||
return data.size();
|
||||
}
|
||||
|
||||
bool BinaryBuffer::empty() const {
|
||||
return data.empty();
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream &out, const BinaryBuffer &x) {
|
||||
for (auto v : x.data)
|
||||
out.put(v);
|
||||
return out;
|
||||
}
|
||||
|
||||
void BinaryBuffer::writeTo(std::FILE *out) const {
|
||||
auto sz = size();
|
||||
for (std::size_t i = 0; i < sz; ++i)
|
||||
fputc(data[i], out);
|
||||
}
|
||||
|
||||
@ -1,130 +0,0 @@
|
||||
#ifndef OG_BINARY_BUFFER_H_
|
||||
#define OG_BINARY_BUFFER_H_
|
||||
|
||||
#include <cstdint>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <deque>
|
||||
#include <concepts>
|
||||
#include <string_view>
|
||||
#include <iostream>
|
||||
|
||||
using byte = unsigned char;
|
||||
|
||||
inline namespace {
|
||||
|
||||
template <typename T>
|
||||
concept IsTupleLike = requires(T t) {
|
||||
std::tuple_size<T>::value;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
concept IsBasicType = std::integral<T> || std::is_enum<T>::value
|
||||
|| std::same_as<T, float> || std::same_as<T, double>;
|
||||
|
||||
template <typename T>
|
||||
concept IsTupleConvertable = requires(T t) {
|
||||
IsTupleLike<decltype(t.asTuple())>;
|
||||
};
|
||||
|
||||
static_assert(IsTupleLike<std::tuple<int, int, int>>);
|
||||
|
||||
}
|
||||
|
||||
class BinaryBuffer {
|
||||
public:
|
||||
BinaryBuffer();
|
||||
BinaryBuffer(std::size_t n, const byte *buf);
|
||||
|
||||
template <typename T>
|
||||
requires IsBasicType<T>
|
||||
BinaryBuffer& operator>>(T& x) {
|
||||
if (sizeof(T) <= data.size()) {
|
||||
auto ptr = reinterpret_cast<byte*>(&x);
|
||||
for (std::size_t i = 0; i < sizeof(T); ++i) {
|
||||
ptr[i] = data.front();
|
||||
data.pop_front();
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
requires IsBasicType<T>
|
||||
BinaryBuffer& operator<<(const T& x) {
|
||||
auto ptr = reinterpret_cast<const byte*>(&x);
|
||||
for (std::size_t i = 0; i < sizeof(T); ++i) {
|
||||
data.push_back(ptr[i]);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
BinaryBuffer& operator<<(const std::vector<T>& x) {
|
||||
uint32_t len = x.size();
|
||||
*this << len;
|
||||
for (const T& element : x)
|
||||
*this << element;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
BinaryBuffer& operator>>(std::vector<T>& x) {
|
||||
uint32_t len;
|
||||
*this >> len;
|
||||
x.resize(len);
|
||||
for (std::uint32_t i = 0; i < len; ++i)
|
||||
*this >> x[i];
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
requires IsTupleLike<T>
|
||||
BinaryBuffer& operator<<(const T& x) {
|
||||
std::apply([this](const auto&... elements) {
|
||||
(*this << ... << elements);
|
||||
}, x);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
requires IsTupleLike<T>
|
||||
BinaryBuffer& operator>>(T& x) {
|
||||
std::apply([this](auto&... elements) {
|
||||
(*this >> ... >> elements);
|
||||
}, x);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
requires IsTupleConvertable<T>
|
||||
BinaryBuffer& operator<<(const T &x) {
|
||||
*this << x.asTuple();
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
requires IsTupleConvertable<T>
|
||||
BinaryBuffer& operator>>(T &x) {
|
||||
*this >> x.asTuple();
|
||||
return *this;
|
||||
}
|
||||
|
||||
BinaryBuffer& operator<<(const std::string_view &);
|
||||
BinaryBuffer& operator>>(std::string&);
|
||||
|
||||
std::size_t size() const;
|
||||
bool empty() const;
|
||||
void writeTo(std::FILE *out) const;
|
||||
|
||||
friend std::ostream& operator<<(std::ostream &, const BinaryBuffer &);
|
||||
|
||||
private:
|
||||
std::deque<byte> data;
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream &, const BinaryBuffer &);
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,10 +0,0 @@
|
||||
#include "Point.h"
|
||||
|
||||
Point::Point() : x(0), y(0) {}
|
||||
|
||||
Point::Point(pos_t x, pos_t y) : x(x), y(y) {}
|
||||
|
||||
bool Point::operator<(const Point &o) const {
|
||||
return x == o.x ? y < o.y : x < o.x;
|
||||
}
|
||||
|
||||
@ -1,18 +0,0 @@
|
||||
#ifndef OGPC_POINT_H_
|
||||
#define OGPC_POINT_H_
|
||||
|
||||
#include "basictypes.h"
|
||||
#include "astuple.h"
|
||||
|
||||
struct Point {
|
||||
pos_t x, y;
|
||||
Point(pos_t x, pos_t y);
|
||||
Point();
|
||||
|
||||
bool operator<(const Point &o) const;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(x, y);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,39 +0,0 @@
|
||||
#include "ProcedureManager.h"
|
||||
|
||||
ProcedureManager::ProcedureManager() {}
|
||||
|
||||
struct ProcedureCallHeader {
|
||||
uint64_t rd;
|
||||
int32_t method;
|
||||
uint32_t len;
|
||||
};
|
||||
|
||||
struct ProcedureReturnHeader {
|
||||
uint64_t rd;
|
||||
uint32_t len;
|
||||
};
|
||||
|
||||
void ProcedureManager::handleCall(FILE *in, FILE *out) const {
|
||||
ProcedureCallHeader header;
|
||||
auto ptr = reinterpret_cast<byte*>(&header);
|
||||
std::size_t sz = 0;
|
||||
while (sz < sizeof(header))
|
||||
sz += fread(ptr + sz, 1, sizeof(header) - sz, in);
|
||||
|
||||
auto buf = new byte[header.len];
|
||||
sz = 0;
|
||||
while (sz < header.len)
|
||||
sz += fread(buf + sz, 1, header.len - sz, in);
|
||||
|
||||
BinaryBuffer bb(header.len, buf);
|
||||
delete[] buf;
|
||||
if (procedures.count(header.method)) {
|
||||
auto res = procedures.at(header.method)(bb);
|
||||
ProcedureReturnHeader rh;
|
||||
rh.rd = header.rd;
|
||||
rh.len = header.len;
|
||||
fwrite(&rh, 1, sizeof(rh), out);
|
||||
res.writeTo(out);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,60 +0,0 @@
|
||||
#ifndef OGPC_PMANAGER_H_
|
||||
#define OGPC_PMANAGER_H_
|
||||
|
||||
#include "BinaryBuffer.h"
|
||||
#include <map>
|
||||
#include <functional>
|
||||
#include <cstdint>
|
||||
#include <tuple>
|
||||
#include <type_traits>
|
||||
|
||||
inline namespace {
|
||||
|
||||
template <typename T>
|
||||
struct FuncArgTraits;
|
||||
|
||||
template <typename R, typename... T>
|
||||
struct FuncArgTraits<R(*)(T...)> {
|
||||
using type = std::tuple<T...>;
|
||||
};
|
||||
|
||||
template <typename R, typename... T>
|
||||
struct FuncArgTraits<std::function<R(T...)>> {
|
||||
using type = std::tuple<T...>;
|
||||
};
|
||||
|
||||
template <typename Callable>
|
||||
struct FuncArgTraits : FuncArgTraits<decltype(&Callable::operator())> {};
|
||||
|
||||
template <typename ReturnType, typename ClassType, typename... Args>
|
||||
struct FuncArgTraits<ReturnType(ClassType::*)(Args...) const> {
|
||||
using type = std::tuple<Args...>;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
class ProcedureManager {
|
||||
public:
|
||||
ProcedureManager();
|
||||
|
||||
template <typename T>
|
||||
void registerProcedure(const std::uint32_t &id, T&& func) {
|
||||
procedures[id] = [&func](BinaryBuffer &b) -> BinaryBuffer {
|
||||
using Arg = typename FuncArgTraits<typename std::decay<T>::type>::type;
|
||||
Arg x;
|
||||
b >> x;
|
||||
auto y = std::apply(func, std::move(x));
|
||||
BinaryBuffer res;
|
||||
res << y;
|
||||
return res;
|
||||
};
|
||||
}
|
||||
|
||||
void handleCall(FILE *in, FILE *out) const;
|
||||
|
||||
private:
|
||||
std::map<std::uint32_t, std::function<BinaryBuffer(BinaryBuffer&)>> procedures;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,22 +0,0 @@
|
||||
#ifndef OGPC_PROCEDURETYPE_H_
|
||||
#define OGPC_PROCEDURETYPE_H_
|
||||
|
||||
enum class ProcedureType : std::int32_t {
|
||||
setSeed = 0,
|
||||
setLogLevel = 1,
|
||||
getError = 2,
|
||||
getErrorInfo = 3,
|
||||
importTerrain = 10,
|
||||
randomTerrain = 11,
|
||||
appendOrderQueue = 20,
|
||||
clearOrderQueue = 21,
|
||||
popOrderQueue = 22,
|
||||
setOffline = 23,
|
||||
init = 30,
|
||||
tick = 31,
|
||||
getKeyFrame = 40,
|
||||
saveReplay = 50,
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,53 +0,0 @@
|
||||
#ifndef OGPC_ASTUPLE_H_
|
||||
#define OGPC_ASTUPLE_H_
|
||||
|
||||
#include "utility/macros.h"
|
||||
|
||||
#define OGPC_T__AS_DECLARETYPE_1(x) decltype(x)&
|
||||
#define OGPC_T__AS_DECLARETYPE_2(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_1(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_3(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_2(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_4(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_3(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_5(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_4(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_6(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_5(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_7(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_6(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_8(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_7(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_9(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_8(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_10(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_9(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_11(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_10(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_12(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_11(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_13(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_12(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_14(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_13(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_15(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_14(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE_16(x, ...) decltype(x)&, OGPC_T__AS_DECLARETYPE_15(__VA_ARGS__)
|
||||
#define OGPC_T__AS_DECLARETYPE(...) OG_M_CONCAT(OGPC_T__AS_DECLARETYPE_, OG_M_ARG_COUNT(__VA_ARGS__))(__VA_ARGS__)
|
||||
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_1(x) const decltype(x)&
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_2(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_1(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_3(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_2(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_4(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_3(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_5(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_4(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_6(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_5(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_7(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_6(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_8(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_7(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_9(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_8(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_10(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_9(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_11(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_10(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_12(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_11(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_13(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_12(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_14(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_13(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_15(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_14(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE_16(x, ...) const decltype(x)&, OGPC_T__AS_CONST_DECLARETYPE_15(__VA_ARGS__)
|
||||
#define OGPC_T__AS_CONST_DECLARETYPE(...) OG_M_CONCAT(OGPC_T__AS_CONST_DECLARETYPE_, OG_M_ARG_COUNT(__VA_ARGS__))(__VA_ARGS__)
|
||||
|
||||
#include <tuple>
|
||||
|
||||
#define OGPC_DECLARE_ASTUPLE(...) \
|
||||
std::tuple<OGPC_T__AS_DECLARETYPE(__VA_ARGS__)> asTuple() { \
|
||||
return {__VA_ARGS__}; \
|
||||
}\
|
||||
std::tuple<OGPC_T__AS_CONST_DECLARETYPE(__VA_ARGS__)> asTuple() const { \
|
||||
return {__VA_ARGS__}; \
|
||||
}\
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,15 +0,0 @@
|
||||
#ifndef OGPC_BASICTYPES_H_
|
||||
#define OGPC_BASICTYPES_H_
|
||||
|
||||
#include <cstdint>
|
||||
#include <tuple>
|
||||
|
||||
using Player = std::uint8_t;
|
||||
using Team = std::uint8_t;
|
||||
using pos_t = std::uint8_t;
|
||||
using Void = std::tuple<>;
|
||||
|
||||
const Player neutral_player = 0;
|
||||
const Team neutral_team = 0;
|
||||
|
||||
#endif
|
||||
@ -1,48 +0,0 @@
|
||||
#ifndef OGPC_COMMCODE_H_
|
||||
#define OGPC_COMMCODE_H_
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
enum class Direction : std::uint8_t {
|
||||
N = 0x00,
|
||||
S = 0x01,
|
||||
W = 0x02,
|
||||
E = 0x03,
|
||||
};
|
||||
|
||||
constexpr int direction_dx[] = {-1, 1, 0, 0};
|
||||
constexpr int direction_dy[] = {0, 0, -1, 1};
|
||||
|
||||
enum class LogLevel : std::uint8_t {
|
||||
Debug = 0x00,
|
||||
Info = 0x01,
|
||||
Warn = 0x02,
|
||||
Error = 0x03,
|
||||
Fatal = 0x04,
|
||||
};
|
||||
|
||||
enum class TileType : std::uint8_t {
|
||||
Misty = 0x00,
|
||||
Mountain = 0x01,
|
||||
Stronghold = 0x02,
|
||||
Blank = 0x03,
|
||||
Capital = 0x04,
|
||||
Swamp = 0x05,
|
||||
};
|
||||
|
||||
enum class MistyTileType : std::uint8_t {
|
||||
MountainLike = 0x01,
|
||||
BlankLike = 0x02,
|
||||
Swamp = 0x03,
|
||||
};
|
||||
|
||||
enum class ModifierType : std::uint8_t {
|
||||
Leapfrog = 0x01,
|
||||
CityState = 0x02,
|
||||
MistyVeil = 0x03,
|
||||
CrystalClear = 0x04,
|
||||
SilentWar = 0x05,
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,9 +0,0 @@
|
||||
#include "pctypes.h"
|
||||
|
||||
PlayerRanking::PlayerRanking() : player(neutral_player)
|
||||
, is_defeated(false), land(0), unit(0) {}
|
||||
|
||||
TeamRanking::TeamRanking() : team(neutral_team), land(0), unit(0) {}
|
||||
|
||||
Tile::Tile() : owner(neutral_player), type(TileType::Misty), unit(0) {}
|
||||
|
||||
@ -1,147 +0,0 @@
|
||||
#ifndef OGPC_PCTYPES_H_
|
||||
#define OGPC_PCTYPES_H_
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "basictypes.h"
|
||||
#include "astuple.h"
|
||||
#include "commcode.h"
|
||||
#include "Point.h"
|
||||
|
||||
struct uuid {
|
||||
std::uint64_t low, high;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(low, high)
|
||||
};
|
||||
|
||||
struct ImportTerrainConfig {
|
||||
pos_t w, h;
|
||||
std::string value;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(w, h, value)
|
||||
};
|
||||
|
||||
struct RandomTerrainConfig {
|
||||
pos_t w, h;
|
||||
std::uint8_t city_dense, mountain_dense, swamp_dense, light_dense;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(w, h, city_dense, mountain_dense, swamp_dense, light_dense)
|
||||
};
|
||||
|
||||
struct PlayerRanking {
|
||||
Player player;
|
||||
bool is_defeated;
|
||||
std::uint16_t land;
|
||||
std::int32_t unit;
|
||||
|
||||
PlayerRanking();
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(player, is_defeated, land, unit)
|
||||
};
|
||||
|
||||
struct TeamRanking {
|
||||
Team team;
|
||||
std::uint16_t land;
|
||||
std::int32_t unit;
|
||||
std::vector<PlayerRanking> players;
|
||||
|
||||
TeamRanking();
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(team, land, unit, players)
|
||||
};
|
||||
|
||||
struct Tile {
|
||||
Player owner;
|
||||
TileType type;
|
||||
std::int32_t unit;
|
||||
|
||||
Tile();
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(owner, type, unit)
|
||||
};
|
||||
|
||||
struct TileDiff {
|
||||
pos_t x, y;
|
||||
Tile value;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(x, y, value)
|
||||
};
|
||||
|
||||
struct TeamViewDiff {
|
||||
Team team;
|
||||
std::vector<TileDiff> diffs;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(team, diffs)
|
||||
};
|
||||
|
||||
struct GameState {
|
||||
std::uint32_t halfturn_id;
|
||||
std::vector<Player> defeated_players;
|
||||
std::vector<Player> alive_players;
|
||||
std::vector<TeamRanking> leaderboard;
|
||||
std::vector<TeamViewDiff> diffs;
|
||||
std::vector<std::string> msg;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(halfturn_id, defeated_players, alive_players, leaderboard, diffs, msg)
|
||||
};
|
||||
|
||||
struct Modifier {
|
||||
ModifierType key;
|
||||
std::int32_t value;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(key, value)
|
||||
};
|
||||
|
||||
struct PlayerMove;
|
||||
|
||||
struct ReplayStep {
|
||||
std::uint32_t halfturn_id;
|
||||
std::vector<PlayerMove> player_moves;
|
||||
std::vector<Player> offline_events;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(halfturn_id, player_moves, offline_events)
|
||||
};
|
||||
|
||||
struct PlayerInfo {
|
||||
uuid uid;
|
||||
Player id;
|
||||
Team team;
|
||||
std::string name;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(uid, id, team, name)
|
||||
};
|
||||
|
||||
struct InitInfo {
|
||||
std::uint8_t n;
|
||||
std::vector<Player> player_team;
|
||||
std::vector<Modifier> modifiers;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(n, player_team, modifiers)
|
||||
};
|
||||
|
||||
struct Replay {
|
||||
uuid rid;
|
||||
std::uint64_t timestamp;
|
||||
std::int8_t speed;
|
||||
InitInfo init_info;
|
||||
std::uint32_t length;
|
||||
std::uint8_t player_num;
|
||||
std::vector<PlayerInfo> players;
|
||||
Team winner;
|
||||
std::vector<Tile> terrain;
|
||||
std::vector<ReplayStep> steps;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(rid, timestamp, speed, init_info, length, player_num, players, winner, terrain, steps)
|
||||
};
|
||||
|
||||
struct GameInfo {
|
||||
uuid rid;
|
||||
std::int8_t speed;
|
||||
std::vector<PlayerInfo> players;
|
||||
|
||||
OGPC_DECLARE_ASTUPLE(rid, speed, players)
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,32 +0,0 @@
|
||||
#include "pc/BinaryBuffer.h"
|
||||
#include "pc/astuple.h"
|
||||
#include "test/u.hpp"
|
||||
|
||||
inline namespace {
|
||||
|
||||
struct Point {
|
||||
int x, y, z;
|
||||
OGPC_DECLARE_ASTUPLE(x, y, z);
|
||||
};
|
||||
|
||||
AddTestCase _(10, "BinaryBuffer", [](TestCase& t) {
|
||||
t.expectEq<int>([] {
|
||||
BinaryBuffer bb;
|
||||
int x, y = 10;
|
||||
bb << y;
|
||||
bb >> x;
|
||||
return x;
|
||||
}, 10);
|
||||
|
||||
t.expectEq<std::tuple<int, int, int>>([] {
|
||||
BinaryBuffer bb;
|
||||
Point x{1, 2, 4};
|
||||
std::tuple<int, int, int> y;
|
||||
bb << x;
|
||||
bb >> y;
|
||||
return y;
|
||||
}, {1, 2, 4});
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
@ -1,55 +0,0 @@
|
||||
#include "pc/ProcedureManager.h"
|
||||
#include "pc/BinaryBuffer.h"
|
||||
#include "test/u.hpp"
|
||||
#include <tuple>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
|
||||
inline namespace {
|
||||
|
||||
using Void = std::tuple<>;
|
||||
|
||||
AddTestCase _(20, "ProcedureManager", [](TestCase& t) {
|
||||
t.expectEq<int>([] {
|
||||
std::int32_t x = 0;
|
||||
auto f1 = [&x] (std::int32_t d) -> Void {
|
||||
x += d;
|
||||
return {};
|
||||
};
|
||||
|
||||
auto f2 = [&x] (std::int32_t d) -> Void {
|
||||
x -= d;
|
||||
return {};
|
||||
};
|
||||
|
||||
ProcedureManager pm;
|
||||
pm.registerProcedure(1, f1);
|
||||
pm.registerProcedure(2, f2);
|
||||
|
||||
unsigned char ibuf[256] = {
|
||||
0x45, 0x27, 0xd1, 0xf2, 0x93, 0x43, 0xfc, 0xb1,
|
||||
0x01, 0x00, 0x00, 0x00,
|
||||
0x04, 0x00, 0x00, 0x00,
|
||||
0x02, 0x00, 0x00, 0x00,
|
||||
0x45, 0x27, 0xd1, 0xf2, 0x93, 0x43, 0xfc, 0xb2,
|
||||
0x02, 0x00, 0x00, 0x00,
|
||||
0x04, 0x00, 0x00, 0x00,
|
||||
0x01, 0x00, 0x00, 0x00,
|
||||
};
|
||||
|
||||
FILE *in = fopen(".in.tmp", "wb");
|
||||
fwrite(ibuf, 128, 1, in);
|
||||
fclose(in);
|
||||
in = fopen(".in.tmp", "rb");
|
||||
FILE *out = fopen(".out.tmp", "wb");
|
||||
|
||||
pm.handleCall(in, out);
|
||||
pm.handleCall(in, out);
|
||||
fclose(in);
|
||||
fclose(out);
|
||||
return x;
|
||||
}, 1);
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
@ -1,19 +0,0 @@
|
||||
#include "test/u.hpp"
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
|
||||
namespace {
|
||||
|
||||
AddTestCase _(0, "tester", [](TestCase& t) {
|
||||
t.expectTrue([] { return true; });
|
||||
t.expectFalse([] { return false; });
|
||||
t.expectTrue([] {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(200));
|
||||
return true;
|
||||
});
|
||||
|
||||
t.expectEq<int>([] { return 42; }, 42);
|
||||
t.expectEq<float>([] { return 10 + 1e-7; }, 10);
|
||||
t.expectEq<double>([] { return 10 + 1e-10; }, 10);
|
||||
});
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
#include "test/u.hpp"
|
||||
|
||||
int main() {
|
||||
return TestSuit::getInstance()->evalTestCases();
|
||||
}
|
||||
@ -1,205 +0,0 @@
|
||||
#ifndef HEADER_TEST_U_HPP
|
||||
#define HEADER_TEST_U_HPP
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
#include <exception>
|
||||
#include <functional>
|
||||
#include <optional>
|
||||
#include <type_traits>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
|
||||
template<typename T>
|
||||
struct TestDefaultEps {};
|
||||
|
||||
template<>
|
||||
struct TestDefaultEps<float> {
|
||||
static constexpr float value = 1e-6;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct TestDefaultEps<double> {
|
||||
static constexpr double value = 1e-9;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct TestDefaultEps<long double> {
|
||||
static constexpr long double value = 1e-12;
|
||||
};
|
||||
|
||||
class TestCase {
|
||||
public:
|
||||
TestCase(int id, const char* title): ok(0), fail(0), n(0), ended(false), time_used(0) {
|
||||
std::printf("[%02d]Testing %s:\n", id, title);
|
||||
}
|
||||
|
||||
void expectTrue(std::function<bool()> func) noexcept {
|
||||
expectEq<bool>(func, true);
|
||||
}
|
||||
|
||||
void expectFalse(std::function<bool()> func) noexcept {
|
||||
expectEq<bool>(func, false);
|
||||
}
|
||||
|
||||
template<typename T, typename EPS = TestDefaultEps<T>>
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type expectEq(
|
||||
std::function<T()> func,
|
||||
T&& answer) noexcept {
|
||||
auto res = runTask(func);
|
||||
if (!res.has_value()) {
|
||||
return onError();
|
||||
}
|
||||
|
||||
if (std::abs(res.value() - answer) < EPS::value) {
|
||||
onPass();
|
||||
} else {
|
||||
onFail();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
typename std::enable_if<!std::is_floating_point<T>::value>::type expectEq(
|
||||
std::function<T()> func,
|
||||
T&& answer) noexcept {
|
||||
auto res = runTask(func);
|
||||
if (!res.has_value()) {
|
||||
return onError();
|
||||
}
|
||||
|
||||
if (res.value() == answer) {
|
||||
onPass();
|
||||
} else {
|
||||
onFail();
|
||||
}
|
||||
}
|
||||
|
||||
void end() noexcept {
|
||||
if (ended) {
|
||||
return;
|
||||
}
|
||||
ended = true;
|
||||
|
||||
std::putchar('\n');
|
||||
for (int i = 0; i < 20; ++i) {
|
||||
std::putchar('-');
|
||||
}
|
||||
std::putchar('\n');
|
||||
if (fail) {
|
||||
if (fail == 1) {
|
||||
std::puts("1 test failed.");
|
||||
} else {
|
||||
std::printf("%d tests failed.\n", fail);
|
||||
}
|
||||
} else {
|
||||
if (ok == 1) {
|
||||
std::printf("OK. 1 test passed");
|
||||
} else {
|
||||
std::printf("OK. %d tests passed", ok);
|
||||
}
|
||||
std::printf(" in %lldms.\n", static_cast<long long>(time_used.count()));
|
||||
}
|
||||
}
|
||||
|
||||
bool hasFail() const noexcept {
|
||||
return fail > 0;
|
||||
}
|
||||
|
||||
private:
|
||||
void putchar(char c) noexcept {
|
||||
n += 1;
|
||||
if (n > 1 && n % 15 == 1) {
|
||||
std::putchar('\n');
|
||||
}
|
||||
std::putchar(c);
|
||||
}
|
||||
|
||||
void onPass() noexcept {
|
||||
ok += 1;
|
||||
putchar('.');
|
||||
}
|
||||
|
||||
void onFail() noexcept {
|
||||
fail += 1;
|
||||
putchar('F');
|
||||
}
|
||||
|
||||
void onError() noexcept {
|
||||
fail += 1;
|
||||
putchar('E');
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::optional<T> runTask(std::function<T()> func) noexcept {
|
||||
auto start = std::chrono::high_resolution_clock::now();
|
||||
try {
|
||||
T res = func();
|
||||
auto end = std::chrono::high_resolution_clock::now();
|
||||
auto dt = end - start;
|
||||
time_used += std::chrono::duration_cast<std::chrono::milliseconds>(dt);
|
||||
return {res};
|
||||
} catch (...) {
|
||||
return std::nullopt;
|
||||
}
|
||||
}
|
||||
|
||||
int ok, fail, n;
|
||||
bool ended;
|
||||
std::chrono::milliseconds time_used;
|
||||
};
|
||||
|
||||
class TestSuit {
|
||||
TestSuit(const TestSuit&) = delete;
|
||||
TestSuit(TestSuit&&) = delete;
|
||||
|
||||
public:
|
||||
static TestSuit* getInstance() {
|
||||
if (!instance) {
|
||||
instance = new TestSuit();
|
||||
}
|
||||
return instance;
|
||||
}
|
||||
|
||||
void addTestCase(int id, const char* title, std::function<void(TestCase&)> f) {
|
||||
tc.emplace_back(id, title, f);
|
||||
}
|
||||
|
||||
int evalTestCases() {
|
||||
std::sort(tc.begin(), tc.end(), [](const auto &x, const auto &y) {
|
||||
return std::get<0>(x) < std::get<0>(y);
|
||||
});
|
||||
|
||||
for (auto [id, title, func] : tc) {
|
||||
TestCase t(id, title);
|
||||
func(t);
|
||||
t.end();
|
||||
std::putchar('\n');
|
||||
if (t.hasFail()) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
tc.clear();
|
||||
return 0;
|
||||
}
|
||||
|
||||
private:
|
||||
static inline TestSuit* instance = nullptr;
|
||||
TestSuit() {}
|
||||
|
||||
std::vector<std::tuple<int, const char*, std::function<void(TestCase&)>>> tc;
|
||||
};
|
||||
|
||||
class AddTestCase {
|
||||
AddTestCase() = delete;
|
||||
AddTestCase(const AddTestCase&) = delete;
|
||||
AddTestCase(AddTestCase&&) = delete;
|
||||
|
||||
public:
|
||||
AddTestCase(int id, const char* tilte, std::function<void(TestCase&)> func) {
|
||||
TestSuit::getInstance()->addTestCase(id, tilte, func);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // HEADER_TEST_U_HPP
|
||||
|
||||
@ -1,51 +0,0 @@
|
||||
#include "log.h"
|
||||
#include <cstdio>
|
||||
#include <ctime>
|
||||
|
||||
Logger* Logger::getInstance() {
|
||||
return instance_;
|
||||
}
|
||||
|
||||
void Logger::debug(const std::string& s) const {
|
||||
_log(LogLevel::Debug, s);
|
||||
}
|
||||
|
||||
void Logger::info(const std::string& s) const {
|
||||
_log(LogLevel::Info, s);
|
||||
}
|
||||
|
||||
void Logger::warn(const std::string& s) const {
|
||||
_log(LogLevel::Warn, s);
|
||||
}
|
||||
|
||||
void Logger::error(const std::string& s) const {
|
||||
_log(LogLevel::Error, s);
|
||||
}
|
||||
|
||||
void Logger::fatal(const std::string& s) const {
|
||||
_log(LogLevel::Fatal, s);
|
||||
}
|
||||
|
||||
void Logger::setLogLeval(LogLevel v) {
|
||||
filter = v;
|
||||
}
|
||||
|
||||
Logger::Logger() {
|
||||
filter = LogLevel::Warn;
|
||||
}
|
||||
|
||||
Logger* const Logger::instance_ = new Logger();
|
||||
|
||||
void Logger::_log(LogLevel v, const std::string& s) const {
|
||||
if (v >= filter) {
|
||||
time_t now = time(NULL);
|
||||
static char buff[100];
|
||||
strftime(buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", localtime(&now));
|
||||
const char* mp = "DIWEF";
|
||||
fprintf(stderr, "%s [%c] %s\n", buff, mp[(int)v], s.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
Logger* Log() {
|
||||
return Logger::getInstance();
|
||||
}
|
||||
@ -1,30 +0,0 @@
|
||||
#ifndef OG_LOG_H_
|
||||
#define OG_LOG_H_
|
||||
|
||||
#include "pc/commcode.h"
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
|
||||
class Logger {
|
||||
public:
|
||||
static Logger* getInstance();
|
||||
|
||||
void debug(const std::string&) const;
|
||||
void info(const std::string&) const;
|
||||
void warn(const std::string&) const;
|
||||
void error(const std::string&) const;
|
||||
void fatal(const std::string&) const;
|
||||
void setLogLeval(LogLevel v);
|
||||
|
||||
private:
|
||||
Logger();
|
||||
static Logger* const instance_;
|
||||
|
||||
void _log(LogLevel v, const std::string&) const;
|
||||
|
||||
LogLevel filter;
|
||||
};
|
||||
|
||||
Logger* Log();
|
||||
|
||||
#endif
|
||||
@ -1,27 +0,0 @@
|
||||
#ifndef OG_MACROS_H_
|
||||
#define OG_MACROS_H_
|
||||
|
||||
#define OG_M_ARG_COUNT__( \
|
||||
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
|
||||
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
|
||||
_21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
|
||||
_31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \
|
||||
_41, _42, _43, _44, _45, _46, _47, _48, _49, _50, \
|
||||
_51, _52, _53, _54, _55, _56, _57, _58, _59, _60, \
|
||||
_61, _62, _63, N, ...) \
|
||||
N
|
||||
|
||||
#define OG_M_ARG_COUNT(...) OG_M_ARG_COUNT__(__VA_ARGS__ \
|
||||
, 63, 62, 61, 60, \
|
||||
59, 58, 57, 56, 55, 54, 53, 52, 51, 50, \
|
||||
49, 48, 47, 46, 45, 44, 43, 42, 41, 40, \
|
||||
39, 38, 37, 36, 35, 34, 33, 32, 31, 30, \
|
||||
29, 28, 27, 26, 25, 24, 23, 22, 21, 20, \
|
||||
19, 18, 17, 16, 15, 14, 13, 12, 11, 10, \
|
||||
9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
|
||||
|
||||
#define OG_M_CONCAT__(a, b) a##b
|
||||
#define OG_M_CONCAT(a, b) OG_M_CONCAT__(a, b)
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,28 +0,0 @@
|
||||
set_project("opengenerals-processor")
|
||||
set_basename("ogprocessor")
|
||||
set_version("0.1.0")
|
||||
set_languages("c++20")
|
||||
set_targetdir("build")
|
||||
|
||||
add_includedirs(".", "pc", "utility", "logic")
|
||||
|
||||
add_files("pc/*.cpp", "utility/*.cpp", "logic/*.cpp")
|
||||
target("main")
|
||||
set_default(true)
|
||||
set_kind("binary")
|
||||
add_files("main.cpp")
|
||||
set_warnings("allextra")
|
||||
|
||||
target("test")
|
||||
set_default(false)
|
||||
set_kind("binary")
|
||||
set_prefixname("test-")
|
||||
|
||||
add_files("test/**/*.cpp")
|
||||
add_files("test/main.cpp")
|
||||
|
||||
set_warnings("allextra")
|
||||
set_optimize("none")
|
||||
set_symbols("debug")
|
||||
add_defines("DEBUG")
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user