Lucas de Vries
1140 lines
29 KiB
ActionScript
1140 lines
29 KiB
ActionScript
#section disable menu
|
|
import elements.BaseGuiElement;
|
|
import elements.GuiPanel;
|
|
import elements.GuiText;
|
|
import elements.GuiTextbox;
|
|
import elements.GuiSprite;
|
|
import elements.GuiOverlay;
|
|
import elements.GuiDropdown;
|
|
import elements.GuiSkinElement;
|
|
import elements.GuiButton;
|
|
import elements.GuiMarkupText;
|
|
import elements.GuiEmpire;
|
|
import elements.MarkupTooltip;
|
|
import elements.GuiBackgroundPanel;
|
|
import influence;
|
|
import icons;
|
|
import hooks;
|
|
import util.formatting;
|
|
from gui import animate_time, navigateInto;
|
|
|
|
#section game
|
|
import tabs.Tab;
|
|
import targeting.ObjectTarget;
|
|
#section all
|
|
|
|
export GuiInfluenceCard;
|
|
export updateCardList;
|
|
export GuiInfluenceCardPopup;
|
|
export GUI_CARD_WIDTH, GUI_CARD_HEIGHT;
|
|
export drawCardIcon;
|
|
|
|
const int GUI_CARD_WIDTH = 207;
|
|
const int GUI_CARD_HEIGHT = 137;
|
|
|
|
const vec2i CARD_ART_OFFSET(2, 32);
|
|
const vec2i CARD_ART_SIZE(201,99);
|
|
|
|
class GuiInfluenceCard : BaseGuiElement {
|
|
InfluenceCard@ card;
|
|
bool Hovered = false;
|
|
bool Focused = false;
|
|
bool Pressed = false;
|
|
bool disabled = false;
|
|
Color disabledColor;
|
|
|
|
Color cardColor = colors::White;
|
|
GuiMarkupText@ title;
|
|
|
|
GuiSprite@ qualityIcon;
|
|
GuiSprite@ typeIcon;
|
|
|
|
GuiSprite@ leaderIcon;
|
|
|
|
GuiEmpire@ empireIcon;
|
|
GuiSprite@ purchaseIcon;
|
|
GuiText@ purchaseCost;
|
|
|
|
array<GuiSprite@> varIcons;
|
|
array<GuiText@> varTexts;
|
|
|
|
GuiInfluenceCard(IGuiElement@ ParentElement) {
|
|
super(ParentElement, recti(0, 0, GUI_CARD_WIDTH, GUI_CARD_HEIGHT));
|
|
updateAbsolutePosition();
|
|
|
|
@title = GuiMarkupText(this, recti(10, 5, GUI_CARD_WIDTH - 10, 30));
|
|
|
|
@leaderIcon = GuiSprite(this, recti_area(8, 34, 34, 34));
|
|
leaderIcon.desc = Sprite(material::LeaderIcon);
|
|
setMarkupTooltip(leaderIcon, locale::TT_LEADER_CARD, false);
|
|
leaderIcon.visible = false;
|
|
|
|
@purchaseIcon = GuiSprite(this, recti_area(GUI_CARD_WIDTH - 50, GUI_CARD_HEIGHT - 50, 44, 44));
|
|
purchaseIcon.desc = icons::InfluencePurchaseCost;
|
|
@purchaseCost = GuiText(this, recti_area(GUI_CARD_WIDTH - 120, GUI_CARD_HEIGHT - 45, 70, 44));
|
|
purchaseCost.vertAlign = 0.5;
|
|
purchaseCost.horizAlign = 1.0;
|
|
purchaseCost.font = FT_Big;
|
|
purchaseCost.stroke = colors::Black;
|
|
|
|
@typeIcon = GuiSprite(this, recti_area(GUI_CARD_WIDTH - 42, 34, 34, 34));
|
|
|
|
@qualityIcon = GuiSprite(this, recti_area(GUI_CARD_WIDTH - 72, 6, 64, 22));
|
|
qualityIcon.color = Color(0xffffff40);
|
|
setMarkupTooltip(qualityIcon, locale::INFLUENCE_TT_QUALITY, false);
|
|
|
|
navigable = true;
|
|
}
|
|
|
|
void set(InfluenceCard@ c, InfluenceVote@ vote = null, bool showVariables = true, bool centerTitle = false) {
|
|
@card = c;
|
|
|
|
//Title on top
|
|
string ttext = card.formatTitle();
|
|
if(showVariables) {
|
|
if(card.uses < 0)
|
|
ttext += " ("+locale::USES_UNLIMITED+")";
|
|
else if(card.uses > 1)
|
|
ttext += " ("+card.uses+"x)";
|
|
}
|
|
|
|
if(ttext.length > 20) {
|
|
title.defaultFont = FT_Small;
|
|
title.position = vec2i(6, 6);
|
|
}
|
|
else {
|
|
title.defaultFont = FT_Normal;
|
|
title.position = vec2i(10, 4);
|
|
}
|
|
if(centerTitle)
|
|
ttext = "[center]"+ttext+"[/center]";
|
|
title.text = ttext;
|
|
title.updateAbsolutePosition();
|
|
|
|
typeIcon.desc = getInfluenceCardClassSprite(card.type.cls);
|
|
leaderIcon.visible = card.type.leaderOnly;
|
|
setMarkupTooltip(typeIcon, getInfluenceCardClassTooltip(card.type.cls), false);
|
|
|
|
//Purchase cost
|
|
auto@ stackCard = cast<StackInfluenceCard>(c);
|
|
disabled = false;
|
|
if(stackCard !is null) {
|
|
if(stackCard.purchasedBy !is null) {
|
|
if(empireIcon is null) {
|
|
@empireIcon = GuiEmpire(this, Alignment(Right-60, Bottom-60, Width=55, Height=55));
|
|
empireIcon.padding = 4;
|
|
empireIcon.background = SS_EmpireBox;
|
|
}
|
|
|
|
if(playerEmpire.valid && playerEmpire.ContactMask & stackCard.purchasedBy.mask != 0) {
|
|
empireIcon.visible = true;
|
|
@empireIcon.empire = stackCard.purchasedBy;
|
|
setMarkupTooltip(empireIcon, format(locale::INFLUENCE_TT_BOUGHTBY,
|
|
formatEmpireName(stackCard.purchasedBy)), false);
|
|
}
|
|
else {
|
|
empireIcon.visible = false;
|
|
}
|
|
|
|
purchaseIcon.visible = false;
|
|
purchaseCost.visible = false;
|
|
disabled = true;
|
|
disabledColor = stackCard.purchasedBy.color;
|
|
}
|
|
else {
|
|
int cost = card.getPurchaseCost(playerEmpire);
|
|
bool canPurchase = card.canPurchase(playerEmpire);
|
|
|
|
purchaseIcon.visible = canPurchase;
|
|
purchaseCost.visible = canPurchase;
|
|
purchaseCost.text = toString(cost);
|
|
purchaseCost.font = FT_Big;
|
|
|
|
if(canPurchase) {
|
|
string tt = format(locale::INFLUENCE_TT_BUY_COST, toString(cost));
|
|
setMarkupTooltip(purchaseIcon, tt, false);
|
|
setMarkupTooltip(purchaseCost, tt, false);
|
|
}
|
|
|
|
if(empireIcon !is null)
|
|
empireIcon.visible = false;
|
|
}
|
|
}
|
|
else {
|
|
purchaseIcon.visible = false;
|
|
purchaseCost.visible = false;
|
|
|
|
if(empireIcon !is null)
|
|
empireIcon.visible = false;
|
|
}
|
|
|
|
//Rarity
|
|
cardColor = getInfluenceCardRarityColor(c.type.rarity);
|
|
|
|
//Quality
|
|
if(c.quality > c.type.minQuality) {
|
|
int qlev = c.quality - c.type.minQuality;
|
|
|
|
int qdist = c.type.maxQuality - c.type.minQuality + 1;
|
|
if(qdist > 4)
|
|
qlev = floor(double(qlev) / double(qdist) * 4) + 1;
|
|
|
|
if(qlev > 0) {
|
|
qualityIcon.desc = Sprite(spritesheet::PlanetLevelIcons, qlev-1);
|
|
qualityIcon.visible = true;
|
|
}
|
|
else {
|
|
qualityIcon.visible = false;
|
|
}
|
|
}
|
|
else {
|
|
qualityIcon.visible = false;
|
|
}
|
|
|
|
//Variables
|
|
uint index = 0;
|
|
Sprite sprt;
|
|
string name, text, tooltip;
|
|
bool highlight = false;
|
|
if(showVariables) {
|
|
if(card.getCostVariable(sprt, name, tooltip, text, highlight, vote = vote))
|
|
addVar(index, IVM_Property, sprt, name, tooltip,text, highlight);
|
|
if(card.getWeightVariable(sprt, name, tooltip, text, highlight, vote = vote))
|
|
addVar(index, IVM_Property, sprt, name, tooltip,text, highlight);
|
|
for(uint i = 0, cnt = card.type.hooks.length; i < cnt; ++i) {
|
|
uint mode = card.type.hooks[i].getVariable(card, vote, sprt, name, tooltip, text, highlight);
|
|
if(mode != IVM_None)
|
|
addVar(index, mode, sprt, name, tooltip, text, highlight);
|
|
}
|
|
}
|
|
for(uint i = index, cnt = varIcons.length; i < cnt; ++i) {
|
|
varIcons[i].remove();
|
|
varTexts[i].remove();
|
|
}
|
|
varIcons.length = index;
|
|
varTexts.length = index;
|
|
}
|
|
|
|
void addVar(uint& index, uint mode, const Sprite& sprt, const string& name, const string& tooltip, const string& text, bool highlight) {
|
|
if(mode == IVM_PurchaseCost) {
|
|
if(purchaseIcon !is null) {
|
|
purchaseIcon.desc = sprt;
|
|
purchaseCost.text = text;
|
|
if(purchaseCost.getTextDimension().x >= purchaseCost.size.width)
|
|
purchaseCost.font = FT_Medium;
|
|
else
|
|
purchaseCost.font = FT_Big;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if(varIcons.length <= index) {
|
|
varIcons.resize(index+1);
|
|
varTexts.resize(index+1);
|
|
}
|
|
|
|
auto@ icon = varIcons[index];
|
|
if(icon is null) {
|
|
@icon = GuiSprite(this, recti_area(vec2i(8, GUI_CARD_HEIGHT - 30 - 26*index), vec2i(24, 24)));
|
|
@varIcons[index] = icon;
|
|
}
|
|
|
|
setMarkupTooltip(icon, tooltip, false);
|
|
icon.desc = sprt;
|
|
|
|
auto@ txt = varTexts[index];
|
|
if(txt is null) {
|
|
@txt = GuiText(this, recti_area(vec2i(38, GUI_CARD_HEIGHT - 29 - 26*index), vec2i(40, 24)));
|
|
txt.stroke = colors::Black;
|
|
@varTexts[index] = txt;
|
|
}
|
|
|
|
setMarkupTooltip(txt, tooltip, false);
|
|
txt.text = text;
|
|
|
|
if(highlight) {
|
|
txt.font = FT_Bold;
|
|
txt.color = Color(0xffcd00ff);
|
|
}
|
|
else {
|
|
txt.font = FT_Normal;
|
|
txt.color = colors::White;
|
|
}
|
|
|
|
index += 1;
|
|
}
|
|
|
|
bool onGuiEvent(const GuiEvent& event) {
|
|
if(event.caller is this) {
|
|
switch(event.type) {
|
|
case GUI_Mouse_Entered:
|
|
Hovered = true;
|
|
break;
|
|
case GUI_Mouse_Left:
|
|
Hovered = false;
|
|
break;
|
|
case GUI_Focused:
|
|
Focused = true;
|
|
break;
|
|
case GUI_Focus_Lost:
|
|
Focused = false;
|
|
break;
|
|
case GUI_Controller_Down:
|
|
if(event.caller is this) {
|
|
if(event.value == GP_A) {
|
|
Pressed = true;
|
|
return true;
|
|
}
|
|
}
|
|
break;
|
|
case GUI_Controller_Up:
|
|
if(Focused) {
|
|
if(event.value == GP_A) {
|
|
Pressed = false;
|
|
emitClicked();
|
|
return true;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return BaseGuiElement::onGuiEvent(event);
|
|
}
|
|
|
|
bool onMouseEvent(const MouseEvent& event, IGuiElement@ source) {
|
|
switch(event.type) {
|
|
case MET_Button_Down:
|
|
if(event.button == 0) {
|
|
Pressed = true;
|
|
return true;
|
|
}
|
|
break;
|
|
case MET_Button_Up:
|
|
if(event.button == 0) {
|
|
if(Pressed) {
|
|
Pressed = false;
|
|
emitClicked();
|
|
}
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
return BaseGuiElement::onMouseEvent(event, source);
|
|
}
|
|
|
|
void updateAbsolutePosition() {
|
|
BaseGuiElement::updateAbsolutePosition();
|
|
}
|
|
|
|
uint get_flags() {
|
|
uint flags = SF_Normal;
|
|
if(disabled)
|
|
flags |= SF_Disabled;
|
|
if(Pressed)
|
|
flags |= SF_Active;
|
|
if(Hovered)
|
|
flags |= SF_Hovered;
|
|
if(Focused)
|
|
flags |= SF_Focused;
|
|
return flags;
|
|
}
|
|
|
|
void draw() {
|
|
if(card is null)
|
|
return;
|
|
|
|
uint index = 0;
|
|
if(Hovered)
|
|
index = 2;
|
|
else if(Pressed || Focused)
|
|
index = 1;
|
|
|
|
if(card.uses > 1)
|
|
spritesheet::ActionCard.draw(index, AbsolutePosition+vec2i(3,3), cardColor);
|
|
recti ipos = recti_area(AbsolutePosition.topLeft+CARD_ART_OFFSET, CARD_ART_SIZE);
|
|
drawRectangle(ipos, Color(0x202020ff));
|
|
if(card.type.icon.valid)
|
|
card.type.icon.draw(ipos.aspectAligned(card.type.icon.aspect));
|
|
spritesheet::ActionCard.draw(index, AbsolutePosition, cardColor);
|
|
if(disabled)
|
|
spritesheet::ActionCard.draw(4, AbsolutePosition, disabledColor);
|
|
skin.draw(SS_FullTitle, SF_Normal, recti_area(
|
|
AbsolutePosition.topLeft + vec2i(2, 2),
|
|
vec2i(GUI_CARD_WIDTH - 6, 30)), card.type.color);
|
|
BaseGuiElement::draw();
|
|
}
|
|
};
|
|
|
|
int updateCardList(IGuiElement@ panel, array<InfluenceCard@> cards, GuiInfluenceCard@[]@ boxes, double horizAlign = 0.0, InfluenceVote@ vote = null, bool filterPlayable = true) {
|
|
uint oldCnt = boxes.length;
|
|
uint newCnt = cards.length;
|
|
|
|
//Remove old boxes
|
|
for(uint i = newCnt; i < oldCnt; ++i) {
|
|
if(boxes[i] !is null)
|
|
boxes[i].remove();
|
|
}
|
|
boxes.length = newCnt;
|
|
|
|
//Do alignment
|
|
vec2i pos(4, 4);
|
|
if(horizAlign != 0.0) {
|
|
int perRow = floor(double(panel.size.width) / double(GUI_CARD_WIDTH + 4));
|
|
int rowWidth = min(perRow, newCnt) * (GUI_CARD_WIDTH + 4);
|
|
pos.x = (panel.size.width - rowWidth) / 2;
|
|
}
|
|
|
|
//Update boxes
|
|
uint n = 0;
|
|
for(uint i = 0; i < newCnt; ++i) {
|
|
//Figure out if the card is usable
|
|
if(vote !is null) {
|
|
if(filterPlayable) {
|
|
if(!cards[i].canPlay(vote, null))
|
|
continue;
|
|
}
|
|
else {
|
|
if(cards[i].type.cls != ICC_Support)
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//Create box if needed
|
|
if(boxes[n] is null)
|
|
@boxes[n] = GuiInfluenceCard(panel);
|
|
|
|
//Update the card box
|
|
GuiInfluenceCard@ box = boxes[n];
|
|
box.set(cards[i], vote);
|
|
|
|
//Position the card
|
|
box.position = pos;
|
|
|
|
pos.x += GUI_CARD_WIDTH + 4;
|
|
if(pos.x + GUI_CARD_WIDTH > panel.size.width - 20) {
|
|
pos.x = 4;
|
|
pos.y += GUI_CARD_HEIGHT + 4;
|
|
}
|
|
++n;
|
|
}
|
|
|
|
for(uint i = n; i < newCnt; ++i) {
|
|
if(boxes[i] !is null) {
|
|
boxes[i].remove();
|
|
@boxes[i] = null;
|
|
}
|
|
}
|
|
|
|
if(pos.x == 4)
|
|
return pos.y;
|
|
else
|
|
return pos.y + GUI_CARD_HEIGHT + 4;
|
|
}
|
|
|
|
final class TargetingOption {
|
|
uint target = uint(-1);
|
|
GuiDropdown@ dropdown;
|
|
GuiTextbox@ textbox;
|
|
array<Target@> potentials;
|
|
Target defaultTarget;
|
|
|
|
TargetingOption(uint index) {
|
|
target = index;
|
|
}
|
|
|
|
void create(IGuiElement@ elem, int y, Target@ target) {
|
|
Alignment align(Left+CARD_ART_SIZE.x+30, Bottom-y, Right-30, Bottom-y+34);
|
|
if(target.type == TT_String)
|
|
@textbox = GuiTextbox(elem, align, target.str);
|
|
else
|
|
@dropdown = GuiDropdown(elem, align);
|
|
defaultTarget = target;
|
|
}
|
|
|
|
void add(InfluenceCard@ card, Target@ targ, const string& name) {
|
|
if(!card.isValidTarget(target, targ))
|
|
return;
|
|
if(dropdown is null)
|
|
return;
|
|
|
|
dropdown.addItem(GuiMarkupListText(name));
|
|
potentials.insertLast(targ);
|
|
|
|
if(targ == defaultTarget)
|
|
dropdown.selected = potentials.length - 1;
|
|
}
|
|
|
|
void fill(Targets@ targets) {
|
|
if(target >= targets.targets.length)
|
|
return;
|
|
|
|
if(dropdown !is null) {
|
|
uint sel = uint(dropdown.selected);
|
|
if(sel >= potentials.length) {
|
|
targets[target].filled = false;
|
|
return;
|
|
}
|
|
|
|
targets[target].filled = true;
|
|
targets[target] = potentials[sel];
|
|
}
|
|
else if(textbox !is null) {
|
|
targets[target].filled = true;
|
|
targets[target].str = textbox.text;
|
|
}
|
|
}
|
|
};
|
|
|
|
class GuiInfluenceCardPopup : BaseGuiElement {
|
|
GuiOverlay@ overlay;
|
|
IGuiElement@ around;
|
|
int cardId = -1;
|
|
int cost = 0;
|
|
bool animating = false;
|
|
|
|
int awaitsObjectTarget = -1;
|
|
|
|
InfluenceVote@ vote;
|
|
InfluenceCard@ card;
|
|
Targets targets;
|
|
|
|
GuiBackgroundPanel@ panel;
|
|
GuiSprite@ qualityIcon;
|
|
GuiSprite@ image;
|
|
GuiMarkupText@ description;
|
|
|
|
array<TargetingOption@> options;
|
|
array<Empire@> targetEmpireList;
|
|
|
|
GuiButton@ supportButton;
|
|
GuiButton@ opposeButton;
|
|
|
|
bool haveButtons = false;
|
|
|
|
GuiButton@ purchaseButton;
|
|
GuiSprite@ purchaseIcon;
|
|
GuiText@ purchaseCost;
|
|
|
|
GuiButton@ playButton;
|
|
|
|
array<GuiSprite@> varIcons;
|
|
array<GuiText@> varNames;
|
|
array<GuiText@> varTexts;
|
|
|
|
GuiInfluenceCardPopup(IGuiElement@ Parent, IGuiElement@ Around, InfluenceCard@ card, bool animate = true, InfluenceVote@ vote = null, bool playable = true) {
|
|
@around = Around;
|
|
@overlay = GuiOverlay(Parent);
|
|
overlay.closeSelf = false;
|
|
super(overlay, recti(0, 0, 600, 400));
|
|
@this.card = card;
|
|
@this.vote = vote;
|
|
cardId = card.id;
|
|
|
|
targets = card.targets;
|
|
card.targetDefaults(targets);
|
|
|
|
@panel = GuiBackgroundPanel(this, Alignment_Fill());
|
|
panel.titleStyle = SS_FullTitle;
|
|
panel.markup = true;
|
|
panel.titleColor = card.type.color;
|
|
|
|
string ttext = card.formatTitle();
|
|
if(card.uses < 0)
|
|
ttext += " ("+locale::USES_UNLIMITED+")";
|
|
else if(card.uses > 1)
|
|
ttext += " ("+card.uses+"x)";
|
|
panel.title = ttext;
|
|
|
|
//Quality
|
|
@qualityIcon = GuiSprite(panel, Alignment(Right-72, Top+6, Width=64, Height=22));
|
|
qualityIcon.color = Color(0xffffff40);
|
|
setMarkupTooltip(qualityIcon, locale::INFLUENCE_TT_QUALITY, false);
|
|
|
|
if(card.quality > card.type.minQuality) {
|
|
int qlev = card.quality - card.type.minQuality;
|
|
|
|
int qdist = card.type.maxQuality - card.type.minQuality + 1;
|
|
if(qdist > 4)
|
|
qlev = floor(double(qlev) / double(qdist) * 4) + 1;
|
|
|
|
if(qlev > 0) {
|
|
qualityIcon.desc = Sprite(spritesheet::PlanetLevelIcons, qlev-1);
|
|
qualityIcon.visible = true;
|
|
}
|
|
else {
|
|
qualityIcon.visible = false;
|
|
}
|
|
}
|
|
else {
|
|
qualityIcon.visible = false;
|
|
}
|
|
|
|
@image = GuiSprite(this, recti_area(vec2i(16, 36), CARD_ART_SIZE));
|
|
image.desc = card.type.icon;
|
|
|
|
@description = GuiMarkupText(this, recti(26+CARD_ART_SIZE.x, 36, size.width-16, CARD_ART_SIZE.y+96));
|
|
description.text = card.formatDescription();
|
|
|
|
int btnWidth = (size.width - CARD_ART_SIZE.x - 42);
|
|
int btnStart = CARD_ART_SIZE.x + 30;
|
|
if(cast<StackInfluenceCard>(card) !is null) {
|
|
bool canPurchase = card.canPurchase(playerEmpire);
|
|
|
|
if(canPurchase) {
|
|
@purchaseIcon = GuiSprite(this, Alignment(Right-50, Bottom-50, Width=44, Height=44));
|
|
purchaseIcon.desc = icons::InfluencePurchaseCost;
|
|
|
|
@purchaseCost = GuiText(this, Alignment(Right-120, Bottom-45, Width=70, Height=44));
|
|
purchaseCost.vertAlign = 0.5;
|
|
purchaseCost.horizAlign = 1.0;
|
|
purchaseCost.font = FT_Big;
|
|
|
|
cost = card.getPurchaseCost(playerEmpire);
|
|
purchaseCost.text = toString(cost);
|
|
|
|
@purchaseButton = GuiButton(this, Alignment(
|
|
Left+((btnWidth-160)/2+btnStart), Bottom-44,
|
|
Width=160, Height=34), locale::PURCHASE_CARD);
|
|
purchaseButton.color = Color(0x20adffff);
|
|
purchaseButton.disabled = !card.hasPurchaseCost(playerEmpire);
|
|
haveButtons = true;
|
|
}
|
|
}
|
|
else if(playable) {
|
|
if(card.type.cls == ICC_Support) {
|
|
if(vote !is null) {
|
|
if(card.type.sideMode == ICS_Neutral) {
|
|
@playButton = GuiButton(this, Alignment(
|
|
Left+((btnWidth-160)/2+btnStart), Bottom-44,
|
|
Width=160, Height=34), locale::PLAY_NEUTRAL);
|
|
playButton.color = Color(0xffad20ff);
|
|
haveButtons = true;
|
|
}
|
|
else if(card.type.sideMode == ICS_Both) {
|
|
@supportButton = GuiButton(this, Alignment(
|
|
Left+((btnWidth-160)/2+btnStart)-84, Bottom-44,
|
|
Width=160, Height=34), locale::PLAY_SUPPORT);
|
|
supportButton.color = Color(0xddffdbff);
|
|
haveButtons = true;
|
|
|
|
@opposeButton = GuiButton(this, Alignment(
|
|
Left+((btnWidth-160)/2+btnStart)+84, Bottom-44,
|
|
Width=160, Height=34), locale::PLAY_OPPOSE);
|
|
opposeButton.color = Color(0xffe3dbff);
|
|
haveButtons = true;
|
|
}
|
|
else if(card.type.sideMode == ICS_Support) {
|
|
@supportButton = GuiButton(this, Alignment(
|
|
Left+((btnWidth-160)/2+btnStart), Bottom-44,
|
|
Width=160, Height=34), locale::PLAY_SUPPORT);
|
|
supportButton.color = Color(0xddffdbff);
|
|
haveButtons = true;
|
|
}
|
|
else if(card.type.sideMode == ICS_Oppose) {
|
|
@opposeButton = GuiButton(this, Alignment(
|
|
Left+((btnWidth-160)/2+btnStart), Bottom-44,
|
|
Width=160, Height=34), locale::PLAY_OPPOSE);
|
|
opposeButton.color = Color(0xffe3dbff);
|
|
haveButtons = true;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
@playButton = GuiButton(this, Alignment(
|
|
Left+((btnWidth-160)/2+btnStart), Bottom-44,
|
|
Width=160, Height=34), locale::PLAY_CARD);
|
|
playButton.color = Color(0xffad20ff);
|
|
haveButtons = true;
|
|
}
|
|
|
|
if(haveButtons) {
|
|
uint targCnt = targets.targets.length;
|
|
int y = 82;
|
|
for(uint i = 0; i < targCnt; ++i) {
|
|
auto@ targ = targets.targets[i];
|
|
if(card.targets[i].filled)
|
|
continue;
|
|
if(targ.type == TT_Empire) {
|
|
TargetingOption opt(i);
|
|
opt.create(this, y, targ);
|
|
options.insertLast(opt);
|
|
|
|
for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
|
|
Empire@ emp = getEmpire(i);
|
|
if(!emp.major)
|
|
continue;
|
|
if(playerEmpire.ContactMask & emp.mask == 0)
|
|
continue;
|
|
|
|
Target targ(TT_Empire);
|
|
targ.filled = true;
|
|
@targ.emp = emp;
|
|
|
|
opt.add(card, targ, formatEmpireName(emp));
|
|
}
|
|
|
|
y += 40;
|
|
}
|
|
else if(targ.type == TT_Card) {
|
|
array<InfluenceCard> cards;
|
|
cards.syncFrom(playerEmpire.getInfluenceCards());
|
|
|
|
TargetingOption opt(i);
|
|
opt.create(this, y, targ);
|
|
options.insertLast(opt);
|
|
|
|
for(uint i = 0, cnt = cards.length; i < cnt; ++i) {
|
|
auto@ c = cards[i];
|
|
|
|
Target targ(TT_Card);
|
|
targ.filled = true;
|
|
targ.id = c.id;
|
|
|
|
opt.add(card, targ, c.formatBlurb());
|
|
}
|
|
|
|
y += 40;
|
|
}
|
|
else if(targ.type == TT_Effect) {
|
|
array<InfluenceEffect> effects;
|
|
effects.syncFrom(getActiveInfluenceEffects());
|
|
|
|
TargetingOption opt(i);
|
|
opt.create(this, y, targ);
|
|
options.insertLast(opt);
|
|
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
auto@ eff = effects[i];
|
|
if(eff.owner !is null && playerEmpire.valid && playerEmpire.ContactMask & eff.owner.mask == 0)
|
|
continue;
|
|
|
|
Target targ(TT_Effect);
|
|
targ.filled = true;
|
|
targ.id = eff.id;
|
|
|
|
string title = eff.formatTitle();
|
|
title = format("$3: [color=$2]$1[/color]", title, toString(eff.type.color), formatEmpireName(eff.owner));
|
|
|
|
opt.add(card, targ, title);
|
|
}
|
|
|
|
y += 40;
|
|
}
|
|
else if(targ.type == TT_String) {
|
|
TargetingOption opt(i);
|
|
opt.create(this, y, targ);
|
|
options.insertLast(opt);
|
|
|
|
y += 40;
|
|
}
|
|
else if(targ.type == TT_Object) {
|
|
awaitsObjectTarget = int(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Add variables
|
|
uint index = 0;
|
|
Sprite sprt;
|
|
string name, text, tooltip;
|
|
bool highlight = false;
|
|
if(card.getCostVariable(sprt, name, tooltip, text, highlight, vote=vote))
|
|
addVar(index, IVM_Property, sprt, name, tooltip, text, highlight);
|
|
if(card.getWeightVariable(sprt, name, tooltip, text, highlight, vote=vote))
|
|
addVar(index, IVM_Property, sprt, name, tooltip, text, highlight);
|
|
for(uint i = 0, cnt = card.type.hooks.length; i < cnt; ++i) {
|
|
uint mode = card.type.hooks[i].getVariable(card, vote, sprt, name, tooltip, text, highlight);
|
|
if(mode != IVM_None)
|
|
addVar(index, mode, sprt, name, tooltip, text, highlight);
|
|
}
|
|
|
|
for(uint i = index, cnt = varIcons.length; i < cnt; ++i) {
|
|
varIcons[i].remove();
|
|
varTexts[i].remove();
|
|
}
|
|
varIcons.length = index;
|
|
varTexts.length = index;
|
|
|
|
updateAbsolutePosition();
|
|
if(animate) {
|
|
recti target = targetPosition;
|
|
rect = around.absolutePosition - Parent.absolutePosition.topLeft;
|
|
animating = true;
|
|
animate_time(this, target, 0.2);
|
|
}
|
|
|
|
navigateInto(this);
|
|
onChange();
|
|
}
|
|
|
|
void onChange() {
|
|
bool playable = true;
|
|
for(uint i = 0, cnt = options.length; i < cnt; ++i) {
|
|
options[i].fill(targets);
|
|
if(!card.isValidTarget(options[i].target, targets.targets[options[i].target]))
|
|
playable = false;
|
|
}
|
|
|
|
if(awaitsObjectTarget == -1 && playable) {
|
|
if(vote !is null)
|
|
playable = card.canPlay(vote, targets);
|
|
else
|
|
playable = card.canPlay(targets);
|
|
}
|
|
|
|
if(card.type.sideMode != ICS_Neutral) {
|
|
auto@ targ = targets.fill("VoteSide");
|
|
if(targ !is null) {
|
|
if(supportButton !is null) {
|
|
targ.side = true;
|
|
supportButton.disabled = !card.canPlay(vote, targets)
|
|
|| playerEmpire.Influence < card.getPlayCost(vote, targets);
|
|
}
|
|
if(opposeButton !is null) {
|
|
targ.side = false;
|
|
opposeButton.disabled = !card.canPlay(vote, targets)
|
|
|| playerEmpire.Influence < card.getPlayCost(vote, targets);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(playButton !is null) {
|
|
if(vote !is null) {
|
|
playButton.disabled = !playable
|
|
|| playerEmpire.Influence < card.getPlayCost(vote, targets);
|
|
}
|
|
else {
|
|
playButton.disabled = !playable
|
|
|| (playerEmpire.Influence < card.getPlayCost(null, targets) && awaitsObjectTarget == -1);
|
|
}
|
|
}
|
|
|
|
if(purchaseButton !is null) {
|
|
int cost = card.getPurchaseCost(playerEmpire);
|
|
purchaseButton.disabled = !card.hasPurchaseCost(playerEmpire);
|
|
}
|
|
}
|
|
|
|
void addVar(uint& index, uint mode, const Sprite& sprt, const string& name, const string& tooltip, const string& text, bool highlight) {
|
|
if(mode == IVM_PurchaseCost) {
|
|
if(purchaseIcon !is null) {
|
|
purchaseIcon.desc = sprt;
|
|
purchaseCost.text = text;
|
|
if(purchaseCost.getTextDimension().x >= purchaseCost.size.width)
|
|
purchaseCost.font = FT_Medium;
|
|
else
|
|
purchaseCost.font = FT_Big;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if(varIcons.length <= index) {
|
|
varIcons.resize(index+1);
|
|
varTexts.resize(index+1);
|
|
varNames.resize(index+1);
|
|
}
|
|
|
|
auto@ icon = varIcons[index];
|
|
if(icon is null) {
|
|
@icon = GuiSprite(this, Alignment(Left+8, Bottom - 30 - 26*index, Width=24, Height=24));
|
|
@varIcons[index] = icon;
|
|
}
|
|
|
|
icon.desc = sprt;
|
|
setMarkupTooltip(icon, tooltip, false);
|
|
|
|
auto@ nm = varNames[index];
|
|
if(nm is null) {
|
|
@nm = GuiText(this, Alignment(Left+38, Bottom - 32 - 26*index, Width=CARD_ART_SIZE.x-90, Height=30));
|
|
@varNames[index] = nm;
|
|
}
|
|
|
|
nm.text = name;
|
|
setMarkupTooltip(nm, tooltip, false);
|
|
|
|
auto@ txt = varTexts[index];
|
|
if(txt is null) {
|
|
@txt = GuiText(this, Alignment(Left+CARD_ART_SIZE.x-50, Bottom - 32 - 26*index, Width=50, Height=30));
|
|
txt.horizAlign = 1.0;
|
|
@varTexts[index] = txt;
|
|
}
|
|
|
|
txt.text = text;
|
|
setMarkupTooltip(txt, tooltip, false);
|
|
|
|
if(highlight) {
|
|
txt.font = FT_Bold;
|
|
txt.color = Color(0xffcd00ff);
|
|
}
|
|
else {
|
|
txt.font = FT_Normal;
|
|
txt.color = colors::White;
|
|
}
|
|
|
|
index += 1;
|
|
}
|
|
|
|
void play() {
|
|
for(uint i = 0, cnt = options.length; i < cnt; ++i)
|
|
options[i].fill(targets);
|
|
|
|
if(vote !is null) {
|
|
if(awaitsObjectTarget != -1) {
|
|
#section game
|
|
targetObject(CardTargeting(card, uint(awaitsObjectTarget), targets, vote), cast<Tab>(overlay.parent));
|
|
#section all
|
|
}
|
|
else {
|
|
sound::card_play.play(priority=true);
|
|
playInfluenceCard(cardId, targets, voteId = vote.id);
|
|
}
|
|
}
|
|
else {
|
|
if(awaitsObjectTarget != -1) {
|
|
#section game
|
|
targetObject(CardTargeting(card, uint(awaitsObjectTarget), targets), cast<Tab>(overlay.parent));
|
|
#section all
|
|
}
|
|
else {
|
|
sound::card_play.play(priority=true);
|
|
playInfluenceCard(cardId, targets);
|
|
}
|
|
}
|
|
overlay.close();
|
|
emitConfirmed();
|
|
}
|
|
|
|
bool onGuiEvent(const GuiEvent& event) {
|
|
switch(event.type) {
|
|
case GUI_Clicked:
|
|
if(event.caller is supportButton) {
|
|
targets.fill("VoteSide").side = true;
|
|
for(uint i = 0, cnt = options.length; i < cnt; ++i)
|
|
options[i].fill(targets);
|
|
if(awaitsObjectTarget != -1) {
|
|
#section game
|
|
targetObject(CardTargeting(card, uint(awaitsObjectTarget), targets, vote), cast<Tab>(overlay.parent));
|
|
#section all
|
|
}
|
|
else {
|
|
sound::card_play.play(priority=true);
|
|
playInfluenceCard(cardId, targets, voteId = vote.id);
|
|
}
|
|
overlay.close();
|
|
emitConfirmed();
|
|
return true;
|
|
}
|
|
else if(event.caller is opposeButton) {
|
|
targets.fill("VoteSide").side = false;
|
|
for(uint i = 0, cnt = options.length; i < cnt; ++i)
|
|
options[i].fill(targets);
|
|
if(awaitsObjectTarget != -1) {
|
|
#section game
|
|
targetObject(CardTargeting(card, uint(awaitsObjectTarget), targets, vote), cast<Tab>(overlay.parent));
|
|
#section all
|
|
}
|
|
else {
|
|
sound::card_play.play(priority=true);
|
|
playInfluenceCard(cardId, targets, voteId = vote.id);
|
|
}
|
|
overlay.close();
|
|
emitConfirmed();
|
|
return true;
|
|
}
|
|
else if(event.caller is purchaseButton) {
|
|
sound::card_draw.play(priority=true);
|
|
buyCardFromInfluenceStack(cardId);
|
|
overlay.close();
|
|
emitConfirmed();
|
|
return true;
|
|
}
|
|
else if(event.caller is playButton) {
|
|
play();
|
|
return true;
|
|
}
|
|
break;
|
|
case GUI_Confirmed:
|
|
if(event.caller !is this) {
|
|
if(playButton !is null)
|
|
play();
|
|
return true;
|
|
}
|
|
break;
|
|
case GUI_Changed:
|
|
onChange();
|
|
return true;
|
|
case GUI_Animation_Complete:
|
|
animating = false;
|
|
updateAbsolutePosition();
|
|
return true;
|
|
case GUI_Controller_Down:
|
|
return true;
|
|
case GUI_Controller_Up:
|
|
overlay.close();
|
|
return true;
|
|
}
|
|
return BaseGuiElement::onGuiEvent(event);
|
|
}
|
|
|
|
recti get_targetPosition() {
|
|
if(around is null || overlay is null || overlay.parent is null)
|
|
return recti();
|
|
|
|
int bpos = CARD_ART_SIZE.y + varTexts.length * 30;
|
|
int afterdesc = 8 + 40 * options.length;
|
|
if(haveButtons)
|
|
afterdesc += 40;
|
|
bpos = max(bpos, description.size.height + afterdesc);
|
|
|
|
vec2i sz = vec2i(size.width, bpos+38);
|
|
vec2i pos = (around.absolutePosition.topLeft - overlay.parent.absolutePosition.topLeft);
|
|
pos -= (sz - around.size) / 2;
|
|
if(pos.x < 4)
|
|
pos.x = 4;
|
|
if(pos.x + sz.x > overlay.size.x - 4)
|
|
pos.x = overlay.size.x - sz.x - 4;
|
|
if(pos.y < 4)
|
|
pos.y = 4;
|
|
if(pos.y + sz.y > overlay.size.y - 4)
|
|
pos.y = overlay.size.y - sz.y - 4;
|
|
return recti_area(pos, sz);
|
|
}
|
|
|
|
void updateAbsolutePosition() {
|
|
if(!animating)
|
|
rect = targetPosition;
|
|
BaseGuiElement::updateAbsolutePosition();
|
|
}
|
|
|
|
void remove() {
|
|
setGuiFocus(around);
|
|
@around = null;
|
|
BaseGuiElement::remove();
|
|
}
|
|
|
|
double update = 0.0;
|
|
void draw() override {
|
|
update += frameLength;
|
|
if(update >= 1.0) {
|
|
onChange();
|
|
update = 0.0;
|
|
}
|
|
BaseGuiElement::draw();
|
|
}
|
|
};
|
|
|
|
void drawCardIcon(const InfluenceCard@ card, const recti& pos, int uses = 0) {
|
|
Sprite icon = card.type.icon;
|
|
vec2i iconSize = icon.size;
|
|
recti iconPos;
|
|
if(uses == 0)
|
|
uses = card.uses;
|
|
if(iconSize.y != 0) {
|
|
iconPos = pos.padded(6, 6);
|
|
iconPos = iconPos.aspectAligned(double(iconSize.width) / double(iconSize.height));
|
|
}
|
|
|
|
Empire@ purchaser;
|
|
auto@ stackCard = cast<const StackInfluenceCard@>(card);
|
|
if(stackCard !is null)
|
|
@purchaser = stackCard.purchasedBy;
|
|
|
|
Color col;
|
|
if(purchaser !is null)
|
|
col = purchaser.color;
|
|
|
|
icon.draw(iconPos);
|
|
|
|
//Draw uses
|
|
int x = 4;
|
|
if(uses > 1) {
|
|
for(int i = 0; i < uses; ++i) {
|
|
drawRectangle(recti_area(vec2i(pos.topLeft.x+x, pos.botRight.y-9), vec2i(5, 5)), Color(0x991c1cff));
|
|
x += 8;
|
|
}
|
|
}
|
|
|
|
//Draw quality
|
|
uint quality = card.extraQuality;
|
|
x = pos.size.x - 9;
|
|
for(uint i = 0; i < quality; ++i) {
|
|
drawRectangle(recti_area(vec2i(pos.topLeft.x+x, pos.topLeft.y+4), vec2i(5, 5)), Color(0xe4d154ff));
|
|
x -= 8;
|
|
}
|
|
|
|
//Draw purchaser
|
|
if(purchaser !is null)
|
|
spritesheet::ContextIcons.draw(1, iconPos, col);
|
|
}
|
|
|
|
#section game
|
|
class CardTargeting : ObjectTargeting {
|
|
InfluenceCard@ card;
|
|
Targets@ targets;
|
|
uint index;
|
|
InfluenceVote@ vote;
|
|
|
|
bool canPlay = false;
|
|
bool canPay = false;
|
|
|
|
CardTargeting(InfluenceCard@ card, uint index, Targets@ targets, InfluenceVote@ vote = null) {
|
|
this.index = index;
|
|
@this.vote = vote;
|
|
@this.card = card;
|
|
@this.targets = targets;
|
|
}
|
|
|
|
bool valid(Object@ obj) override {
|
|
@targets.targets[index].obj = obj;
|
|
targets.targets[index].filled = true;
|
|
if(vote is null) {
|
|
if(!card.canPlay(targets)) {
|
|
canPlay = false;
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
if(!card.canPlay(vote, targets)) {
|
|
canPlay = false;
|
|
return false;
|
|
}
|
|
}
|
|
canPlay = true;
|
|
if(playerEmpire.Influence < card.getPlayCost(vote, targets)) {
|
|
canPay = false;
|
|
return false;
|
|
}
|
|
canPay = false;
|
|
return true;
|
|
}
|
|
|
|
void call(Object@ obj) override {
|
|
@targets.targets[index].obj = obj;
|
|
targets.targets[index].filled = true;
|
|
sound::card_play.play(priority=true);
|
|
if(vote is null)
|
|
playInfluenceCard(card.id, targets);
|
|
else
|
|
playInfluenceCard(card.id, targets, voteId = vote.id);
|
|
}
|
|
|
|
string message(Object@ obj, bool valid) override {
|
|
if(!canPlay)
|
|
return card.formatTitle(pretty=false);
|
|
@targets.targets[index].obj = obj;
|
|
targets.targets[index].filled = true;
|
|
int cost = card.getPlayCost(vote, targets);
|
|
return format(locale::PLAY_CARD_OPTION, card.formatTitle(pretty=false), toString(cost));
|
|
}
|
|
|
|
string desc(Object@ target, bool valid) {
|
|
if(valid)
|
|
return "";
|
|
@targets[index].obj = target;
|
|
targets[index].filled = true;
|
|
return card.getTargetError(targets);
|
|
}
|
|
};
|
|
#section all
|