Lucas de Vries
661 lines
17 KiB
ActionScript
661 lines
17 KiB
ActionScript
import overlays.InfoBar;
|
|
import elements.BaseGuiElement;
|
|
import elements.Gui3DObject;
|
|
import elements.GuiText;
|
|
import elements.GuiButton;
|
|
import elements.GuiSprite;
|
|
import elements.GuiProgressbar;
|
|
import elements.GuiGroupDisplay;
|
|
import elements.GuiBlueprint;
|
|
import elements.GuiSkinElement;
|
|
import elements.MarkupTooltip;
|
|
import elements.GuiStatusBox;
|
|
import ship_groups;
|
|
import util.formatting;
|
|
import statuses;
|
|
from statuses import getStatusID;
|
|
import icons;
|
|
from overlays.Construction import ConstructionOverlay;
|
|
from obj_selection import isSelected, selectObject, clearSelection, addToSelection;
|
|
from tabs.GalaxyTab import zoomTabTo, openOverlay, toggleSupportOverlay;
|
|
|
|
bool SHIP_INFOBAR_EXPANDED = false;
|
|
|
|
class ShipInfoBar : InfoBar {
|
|
Ship@ ship;
|
|
ConstructionOverlay@ construction;
|
|
|
|
GuiBlueprint@ bpdisp;
|
|
|
|
GuiText@ name;
|
|
GuiText@ subsystem;
|
|
|
|
GuiSprite@ healthIcon;
|
|
GuiText@ healthLabel;
|
|
GuiProgressbar@ health;
|
|
|
|
GuiSprite@ supplyIcon;
|
|
GuiText@ supplyLabel;
|
|
GuiProgressbar@ supply;
|
|
|
|
GuiSprite@ strengthIcon;
|
|
GuiText@ strengthLabel;
|
|
GuiProgressbar@ strength;
|
|
|
|
GuiSkinElement@ groupBox;
|
|
GuiGroupDisplay@ groupdisp;
|
|
|
|
BaseGuiElement@ buttonBar;
|
|
GuiButton@ supportsButton;
|
|
GuiButton@ formationButton;
|
|
GuiButton@ ordersButton;
|
|
|
|
GuiProgressbar@ shield;
|
|
GuiSprite@ shieldIcon;
|
|
|
|
GuiProgressbar@ exp;
|
|
|
|
GuiButton@ expandButton;
|
|
|
|
ActionBar@ actions;
|
|
bool expanded = false;
|
|
|
|
array<Status> statuses;
|
|
array<GuiStatusBox@> statusBoxes;
|
|
|
|
ShipInfoBar(IGuiElement@ parent) {
|
|
super(parent);
|
|
@alignment = Alignment(Left, Bottom-263, Left+395, Bottom);
|
|
|
|
@actions = ActionBar(this, vec2i(385, 207));
|
|
actions.noClip = true;
|
|
|
|
int y = -8;
|
|
|
|
y += 38;
|
|
@bpdisp = GuiBlueprint(this, Alignment(Left+4, Top+y, Right-128, Bottom-70));
|
|
bpdisp.noClip = true;
|
|
bpdisp.popHover = true;
|
|
bpdisp.popSize = vec2i(77, 40);
|
|
bpdisp.horizAlign = 0.25;
|
|
bpdisp.vertAlign = 1.0;
|
|
bpdisp.hoverArcs = true;
|
|
|
|
@name = GuiText(bpdisp, Alignment(Left+12, Top+28, Right-12, Top+60));
|
|
name.horizAlign = 0.0;
|
|
name.vertAlign = 0.0;
|
|
name.font = FT_Medium;
|
|
name.stroke = colors::Black;
|
|
name.visible = false;
|
|
|
|
@subsystem = GuiText(bpdisp, Alignment(Left+12, Top+28, Right-12, Top+60));
|
|
subsystem.horizAlign = 1.0;
|
|
subsystem.vertAlign = 0.0;
|
|
subsystem.font = FT_Subtitle;
|
|
subsystem.stroke = colors::Black;
|
|
subsystem.visible = false;
|
|
|
|
@expandButton = GuiButton(bpdisp, Alignment(Right+75, Bottom-20, Width=20, Height=20), icons::Add);
|
|
expandButton.noClip = true;
|
|
expandButton.style = SS_IconButton;
|
|
|
|
@health = GuiProgressbar(this, Alignment(Left+8, Bottom-68, Left+200, Bottom-38));
|
|
health.textHorizAlign = 0.9;
|
|
|
|
@healthIcon = GuiSprite(health, Alignment(Left-8, Top-9, Left+24, Bottom-8), icons::Health);
|
|
healthIcon.noClip = true;
|
|
@healthLabel = GuiText(health, Alignment(Left+23, Top, Left+100, Bottom));
|
|
healthLabel.font = FT_Bold;
|
|
healthLabel.text = locale::HEALTH;
|
|
healthLabel.stroke = colors::Black;
|
|
|
|
@shield = GuiProgressbar(this, Alignment(Left+9, Bottom-48, Left+199, Bottom-38));
|
|
shield.noClip = true;
|
|
shield.textHorizAlign = 0.85;
|
|
shield.textVertAlign = 1.65;
|
|
shield.visible = false;
|
|
shield.frontColor = Color(0x429cffff);
|
|
shield.backColor = Color(0x59a8ff20);
|
|
|
|
@shieldIcon = GuiSprite(shield, Alignment(Right-25, Bottom-25, Width=30, Height=30), icons::Shield);
|
|
shieldIcon.noClip = true;
|
|
|
|
@supply = GuiProgressbar(this, Alignment(Left+206, Bottom-68, Right-22, Bottom-38));
|
|
supply.textHorizAlign = 0.9;
|
|
|
|
@supplyIcon = GuiSprite(supply, Alignment(Left-5, Top-6, Left+24, Bottom-8), icons::Supply);
|
|
supplyIcon.noClip = true;
|
|
@supplyLabel = GuiText(supply, Alignment(Left+23, Top, Left+100, Bottom));
|
|
supplyLabel.font = FT_Bold;
|
|
supplyLabel.text = locale::SUPPLY;
|
|
supplyLabel.stroke = colors::Black;
|
|
|
|
@strength = GuiProgressbar(this, Alignment(Left+8, Bottom-34, Left+200, Bottom-4));
|
|
strength.textHorizAlign = 0.9;
|
|
|
|
@exp = GuiProgressbar(strength, Alignment(Left, Bottom-6, Right, Bottom));
|
|
exp.frontColor = Color(0xff009eff);
|
|
exp.backColor = colors::Invisible;
|
|
exp.visible = false;
|
|
|
|
@strengthIcon = GuiSprite(strength, Alignment(Left-5, Top-6, Left+24, Bottom-8), icons::Strength);
|
|
strengthIcon.noClip = true;
|
|
@strengthLabel = GuiText(strength, Alignment(Left+23, Top, Left+100, Bottom));
|
|
strengthLabel.font = FT_Bold;
|
|
strengthLabel.text = locale::STRENGTH;
|
|
strengthLabel.stroke = colors::Black;
|
|
|
|
@groupBox = GuiSkinElement(this, Alignment(Left+206, Bottom-34, Right-22, Bottom-5), SS_PlainOverlay);
|
|
@groupdisp = GuiGroupDisplay(groupBox, Alignment(Left+3, Top+4, Right-3, Bottom));
|
|
groupdisp.horizAlign = 0.0;
|
|
|
|
updateAbsolutePosition();
|
|
setExpanded(SHIP_INFOBAR_EXPANDED);
|
|
}
|
|
|
|
void remove() override {
|
|
if(construction !is null)
|
|
construction.remove();
|
|
InfoBar::remove();
|
|
}
|
|
|
|
void setExpanded(bool value) {
|
|
if(expanded == value)
|
|
return;
|
|
expanded = value;
|
|
|
|
bpdisp.alignment.set(Left+4, Top+30, Right-128, Bottom-70);
|
|
if(expanded) {
|
|
bpdisp.alignment.padded(0,
|
|
-480.0/1920.0*double(screenSize.width),
|
|
-610.0/1080.0*double(screenSize.height),
|
|
0);
|
|
bpdisp.horizAlign = 0.5;
|
|
bpdisp.vertAlign = 0.5;
|
|
expandButton.alignment.set(Right-34, Bottom-20, Right-34+28, Bottom-20+28);
|
|
expandButton.setIcon(icons::Minus);
|
|
}
|
|
else {
|
|
bpdisp.horizAlign = 0.25;
|
|
bpdisp.vertAlign = 1.0;
|
|
expandButton.alignment.set(Right+75, Bottom-20, Right+75+20, Bottom-20+20);
|
|
expandButton.setIcon(icons::Add);
|
|
}
|
|
|
|
bpdisp.updateAbsolutePosition();
|
|
|
|
bpdisp.popHover = !expanded;
|
|
name.visible = expanded;
|
|
subsystem.visible = expanded;
|
|
}
|
|
|
|
void updateActions() {
|
|
actions.clear();
|
|
|
|
if(ship.owner !is null && ship.owner.controlled) {
|
|
actions.addBasic(ship);
|
|
actions.addFTL(ship);
|
|
actions.addAbilities(ship);
|
|
actions.addEmpireAbilities(ship.owner, ship);
|
|
actions.addScouting(ship);
|
|
}
|
|
|
|
actions.init(ship);
|
|
}
|
|
|
|
bool compatible(Object@ obj) override {
|
|
return obj.isShip;
|
|
}
|
|
|
|
Object@ get() override {
|
|
return ship;
|
|
}
|
|
|
|
void set(Object@ obj) override {
|
|
@ship = cast<Ship>(obj);
|
|
bpdisp.display(ship);
|
|
|
|
setExpanded(SHIP_INFOBAR_EXPANDED);
|
|
updateActions();
|
|
}
|
|
|
|
bool displays(Object@ obj) override {
|
|
if(obj is ship)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool showManage(Object@ obj) override {
|
|
if(construction !is null)
|
|
construction.remove();
|
|
if(obj.hasConstruction && obj.owner.controlled) {
|
|
@construction = ConstructionOverlay(findTab(), obj);
|
|
return false;
|
|
}
|
|
if(!expanded)
|
|
setExpanded(true);
|
|
return false;
|
|
}
|
|
|
|
void toggleExpanded() {
|
|
if(expanded == SHIP_INFOBAR_EXPANDED) {
|
|
SHIP_INFOBAR_EXPANDED = !SHIP_INFOBAR_EXPANDED;
|
|
setExpanded(SHIP_INFOBAR_EXPANDED);
|
|
}
|
|
else {
|
|
setExpanded(!expanded);
|
|
}
|
|
}
|
|
|
|
double lastClick = -INFINITY;
|
|
bool onMouseEvent(const MouseEvent& event, IGuiElement@ source) {
|
|
switch(event.type) {
|
|
case MET_Button_Up: {
|
|
if(event.button == 0) {
|
|
if(lastClick > frameTime - double(settings::iDoubleClickMS) / 1000.0) {
|
|
selectObject(ship);
|
|
setExpanded(!expanded);
|
|
if(SHIP_INFOBAR_EXPANDED && !expanded)
|
|
SHIP_INFOBAR_EXPANDED = false;
|
|
}
|
|
else
|
|
lastClick = frameTime;
|
|
}
|
|
else if(event.button == 2) {
|
|
zoomTabTo(ship);
|
|
return true;
|
|
}
|
|
else if(event.button == 1) {
|
|
toggleExpanded();
|
|
return true;
|
|
}
|
|
} break;
|
|
}
|
|
return InfoBar::onMouseEvent(event, source);
|
|
}
|
|
|
|
bool onGuiEvent(const GuiEvent& evt) override {
|
|
switch(evt.type) {
|
|
case GUI_Clicked:
|
|
if(evt.caller is groupdisp) {
|
|
if(groupdisp.hovered == 0) {
|
|
selectObject(groupdisp.leader);
|
|
}
|
|
else {
|
|
if(!shiftKey)
|
|
clearSelection();
|
|
Object@ leader = groupdisp.leader;
|
|
GroupData@ dat = groupdisp.groups[groupdisp.hovered-1];
|
|
for(uint i = 0, cnt = leader.supportCount; i < cnt; ++i) {
|
|
Ship@ supp = cast<Ship>(leader.supportShip[i]);
|
|
if(supp !is null && supp.valid && supp.blueprint.design is dat.dsg)
|
|
addToSelection(supp);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else if(evt.caller is expandButton) {
|
|
toggleExpanded();
|
|
return true;
|
|
}
|
|
break;
|
|
case GUI_Hover_Changed:
|
|
if(evt.caller is bpdisp) {
|
|
updateHealthBar();
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
return InfoBar::onGuiEvent(evt);
|
|
}
|
|
|
|
void updateHealthBar() {
|
|
if(ship is null)
|
|
return;
|
|
|
|
const Blueprint@ bp = ship.blueprint;
|
|
const Design@ design = bp.design;
|
|
const Hull@ hull = design.hull;
|
|
|
|
Color high;
|
|
Color low;
|
|
|
|
double curHP = 0, maxHP = 1;
|
|
if(bpdisp.hexHovered.x < 0 || bpdisp.hexHovered.y < 0) {
|
|
curHP = bp.currentHP * bp.hpFactor;
|
|
maxHP = (design.totalHP - bp.removedHP) * bp.hpFactor;
|
|
|
|
high = Color(0x00ff00ff);
|
|
low = Color(0xff0000ff);
|
|
|
|
subsystem.visible = false;
|
|
}
|
|
else {
|
|
ObjectLock lock(ship, true);
|
|
vec2u hex = vec2u(bpdisp.hexHovered);
|
|
const HexStatus@ status = bp.getHexStatus(hex.x, hex.y);
|
|
if(status !is null) {
|
|
maxHP = design.variable(hex, HV_HP) * bp.hpFactor;
|
|
curHP = maxHP * double(status.hp) / double(0xff);
|
|
}
|
|
|
|
high = Color(0x9768ffff);
|
|
low = Color(0xff689bff);
|
|
|
|
auto@ sys = design.subsystem(hex);
|
|
auto@ mod = design.module(hex);
|
|
if(sys !is null && expanded) {
|
|
subsystem.visible = true;
|
|
if(mod is null || mod is sys.type.coreModule || mod is sys.type.defaultModule) {
|
|
if(mod is sys.type.coreModule)
|
|
subsystem.text = format("$1 ($2)", sys.type.name, locale::SUBSYS_CORE);
|
|
else
|
|
subsystem.text = sys.type.name;
|
|
subsystem.color = sys.type.color;
|
|
}
|
|
else {
|
|
subsystem.text = mod.name;
|
|
subsystem.color = mod.color;
|
|
}
|
|
}
|
|
else {
|
|
subsystem.visible = false;
|
|
}
|
|
}
|
|
|
|
if(!ship.visible)
|
|
curHP = maxHP;
|
|
|
|
health.progress = curHP / maxHP;
|
|
health.frontColor = low.interpolate(high, health.progress);
|
|
health.text = standardize(curHP)+" / "+standardize(maxHP);
|
|
|
|
double repair = 0.0, combatMod = 1.0;
|
|
if(design !is null) {
|
|
repair = design.total(SV_Repair);
|
|
combatMod *= min(bp.shipEffectiveness, 1.0);
|
|
}
|
|
|
|
string tt = format(locale::TT_SHIP_HEALTH,
|
|
standardize(curHP), standardize(maxHP),
|
|
standardize(repair * 1.0/3.0 * combatMod), standardize(repair));
|
|
|
|
//Update shields
|
|
double curShield = ship.Shield;
|
|
double maxShield = ship.MaxShield;
|
|
|
|
if(maxShield != 0) {
|
|
shield.visible = true;
|
|
health.textHorizAlign = 0.25;
|
|
healthLabel.visible = false;
|
|
|
|
shield.progress = min(curShield / max(maxShield, 0.01), 1.0);
|
|
shield.text = standardize(curShield, true);
|
|
|
|
double shieldRegen = design.total(SV_ShieldRegen);
|
|
tt += "\n\n";
|
|
tt += format(locale::TT_SHIP_SHIELD,
|
|
standardize(curShield), standardize(maxShield),
|
|
standardize(shieldRegen));
|
|
}
|
|
else {
|
|
shield.visible = false;
|
|
health.textHorizAlign = 0.9;
|
|
healthLabel.visible = true;
|
|
}
|
|
|
|
setMarkupTooltip(health, tt, width = 350);
|
|
@shield.tooltipObject = health.tooltipObject;
|
|
}
|
|
|
|
void updateStrengthBar() {
|
|
if(groupdisp.leader is null) {
|
|
strength.progress = 0.f;
|
|
strength.text = "-";
|
|
setMarkupTooltip(strength, "");
|
|
return;
|
|
}
|
|
|
|
Ship@ leader = cast<Ship>(groupdisp.leader);
|
|
const Design@ design;
|
|
if(leader !is null)
|
|
@design = leader.blueprint.design;
|
|
|
|
double curStr = groupdisp.leader.getFleetStrength() * 0.001;
|
|
double totStr = groupdisp.leader.getFleetMaxStrength() * 0.001;
|
|
|
|
if(!ship.visible)
|
|
curStr = totStr;
|
|
|
|
if(totStr == 0) {
|
|
strength.progress = 0.f;
|
|
strength.frontColor = Color(0xff6a00ff);
|
|
strength.text = "-";
|
|
}
|
|
else {
|
|
strength.progress = curStr / totStr;
|
|
if(strength.progress > 1.001f) {
|
|
strength.progress = 1.f;
|
|
strength.font = FT_Bold;
|
|
}
|
|
else {
|
|
strength.font = FT_Normal;
|
|
}
|
|
|
|
strength.frontColor = Color(0xff6a00ff).interpolate(Color(0xffc600ff), strength.progress);
|
|
strength.text = standardize(curStr);
|
|
}
|
|
|
|
double dps = groupdisp.leader.getFleetDPS();
|
|
double hp = groupdisp.leader.getFleetHP();
|
|
|
|
float curEff = groupdisp.leader.getFleetEffectiveness();
|
|
float baseEff = groupdisp.leader.getBaseFleetEffectiveness();
|
|
float eff = curEff / baseEff;
|
|
|
|
string tt = format(locale::TT_SHIP_STRENGTH,
|
|
standardize(curStr), standardize(totStr),
|
|
standardize(hp), standardize(dps),
|
|
toString(eff*100.f, 0)+"%");
|
|
if(baseEff != 1.f)
|
|
tt += "\n"+format(locale::TT_SHIP_EFF_BONUS,
|
|
toString((baseEff-1.f)*100.f, 0)+"%");
|
|
|
|
if(design !is null) {
|
|
int curLevel = groupdisp.leader.getStatusStackCountAny(levelStatus);
|
|
double needExp = groupdisp.leader.getRemainingExp();
|
|
double totalExp = design.size * (config::EXPERIENCE_BASE_AMOUNT + config::EXPERIENCE_INCREASE_AMOUNT * curLevel);
|
|
|
|
if(config::EXPERIENCE_GAIN_FACTOR != 0 && totalExp != 0) {
|
|
exp.progress = 1.0 - (needExp / totalExp);
|
|
exp.visible = true;
|
|
|
|
tt += "\n\n";
|
|
tt += format(locale::TT_SHIP_EXPERIENCE,
|
|
toString(needExp, 0), toString(totalExp, 0),
|
|
toString(curLevel, 0), toString(totalExp-needExp, 0));
|
|
}
|
|
else {
|
|
exp.visible = false;
|
|
}
|
|
}
|
|
else {
|
|
exp.visible = false;
|
|
}
|
|
|
|
setMarkupTooltip(strength, tt, width = 350);
|
|
}
|
|
|
|
void updateSupplyBar() {
|
|
double curSup = 0.0;
|
|
double totSup = 0.0;
|
|
|
|
Ship@ leader = cast<Ship>(groupdisp.leader);
|
|
const Design@ design;
|
|
if(leader !is null) {
|
|
curSup = leader.Supply;
|
|
totSup = leader.MaxSupply;
|
|
@design = leader.blueprint.design;
|
|
}
|
|
|
|
if(!ship.visible)
|
|
curSup = totSup;
|
|
|
|
if(totSup == 0) {
|
|
supply.progress = 0.f;
|
|
supply.frontColor = Color(0xff6a00ff);
|
|
supply.text = "-";
|
|
}
|
|
else {
|
|
supply.progress = curSup / totSup;
|
|
if(supply.progress > 1.001f) {
|
|
supply.progress = 1.f;
|
|
supply.font = FT_Bold;
|
|
}
|
|
else {
|
|
supply.font = FT_Normal;
|
|
}
|
|
|
|
if(supply.progress < 0.4f)
|
|
supply.frontColor = Color(0xd53f1eff).interpolate(Color(0xd5cc1eff), supply.progress/0.4f);
|
|
else
|
|
supply.frontColor = Color(0x4a9487ff);
|
|
supply.text = standardize(curSup);
|
|
}
|
|
|
|
double resupply = 0.0;
|
|
if(design !is null)
|
|
resupply = design.total(SV_SupplyRate);
|
|
setMarkupTooltip(supply, format(locale::TT_SHIP_SUPPLY,
|
|
standardize(curSup), standardize(totSup),
|
|
standardize(resupply * 0.12f), standardize(resupply)),
|
|
width = 350);
|
|
}
|
|
|
|
IGuiElement@ elementFromPosition(const vec2i& pos) override {
|
|
IGuiElement@ elem = BaseGuiElement::elementFromPosition(pos);
|
|
if(!expanded && (elem is this || elem is bpdisp)) {
|
|
vec2i relPos = pos - AbsolutePosition.topLeft;
|
|
bool active = material::ShipInfoBar.isPixelActive(relPos);
|
|
if(!active)
|
|
return null;
|
|
}
|
|
return elem;
|
|
}
|
|
|
|
double updateTimer = 1.0;
|
|
void update(double time) override {
|
|
Empire@ owner = ship.owner;
|
|
bool owned = owner is playerEmpire;
|
|
const Blueprint@ bp = ship.blueprint;
|
|
const Design@ design = bp.design;
|
|
const Hull@ hull = design.hull;
|
|
|
|
if(expanded && !SHIP_INFOBAR_EXPANDED && !ship.selected)
|
|
setExpanded(false);
|
|
|
|
if(design !is bpdisp.design)
|
|
set(ship);
|
|
|
|
if(ship.visible) {
|
|
@bpdisp.bp = bp;
|
|
groupdisp.visible = true;
|
|
}
|
|
else {
|
|
@bpdisp.bp = null;
|
|
groupdisp.visible = false;
|
|
}
|
|
|
|
if(construction !is null) {
|
|
if(construction.parent is null) {
|
|
@construction = null;
|
|
visible = true;
|
|
}
|
|
else
|
|
construction.update(time);
|
|
}
|
|
|
|
//Update ship data
|
|
name.font = FT_Medium;
|
|
name.text = formatShipName(ship);
|
|
if(owner !is null)
|
|
name.color = owner.color;
|
|
vec2i dim = name.getTextDimension();
|
|
int w = clamp(dim.x+26, 160, 1000);
|
|
if(dim.x > name.size.width) {
|
|
name.font = FT_Bold;
|
|
dim = name.getTextDimension();
|
|
if(dim.x > name.size.width)
|
|
name.font = FT_Small;
|
|
}
|
|
|
|
//Update statuses
|
|
Object@ leader = groupdisp.leader;
|
|
if(leader !is null && leader.statusEffectCount > 0)
|
|
statuses.syncFrom(leader.getStatusEffects());
|
|
else
|
|
statuses.length = 0;
|
|
|
|
updateStatusBoxes(bpdisp, statuses, statusBoxes, fromObject=leader);
|
|
int off = expanded ? -70 : 30;
|
|
for(uint i = 0, cnt = statusBoxes.length; i < cnt; ++i) {
|
|
statusBoxes[i].noClip = true;
|
|
statusBoxes[i].rect = recti_area(bpdisp.size.width+off-36*i, bpdisp.size.height-26, 32,32);
|
|
}
|
|
|
|
//Update whatever health is displayed
|
|
updateHealthBar();
|
|
updateSupplyBar();
|
|
updateStrengthBar();
|
|
|
|
//Update group
|
|
groupdisp.update(ship);
|
|
|
|
updateTimer -= time;
|
|
if(updateTimer <= 0) {
|
|
updateTimer = 1.0;
|
|
updateActions();
|
|
}
|
|
|
|
InfoBar::update(time);
|
|
}
|
|
|
|
void draw() override {
|
|
Color col;
|
|
Empire@ owner = ship.owner;
|
|
if(owner !is null)
|
|
col = owner.color;
|
|
|
|
if(!expanded)
|
|
material::ShipInfoBar.draw(AbsolutePosition.padded(0,0,0,35), col);
|
|
else {
|
|
skin.draw(SS_Panel, SF_Normal, bpdisp.absolutePosition.padded(-20,0,0,-100), col);
|
|
skin.draw(SS_BG3D, SF_Normal, bpdisp.absolutePosition.padded(0,4,4,-12), col);
|
|
}
|
|
|
|
if(actions.visible) {
|
|
recti pos = actions.absolutePosition;
|
|
skin.draw(SS_Panel, SF_Normal, recti(pos.topLeft - vec2i(50, 0), pos.botRight + vec2i(0, 20)));
|
|
}
|
|
|
|
skin.draw(SS_InfoBar, SF_Normal, recti_area(vec2i(AbsolutePosition.topLeft.x, AbsolutePosition.botRight.y-40), vec2i(AbsolutePosition.width-13, 45)));
|
|
BaseGuiElement::draw();
|
|
}
|
|
};
|
|
|
|
InfoBar@ makeShipInfoBar(IGuiElement@ parent, Object@ obj) {
|
|
ShipInfoBar bar(parent);
|
|
bar.set(obj);
|
|
return bar;
|
|
}
|
|
|
|
import void resetGalaxyTabs() from "tabs.GalaxyTab";
|
|
void postReload(Message& msg) {
|
|
resetGalaxyTabs();
|
|
}
|
|
|
|
int levelStatus = -1;
|
|
void init() {
|
|
levelStatus = getStatusID("ShipLevel");
|
|
}
|