Lucas de Vries
620 lines
16 KiB
ActionScript
620 lines
16 KiB
ActionScript
#priority init -200
|
|
import tabs.Tab;
|
|
import tabs.tabbar;
|
|
import elements.GuiButton;
|
|
import elements.GuiText;
|
|
import elements.GuiMarkupText;
|
|
import elements.GuiEmpire;
|
|
import elements.GuiSkinElement;
|
|
import elements.GuiListbox;
|
|
import elements.GuiPanel;
|
|
import elements.MarkupTooltip;
|
|
import util.formatting;
|
|
import icons;
|
|
from multiplayer import wantSpectator;
|
|
|
|
class VictoryTab : Tab {
|
|
GuiText@ heading;
|
|
|
|
GuiSkinElement@ victorPanel;
|
|
GuiMarkupText@ description;
|
|
GuiEmpire@ victor;
|
|
|
|
GuiSkinElement@ buttonBar;
|
|
GuiPanel@ buttonPanel;
|
|
|
|
GuiButton@ rankingsButton;
|
|
GuiListbox@ rankings;
|
|
|
|
array<StatPage@> stats;
|
|
array<GuiButton@> statButtons;
|
|
Alignment@ statAlign;
|
|
|
|
Sprite typeIcon;
|
|
|
|
VictoryTab() {
|
|
super();
|
|
|
|
@heading = GuiText(this, Alignment(Left, Top+30, Right, Top+90));
|
|
heading.horizAlign = 0.5;
|
|
heading.font = FT_Big;
|
|
heading.color = colors::Green;
|
|
heading.stroke = colors::Black;
|
|
|
|
@victorPanel = GuiSkinElement(this, Alignment(Left+0.1f, Top+90, Right-0.1f, Top+242), SS_Panel);
|
|
|
|
@victor = GuiEmpire(victorPanel, Alignment(Left+6, Top+6, Width=140, Height=140));
|
|
|
|
@description = GuiMarkupText(victorPanel, Alignment(Left+220, Top+20, Right-6, Bottom-6));
|
|
description.defaultFont = FT_Subtitle;
|
|
|
|
@buttonBar = GuiSkinElement(this, Alignment(Left+0.1f, Top+242+20, Right-0.1f, Height=42), SS_PlainBox);
|
|
@buttonPanel = GuiPanel(this, Alignment(Left+0.1f, Top+242, Right-0.1f, Height=62));
|
|
buttonPanel.vertType = ST_Never;
|
|
|
|
@statAlign = Alignment(Left+0.1f, Top+242+62, Right-0.1f, Bottom-30);
|
|
|
|
if(!playerEmpire.valid) {
|
|
victorPanel.visible = false;
|
|
heading.visible = false;
|
|
buttonBar.alignment.top.pixels = 32;
|
|
buttonPanel.alignment.top.pixels = 12;
|
|
statAlign.top.pixels = 74;
|
|
}
|
|
|
|
@rankingsButton = GuiButton(buttonPanel, Alignment(Left, Bottom-40, Width=135, Height=40), locale::V_RANKINGS);
|
|
rankingsButton.buttonIcon = Sprite(material::PointsIcon);
|
|
rankingsButton.toggleButton = true;
|
|
rankingsButton.pressed = true;
|
|
rankingsButton.font = FT_Bold;
|
|
@rankings = GuiListbox(this, statAlign);
|
|
rankings.itemHeight = 40;
|
|
rankings.disabled = true;
|
|
rankings.vertPadding = 8;
|
|
rankings.style = SS_Panel;
|
|
|
|
addStat(ST_Int, stat::Points, 60, locale::STAT_POINTS, Sprite(material::PointsIcon), 2000);
|
|
addStat(ST_Float, stat::Military, 60, locale::STAT_STRENGTH, icons::Strength, 5000);
|
|
addStat(ST_Int, stat::Planets, 15, locale::STAT_PLANETS, icons::Planet, 10);
|
|
addStat(ST_Int, stat::Ships, 15, locale::STAT_SHIPS, icons::Defense, 10);
|
|
addStat(ST_Float, stat::Budget, 60, locale::STAT_BUDGET, icons::Money, 2000);
|
|
addStat(ST_Float, stat::NetBudget, 60, locale::STAT_NET_BUDGET, icons::Money, 2000);
|
|
addStat(ST_Float, stat::EnergyIncome, 60, locale::STAT_ENERGY_INCOME, icons::Energy, 2);
|
|
addStat(ST_Float, stat::InfluenceIncome, 60, locale::STAT_INFLUENCE_INCOME, icons::Influence, 3/60.0);
|
|
addStat(ST_Float, stat::ResearchIncome, 60, locale::STAT_RESEARCH_INCOME, icons::Research, 2);
|
|
addStat(ST_Float, stat::ResearchTotal, 60, locale::STAT_RESEARCH_TOTAL, icons::Research, 1000);
|
|
|
|
updateAbsolutePosition();
|
|
update();
|
|
|
|
locked = true;
|
|
}
|
|
|
|
void addStat(StatType type, stat::EmpireStat Stat, int FilterDuration, const string& name, const Sprite& icon, double baseMax = 1) {
|
|
StatPage page(this, statAlign, type, Stat, FilterDuration, name, baseMax);
|
|
page.visible = false;
|
|
stats.insertLast(page);
|
|
|
|
int index = stats.length;
|
|
GuiButton btn(buttonPanel, Alignment(Left+135*index, Bottom-40, Width=135, Height=40), name);
|
|
btn.toggleButton = true;
|
|
btn.pressed = false;
|
|
btn.buttonIcon = icon;
|
|
btn.font = FT_Bold;
|
|
statButtons.insertLast(btn);
|
|
}
|
|
|
|
Color get_activeColor() {
|
|
return Color(0xffc283ff);
|
|
}
|
|
|
|
Color get_inactiveColor() {
|
|
return Color(0xffb900ff);
|
|
}
|
|
|
|
Color get_seperatorColor() {
|
|
return Color(0x8d7949ff);
|
|
}
|
|
|
|
Sprite get_icon() {
|
|
return typeIcon;
|
|
}
|
|
|
|
void switchPage(uint page) {
|
|
rankings.visible = page == 0;
|
|
rankingsButton.pressed = page == 0;
|
|
|
|
for(uint i = 0, cnt = stats.length; i < cnt; ++i) {
|
|
stats[i].visible = i+1 == page;
|
|
statButtons[i].pressed = i+1 == page;
|
|
}
|
|
}
|
|
|
|
void tick(double time) {
|
|
update();
|
|
}
|
|
|
|
int lastUpdate = systemTime - 1000;
|
|
bool fullUpdate = true;
|
|
uint nextUpdateIndex = 0;
|
|
|
|
void update() {
|
|
if(systemTime - lastUpdate < 1000)
|
|
return;
|
|
lastUpdate = systemTime;
|
|
|
|
Empire@ winner = playerEmpire;
|
|
int myVictory = playerEmpire.Victory;
|
|
|
|
for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
|
|
if(getEmpire(i).Victory == 1) {
|
|
@winner = getEmpire(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Show the appropriate victory message
|
|
if(myVictory == 1) {
|
|
heading.text = locale::V_WON_TITLE;
|
|
heading.color = colors::Green;
|
|
description.text = format(locale::V_WON_TEXT, formatEmpireName(winner), formatEmpireName(playerEmpire));
|
|
typeIcon = Sprite(material::PointsIcon);
|
|
}
|
|
else if(myVictory == -2 && playerEmpire.SubjugatedBy.Victory == 1) {
|
|
heading.text = locale::V_LESSER_TITLE;
|
|
heading.color = Color(0xfff500ff);
|
|
description.text = format(locale::V_LESSER_TEXT, formatEmpireName(winner), formatEmpireName(playerEmpire));
|
|
typeIcon = Sprite(material::PointsIcon);
|
|
}
|
|
else {
|
|
heading.text = locale::V_LOST_TITLE;
|
|
heading.color = colors::Red;
|
|
description.text = format(locale::V_LOST_TEXT, formatEmpireName(winner), formatEmpireName(playerEmpire));
|
|
typeIcon = Sprite(material::SystemUnderAttack);
|
|
}
|
|
|
|
if(victorPanel.visible)
|
|
title = heading.text;
|
|
else
|
|
title = locale::V_SCORES;
|
|
|
|
//Update rankings
|
|
array<EmpSorter> sorted;
|
|
for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
|
|
Empire@ other = getEmpire(i);
|
|
if(other.major) {
|
|
EmpSorter sort;
|
|
@sort.emp = other;
|
|
sorted.insertLast(sort);
|
|
}
|
|
}
|
|
sorted.sortAsc();
|
|
|
|
rankings.clearItems();
|
|
for(uint i = 0, cnt = sorted.length; i < cnt; ++i) {
|
|
Empire@ emp = sorted[i].emp;
|
|
string text = "";
|
|
|
|
text += format(" #$1", toString(i+1));
|
|
text += format("[offset=100][img=$2;28;$3/] $1[/offset]", formatEmpireName(emp),
|
|
getSpriteDesc(Sprite(emp.flag)), toString(emp.color));
|
|
|
|
if(hasGameEnded()) {
|
|
string victory = "";
|
|
if(emp.SubjugatedBy !is null)
|
|
victory = format("[color=#aaa]$1[/color]", format(locale::V_SUBJUGATED, formatEmpireName(emp.SubjugatedBy)));
|
|
else if(emp.Victory == 1)
|
|
victory = format("[color=#0f0]$1[/color]", locale::V_WON_TITLE);
|
|
else
|
|
victory = format("[color=#f00]$1[/color]", locale::V_LOST_TITLE);
|
|
text += format("[offset=450]$1[/offset]", victory);
|
|
}
|
|
else {
|
|
string victory;
|
|
if(emp.SubjugatedBy !is null)
|
|
victory = format("[color=#aaa]$1[/color]", format(locale::V_SUBJUGATED, formatEmpireName(emp.SubjugatedBy)));
|
|
text += format("[offset=450]$1[/offset]", victory);
|
|
}
|
|
|
|
text += format("[offset=880]$1[/offset]", format(locale::EMPIRE_POINTS, toString(emp.points.value)));
|
|
rankings.addItem(GuiMarkupListText(text, FT_Subtitle));
|
|
}
|
|
|
|
//Update stats data
|
|
if(fullUpdate) {
|
|
fullUpdate = false;
|
|
for(uint i = 0, cnt = stats.length; i < cnt; ++i)
|
|
stats[i].update();
|
|
}
|
|
else {
|
|
//TODO: Even this probably isn't necessary, make sure
|
|
stats[(nextUpdateIndex++) % stats.length].update();
|
|
}
|
|
|
|
victorPanel.color = winner.color;
|
|
@victor.empire = winner;
|
|
|
|
if(!victorPanel.visible && playerEmpire.valid) {
|
|
locked = false;
|
|
shownVictory = false;
|
|
closeTab(this);
|
|
}
|
|
}
|
|
|
|
bool onKeyEvent(const KeyboardEvent& event, IGuiElement@ source) {
|
|
return BaseGuiElement::onKeyEvent(event, source);
|
|
}
|
|
|
|
bool onGuiEvent(const GuiEvent& event) {
|
|
if(event.type == GUI_Clicked) {
|
|
if(event.caller is rankingsButton) {
|
|
switchPage(0);
|
|
return true;
|
|
}
|
|
else {
|
|
for(uint i = 0, cnt = statButtons.length; i < cnt; ++i) {
|
|
if(event.caller is statButtons[i]) {
|
|
switchPage(i+1);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return BaseGuiElement::onGuiEvent(event);
|
|
}
|
|
|
|
void draw() {
|
|
skin.draw(SS_DesignOverviewBG, SF_Normal, AbsolutePosition);
|
|
BaseGuiElement::draw();
|
|
}
|
|
};
|
|
|
|
class EmpSorter {
|
|
Empire@ emp;
|
|
|
|
int opCmp(const EmpSorter& other) const {
|
|
if(other.emp.Victory != emp.Victory) {
|
|
if(emp.Victory == 1)
|
|
return -1;
|
|
if(emp.Victory == -1)
|
|
return 1;
|
|
if(other.emp.Victory == 1)
|
|
return 1;
|
|
if(other.emp.Victory == -1)
|
|
return -1;
|
|
if(emp.Victory == -2) {
|
|
if(other.emp.Victory == 0)
|
|
return 1;
|
|
if(emp.SubjugatedBy.Victory == 1)
|
|
return -1;
|
|
}
|
|
if(other.emp.Victory == -2) {
|
|
if(emp.Victory == 0)
|
|
return -1;
|
|
if(other.emp.SubjugatedBy.Victory == 1)
|
|
return 1;
|
|
}
|
|
}
|
|
if(emp.points.value > other.emp.points.value)
|
|
return -1;
|
|
if(emp.points.value < other.emp.points.value)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
class StatPage : BaseGuiElement {
|
|
stat::EmpireStat stat;
|
|
StatType type;
|
|
array<StatTracker@> trackers;
|
|
double endTime = 0;
|
|
double minVal = 0;
|
|
double maxVal = 0;
|
|
double baseMin = 0;
|
|
double baseMax = 1;
|
|
bool sqrScale = false;
|
|
|
|
StatPage(IGuiElement@ parent, Alignment@ align, StatType type, stat::EmpireStat Stat, int FilterDuration, const string& name, double baseMax = 1) {
|
|
super(parent, align);
|
|
this.stat = Stat;
|
|
this.type = type;
|
|
this.baseMax = baseMax;
|
|
if(stat == stat::Military) {
|
|
this.sqrScale = true;
|
|
this.baseMin = 2000;
|
|
}
|
|
for(uint i = 0, cnt = getEmpireCount(); i <cnt; ++i) {
|
|
Empire@ emp = getEmpire(i);
|
|
if(emp.major)
|
|
trackers.insertLast(StatTracker(type, Stat, emp.color, FilterDuration, emp, sqrScale));
|
|
}
|
|
|
|
addLazyMarkupTooltip(this, width=300, update=true);
|
|
}
|
|
|
|
double getOffsetTime(int offset) {
|
|
return double(offset-52) / double(size.x-64) * endTime;
|
|
}
|
|
|
|
string formatValue(double amt, bool shortForm = false) {
|
|
if(stat == stat::Budget || stat == stat::NetBudget)
|
|
return formatMoney(int(amt));
|
|
if(stat == stat::EnergyIncome || stat == stat::ResearchIncome)
|
|
return standardize(amt, true)+locale::PER_SECOND;
|
|
if(stat == stat::InfluenceIncome)
|
|
return standardize(amt * 60.0, true)+locale::PER_MIN;
|
|
if(type == ST_Int) {
|
|
if(shortForm && amt >= 1000)
|
|
return standardize(amt, true);
|
|
else
|
|
return toString(floor(amt), 0);
|
|
}
|
|
return standardize(amt, true);
|
|
}
|
|
|
|
string get_tooltip() override {
|
|
int mx = mousePos.x;
|
|
if(mx < AbsolutePosition.topLeft.x+52 || mx > AbsolutePosition.botRight.x-12)
|
|
return "";
|
|
string text;
|
|
double time = getOffsetTime(mx - absolutePosition.topLeft.x);
|
|
text += format("[center][font=Subtitle]$1[/font][/center]", formatGameTime(time));
|
|
for(uint i = 0, cnt = trackers.length; i < cnt; ++i) {
|
|
double amt = trackers[i].getClosest(time).y;
|
|
text += format("[b]$1[offset=150]$2[/offset][/b]\n",
|
|
formatEmpireName(trackers[i].emp),
|
|
formatValue(amt));
|
|
}
|
|
return text;
|
|
}
|
|
|
|
void update() {
|
|
endTime = gameTime;
|
|
minVal = baseMin; maxVal = baseMax;
|
|
for(uint i = 0, cnt = trackers.length; i < cnt; ++i) {
|
|
trackers[i].update();
|
|
minVal = min(minVal, trackers[i].minVal);
|
|
maxVal = max(maxVal, trackers[i].maxVal);
|
|
}
|
|
for(uint i = 0, cnt = trackers.length; i < cnt; ++i) {
|
|
trackers[i].minVal = minVal;
|
|
trackers[i].maxVal = maxVal;
|
|
}
|
|
}
|
|
|
|
void draw() {
|
|
skin.draw(SS_Panel, SF_Normal, AbsolutePosition);
|
|
|
|
const Font@ ft = skin.getFont(FT_Normal);
|
|
|
|
{
|
|
int interval = 100;
|
|
vec2i pos(154, size.height-15);
|
|
while(pos.x < size.x) {
|
|
double time = double(pos.x-52) / double(size.x-64) * endTime;
|
|
ft.draw(pos=recti_centered(pos+AbsolutePosition.topLeft, vec2i(200,30)),
|
|
horizAlign=0.5, text=formatTime(time), color=Color(0xaaaaaaff));
|
|
drawLine(vec2i(pos.x, 12)+AbsolutePosition.topLeft,
|
|
vec2i(pos.x, size.height-40)+AbsolutePosition.topLeft,
|
|
Color(0xaaaaaa20));
|
|
pos.x += interval;
|
|
}
|
|
}
|
|
|
|
{
|
|
int interval = 40;
|
|
vec2i pos(26, size.height-40);
|
|
string prevVal;
|
|
if(type == ST_Int) {
|
|
double mult = ceil(double(size.height-52) / ceil(maxVal-minVal));
|
|
interval = ceil(ceil(double(interval) / mult) * mult);
|
|
}
|
|
while(pos.y > 14) {
|
|
double val = 0;
|
|
if(sqrScale)
|
|
val = minVal + (maxVal - minVal) * sqr(1.0 - (double(pos.y-12) / double(size.y-52)));
|
|
else
|
|
val = minVal + (maxVal - minVal) * (1.0 - (double(pos.y-12) / double(size.y-52)));
|
|
string valDisp = formatValue(val, true);
|
|
if(valDisp != prevVal) {
|
|
ft.draw(pos=recti_centered(pos+AbsolutePosition.topLeft, vec2i(200,30)),
|
|
horizAlign=0.5, text=valDisp, color=Color(0xaaaaaaff));
|
|
prevVal = valDisp;
|
|
}
|
|
drawLine(vec2i(42, pos.y)+AbsolutePosition.topLeft,
|
|
vec2i(size.width-12, pos.y)+AbsolutePosition.topLeft,
|
|
Color(0xaaaaaa20));
|
|
pos.y -= interval;
|
|
}
|
|
|
|
if(minVal < 0 && maxVal > 0 && !sqrScale) {
|
|
int y = size.height-40 - size.y * (-minVal) / (maxVal - minVal);
|
|
drawLine(vec2i(42, y)+AbsolutePosition.topLeft,
|
|
vec2i(size.width-12, y)+AbsolutePosition.topLeft,
|
|
Color(0xaa000040), size=3);
|
|
}
|
|
}
|
|
|
|
for(uint i = 0, cnt = trackers.length; i < cnt; ++i)
|
|
trackers[i].draw(skin, AbsolutePosition.padded(42,12,12,40));
|
|
|
|
if(AbsolutePosition.isWithin(mousePos)) {
|
|
int mx = mousePos.x;
|
|
if(mx >= AbsolutePosition.topLeft.x+52 && mx <= AbsolutePosition.botRight.x-12) {
|
|
drawLine(vec2i(mx, AbsolutePosition.topLeft.y+12),
|
|
vec2i(mx, AbsolutePosition.botRight.y-40),
|
|
Color(0xaaaaaaff));
|
|
}
|
|
}
|
|
|
|
BaseGuiElement::draw();
|
|
}
|
|
};
|
|
|
|
enum StatType {
|
|
ST_Int,
|
|
ST_Float,
|
|
}
|
|
|
|
final class StatTracker {
|
|
double minVal = 0, maxVal = 1;
|
|
stat::EmpireStat stat;
|
|
Color color;
|
|
int filterDuration = 1;
|
|
array<vec2d> data;
|
|
Empire@ emp;
|
|
StatType type;
|
|
double endTime;
|
|
bool sqrScale = false;
|
|
|
|
array<vec2i> points;
|
|
vec2i lastSize;
|
|
|
|
StatTracker(StatType type, stat::EmpireStat Stat, const Color& col, int FilterDuration, Empire@ emp = playerEmpire, bool sqrScale = false) {
|
|
stat = Stat;
|
|
color = col;
|
|
filterDuration = FilterDuration;
|
|
this.type = type;
|
|
@this.emp = emp;
|
|
this.sqrScale = sqrScale;
|
|
}
|
|
|
|
vec2d getClosest(double time) {
|
|
vec2d closest(0, 0);
|
|
double dist = INFINITY;
|
|
//Don't make me do a binary search you monster
|
|
for(uint i = 0, cnt = data.length; i < cnt; ++i) {
|
|
double d = abs(data[i].x - time);
|
|
if(d < dist) {
|
|
dist = d;
|
|
closest = data[i];
|
|
}
|
|
}
|
|
return closest;
|
|
}
|
|
|
|
void rebuildPoints(vec2i size) {
|
|
array<vec3d> pts(1);
|
|
|
|
vec2d factor(double(size.x) / endTime, -double(size.y) / (maxVal - minVal));
|
|
vec2d offset(0.0, -minVal);
|
|
|
|
uint lastX = 0;
|
|
for(uint i = 0, cnt = data.length; i < cnt; ++i) {
|
|
vec2d pt = data[i] + offset;
|
|
pt.x *= factor.x;
|
|
|
|
if(!sqrScale) {
|
|
pt.y *= factor.y;
|
|
}
|
|
else {
|
|
if(pt.y != 0)
|
|
pt.y = -double(size.y) * sqrt(pt.y / (maxVal - minVal));
|
|
}
|
|
|
|
uint x = int(pt.x);
|
|
if(i == 0 && x != 0)
|
|
pts[0] = vec3d(0.0, pt.y, 1.0);
|
|
|
|
if(x != lastX)
|
|
pts.resize(pts.length + 1);
|
|
pts[pts.length-1] += vec3d(pt.x, pt.y, 1.0);
|
|
}
|
|
|
|
int maxTimeDelta = max(int(ceil(double(size.x * filterDuration) / endTime)), int(1));
|
|
|
|
points.length = 0;
|
|
points.reserve(pts.length + 1);
|
|
for(uint i = 0, cnt = pts.length; i < cnt; ++i) {
|
|
vec3d pt = pts[i];
|
|
vec2i px = vec2i(pt.x / pt.z, pt.y / pt.z + 0.5);
|
|
if(i > 0) {
|
|
vec2i prev = points.last;
|
|
if(prev.x < px.x - maxTimeDelta)
|
|
points.insertLast(vec2i(px.x - 1, prev.y));
|
|
}
|
|
points.insertLast(px);
|
|
}
|
|
|
|
if(points.last.x < size.x - 1)
|
|
points.insertLast(vec2i(size.x - 1, points.last.y));
|
|
|
|
lastSize = size;
|
|
}
|
|
|
|
void update() {
|
|
minVal = INFINITY;
|
|
maxVal = -INFINITY;
|
|
data.length = 0;
|
|
|
|
StatHistory history(emp, stat);
|
|
endTime = gameTime;
|
|
|
|
while(history.advance(1)) {
|
|
double val = 0;
|
|
if(type == ST_Int)
|
|
val = history.intVal;
|
|
else
|
|
val = history.floatVal;
|
|
|
|
if(val > maxVal)
|
|
maxVal = val;
|
|
if(val < minVal)
|
|
minVal = val;
|
|
|
|
data.insertLast(vec2d(history.time, val));
|
|
}
|
|
|
|
lastSize = vec2i();
|
|
}
|
|
|
|
void draw(const Skin@ skin, recti bound) {
|
|
vec2i size = bound.size;
|
|
if(size != lastSize)
|
|
rebuildPoints(size);
|
|
|
|
if(points.length == 0) {
|
|
drawLine(bound.topLeft + vec2i(0, bound.height), bound.botRight, color);
|
|
return;
|
|
}
|
|
|
|
vec2i corner = bound.topLeft + vec2i(0,size.y);
|
|
vec2i prev = points[0] + corner;
|
|
|
|
uint lines = points.length - 1;
|
|
uint index = 0;
|
|
while(index < lines) {
|
|
drawPolygonStart(PT_LineStrip, min(lines - index, 250));
|
|
drawPolygonPoint(prev, color);
|
|
for(uint i = 0; i < 250 && index + i < lines; ++i) {
|
|
vec2i pt = points[index + i + 1] + corner;
|
|
drawPolygonPoint(pt);
|
|
prev = pt;
|
|
}
|
|
drawPolygonEnd();
|
|
index += 250;
|
|
}
|
|
}
|
|
};
|
|
|
|
Tab@ createVictoryTab() {
|
|
return VictoryTab();
|
|
}
|
|
|
|
void init() {
|
|
/*auto@ tab = createVictoryTab();*/
|
|
/*newTab(tab);*/
|
|
/*switchToTab(tab);*/
|
|
}
|
|
|
|
bool shownVictory = false;
|
|
void tick(double time) {
|
|
if(!shownVictory && (hasGameEnded() || (wantSpectator && !playerEmpire.valid))) {
|
|
auto@ tab = createVictoryTab();
|
|
newTab(tab);
|
|
if(hasGameEnded())
|
|
switchToTab(tab);
|
|
shownVictory = true;
|
|
}
|
|
}
|