Lucas de Vries
1271 lines
32 KiB
ActionScript
1271 lines
32 KiB
ActionScript
#priority init 1501
|
|
import maps;
|
|
|
|
#section game
|
|
import dialogue;
|
|
#section all
|
|
|
|
#section server
|
|
import object_creation;
|
|
import influence;
|
|
import tile_resources;
|
|
import scenario;
|
|
from influence import InfluenceStore;
|
|
from influence_global import influenceLock, cardStack, deck, nextStackId, StackInfluenceCard;
|
|
import systems;
|
|
import map_loader;
|
|
#section all
|
|
|
|
Tutorial _map;
|
|
class Tutorial : Map {
|
|
Tutorial() {
|
|
super();
|
|
|
|
isListed = false;
|
|
isScenario = true;
|
|
}
|
|
|
|
#section server
|
|
void prepareSystem(SystemData@ data, SystemDesc@ desc) {
|
|
@data.homeworlds = null;
|
|
Map::prepareSystem(data, desc);
|
|
}
|
|
|
|
bool canHaveHomeworld(SystemData@ data, Empire@ emp) {
|
|
return false;
|
|
}
|
|
|
|
void preGenerate() {
|
|
Map::preGenerate();
|
|
radius = 40000;
|
|
}
|
|
|
|
void placeSystems() {
|
|
loadMap("maps/Tutorial/map.txt").generate(this);
|
|
}
|
|
|
|
void modSettings(GameSettings& settings) {
|
|
settings.empires.length = 2;
|
|
settings.empires[0].name = locale::TUT_PLAYER_EMP;
|
|
settings.empires[1].name = locale::TUT_ENEMY_EMP;
|
|
settings.empires[1].shipset = "Gevron";
|
|
settings.empires[1].type = ET_NoAI;
|
|
config::ENABLE_UNIQUE_SPREADS = 0.0;
|
|
config::DISABLE_STARTING_FLEETS = 1.0;
|
|
config::ENABLE_DREAD_PIRATE = 0.0;
|
|
config::ENABLE_INFLUENCE_EVENTS = 0.0;
|
|
config::START_EXPLORED_MAP = 1.0;
|
|
}
|
|
|
|
void enemyPlanet(uint systemId, uint planetId) {
|
|
auto@ sys = systemData[systemId];
|
|
auto@ planet = sys.planets[planetId];
|
|
|
|
planet.addPopulation(1.0);
|
|
@planet.owner = enemyEmp;
|
|
}
|
|
|
|
Empire@ enemyEmp;
|
|
const SystemDesc@ lihls;
|
|
const SystemDesc@ yingmow;
|
|
Planet@ spacewood;
|
|
bool ownsSpacewood = false;
|
|
|
|
void spawnPlayerFleet() {
|
|
auto@ leaderDsg = playerEmpire.getDesign("Battleship");
|
|
auto@ sup1Dsg = playerEmpire.getDesign("Beamship");
|
|
auto@ sup2Dsg = playerEmpire.getDesign("Heavy Gunship");
|
|
auto@ sup3Dsg = playerEmpire.getDesign("Missile Boat");
|
|
|
|
vec3d pos = systemData[0].position + vec3d(200, 0, 900);
|
|
|
|
Ship@ leader = createShip(pos, leaderDsg, playerEmpire, free=true);
|
|
leader.name = locale::TUT_FLAGSHIP_NAME;
|
|
leader.setHoldPosition(true);
|
|
playerEmpire.registerFleet(leader);
|
|
for(uint i = 0; i < 25; ++i)
|
|
createShip(pos, sup1Dsg, playerEmpire, leader);
|
|
for(uint i = 0; i < 25; ++i)
|
|
createShip(pos, sup2Dsg, playerEmpire, leader);
|
|
for(uint i = 0; i < 25; ++i)
|
|
createShip(pos, sup3Dsg, playerEmpire, leader);
|
|
}
|
|
|
|
void spawnEnemyFleet(const vec3d& pos, const string& base = "Battleship", uint supBase = 25, bool aggro = false) {
|
|
auto@ leaderDsg = enemyEmp.getDesign(base);
|
|
auto@ sup1Dsg = enemyEmp.getDesign("Beamship");
|
|
auto@ sup2Dsg = enemyEmp.getDesign("Heavy Gunship");
|
|
auto@ sup3Dsg = enemyEmp.getDesign("Missile Boat");
|
|
|
|
Ship@ leader = createShip(pos, leaderDsg, enemyEmp, free=true);
|
|
if(!aggro)
|
|
leader.setHoldPosition(true);
|
|
for(uint i = 0; i < supBase; ++i)
|
|
createShip(pos, sup1Dsg, enemyEmp, leader);
|
|
for(uint i = 0; i < supBase; ++i)
|
|
createShip(pos, sup2Dsg, enemyEmp, leader);
|
|
for(uint i = 0; i < supBase; ++i)
|
|
createShip(pos, sup3Dsg, enemyEmp, leader);
|
|
}
|
|
|
|
void init() {
|
|
@enemyEmp = getEmpire(1);
|
|
@lihls = systems[1];
|
|
@yingmow = systems[3];
|
|
@spacewood = systemData[1].planets[0];
|
|
playerEmpire.setHostile(enemyEmp, true);
|
|
playerEmpire.Victory = -3;
|
|
enemyEmp.Victory = -3;
|
|
enemyEmp.setHostile(playerEmpire, true);
|
|
|
|
playerEmpire.ContactMask.value = int(~0);
|
|
|
|
initDialogue();
|
|
}
|
|
|
|
void postInit() {
|
|
@enemyEmp = getEmpire(1);
|
|
@lihls = systems[1];
|
|
@yingmow = systems[3];
|
|
@spacewood = systemData[1].planets[0];
|
|
|
|
//Player influence
|
|
{
|
|
playerEmpire.modInfluence(+50);
|
|
|
|
auto@ type = getInfluenceCardType("AnnexSystem");
|
|
InfluenceCard@ card = type.create();
|
|
cast<InfluenceStore>(playerEmpire.InfluenceManager).addCard(playerEmpire, card);
|
|
}
|
|
|
|
//Player FTL
|
|
playerEmpire.modFTLStored(+250);
|
|
|
|
//Set up planets
|
|
enemyPlanet(2, 3);
|
|
enemyPlanet(3, 1);
|
|
enemyPlanet(3, 2);
|
|
enemyPlanet(3, 3);
|
|
systemData[3].planets[1].exportResource(0, systemData[3].planets[3]);
|
|
systemData[3].planets[2].exportResource(0, systemData[3].planets[3]);
|
|
|
|
//Set up initial fleets
|
|
spawnPlayerFleet();
|
|
Orbital@ orb = createOrbital(systemData[0].position + vec3d(600, 0, 200), getOrbitalModule("GateCore"), enemyEmp);
|
|
orb.modMaxHealth(-5500);
|
|
orb.modMaxArmor(-2500);
|
|
spawnEnemyFleet(systemData[0].position + vec3d(700, 0, 250), "Dreadnaught", 5);
|
|
spawnEnemyFleet(systemData[0].position + vec3d(500, 0, 150), "Dreadnaught", 5);
|
|
|
|
//Defenses for phasite
|
|
{
|
|
auto@ enemySup = enemyEmp.getDesign("Beamship");
|
|
vec3d pos = systemData[2].planets[3].position;
|
|
for(uint i = 0; i < 20; ++i)
|
|
createShip(pos, enemySup, enemyEmp, systemData[2].planets[3]);
|
|
}
|
|
|
|
guiDialogueAction(CURRENT_PLAYER, "Tutorial.Tutorial::ZoomFleet");
|
|
}
|
|
|
|
void initDialogue() {
|
|
//Prepare dialogue
|
|
Dialogue("TUT_INTRO")
|
|
.onPass(GUIAction("Tutorial.Tutorial::HideGUI"));
|
|
Dialogue("TUT_INTRO2");
|
|
Dialogue("TUT_INTRO3");
|
|
Dialogue("TUT_CAM")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckPan"))
|
|
.checker(2, GUIChecker("Tutorial.Tutorial::CheckZoom"))
|
|
.checker(3, GUIChecker("Tutorial.Tutorial::CheckRotate"));
|
|
Dialogue("TUT_TIME")
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowTime"));
|
|
Dialogue("TUT_SCAN")
|
|
.checker(1, CheckFleetSelect())
|
|
.checker(2, CheckFleetAttack())
|
|
.checker(3, CheckDestroyGate());
|
|
Dialogue("TUT_FTL");
|
|
Dialogue("TUT_FTL2")
|
|
.objectiveKeybind(1, KB_FTL)
|
|
.checker(1, CheckSystemArrive())
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowFTL"))
|
|
.onComplete(GainSpacewood(this));
|
|
Dialogue("TUT_ARRIVE");
|
|
Dialogue("TUT_RES");
|
|
Dialogue("TUT_LEVEL");
|
|
Dialogue("TUT_LEVEL2");
|
|
Dialogue("TUT_EXPAND")
|
|
.checker(1, CheckColonizeFood())
|
|
.checker(2, CheckExportFood())
|
|
.checker(3, CheckColonizeTier1())
|
|
.checker(4, CheckExportTier1());
|
|
Dialogue("TUT_LEVELREQS");
|
|
Dialogue("TUT_IMPORT1")
|
|
.checker(1, CheckLevel1());
|
|
Dialogue("TUT_IMPORT2")
|
|
.checker(1, CheckLevel2());
|
|
Dialogue("TUT_EXPAND_SUCC")
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowPlanets"));
|
|
Dialogue("TUT_BUDGET")
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowMoney"));
|
|
Dialogue("TUT_BUDGET2");
|
|
Dialogue("TUT_BUILD")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckPlanetOverlay", spacewood))
|
|
.checker(2, CheckBuildScout()) ;
|
|
Dialogue("TUT_BUILD2")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckNoOverlay"))
|
|
.checker(2, GUIChecker("Tutorial.Tutorial::CheckFleetOverlay"))
|
|
.checker(3, CheckReinforceFleet())
|
|
.checker(4, CheckScoutFinished());
|
|
Dialogue("TUT_SCOUT")
|
|
.checker(1, CheckScouted());
|
|
Dialogue("TUT_CONQ")
|
|
.checker(1, CheckFleetMoved())
|
|
.checker(2, CheckDefenseKilled())
|
|
.checker(3, CheckCaptured());
|
|
Dialogue("TUT_CAPT")
|
|
.checker(1, CheckPhasiteImport())
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowQuickbars"));
|
|
Dialogue("TUT_PRES");
|
|
Dialogue("TUT_BLD")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckPlanetOverlay", spacewood))
|
|
.checker(2, GUIChecker("Tutorial.Tutorial::CheckBuildingsList"))
|
|
.checker(3, CheckResearchComplex())
|
|
.onComplete(GainResearchRate());
|
|
Dialogue("TUT_RSC")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckResearchTab"))
|
|
.checker(2, CheckResearchArmoring())
|
|
.checker(3, CheckResearchBulkhead())
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowResearch"));
|
|
Dialogue("TUT_DSG")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckDesignEdit"))
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowDesigns"));
|
|
Dialogue("TUT_DSG2");
|
|
Dialogue("TUT_DSG3")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckDesignArmor"));
|
|
Dialogue("TUT_DSG4")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckDesignBulkhead"))
|
|
.checker(2, GUIChecker("Tutorial.Tutorial::CheckDesignSaved"));
|
|
Dialogue("TUT_FLT")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckPlanetOverlay", spacewood))
|
|
.checker(2, CheckBuildCarrier())
|
|
.checker(3, CheckAddBeamships())
|
|
.checker(4, CheckAddSupports())
|
|
.checker(5, CheckFinishCarrier())
|
|
.onComplete(GainEnergy());
|
|
Dialogue("TUT_ENG")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckArtifactTarget"))
|
|
.checker(2, CheckArtifactEquip())
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowEnergy"));
|
|
Dialogue("TUT_INF")
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowInfluence"));
|
|
Dialogue("TUT_INF2")
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowInfluenceTab"));
|
|
Dialogue("TUT_INF3")
|
|
.checker(1, CheckBuySpy())
|
|
.checker(2, CheckActivateSpy())
|
|
.onComplete(ShowSpySystem());
|
|
Dialogue("TUT_INF4");
|
|
Dialogue("TUT_SPY")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckViewSpy"));
|
|
Dialogue("TUT_ANNEX")
|
|
.checker(1, CheckStartVote());
|
|
Dialogue("TUT_VOTE");
|
|
Dialogue("TUT_VOTE2")
|
|
.onComplete(EnemyPlayRhetoric());
|
|
Dialogue("TUT_VOTE3")
|
|
.checker(1, CheckPlayNegotiate())
|
|
.checker(2, CheckWinVote());
|
|
Dialogue("TUT_ANNEX2");
|
|
Dialogue("TUT_DEFCORE")
|
|
.checker(1, GUIChecker("Tutorial.Tutorial::CheckPlanetOverlay", spacewood))
|
|
.checker(2, GUIChecker("Tutorial.Tutorial::CheckOrbitalsList"))
|
|
.checker(3, GUIChecker("Tutorial.Tutorial::CheckTargetDefPlat"))
|
|
.checker(4, CheckOrbitalPlaced())
|
|
.onComplete(GainDefenseGen(this));
|
|
Dialogue("TUT_DEFPROJ")
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowDefense"))
|
|
.checker(1, CheckDefenseProject())
|
|
.checker(2, CheckMoveFleet());
|
|
Dialogue("TUT_DEF")
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowTabStuff"))
|
|
.proceedWith(locale::ENTER_COMBAT)
|
|
.onComplete(SpawnAttackFleets(this));
|
|
Dialogue("TUT_DEF2")
|
|
.checker(1, CheckDefeatEnemies());
|
|
Dialogue("TUT_FINAL")
|
|
.proceedWith(locale::CLOSE)
|
|
.onPass(GUIAction("Tutorial.Tutorial::ShowWiki"));
|
|
}
|
|
|
|
bool initialized = false;
|
|
void tick(double time) {
|
|
if(!initialized && !isLoadedSave) {
|
|
initialized = true;
|
|
postInit();
|
|
}
|
|
|
|
//Make sure there's always a spy in the stack
|
|
{
|
|
Lock lck(influenceLock);
|
|
auto@ spyType = getInfluenceCardType("Spy");
|
|
bool found = false;
|
|
for(uint i = 1, cnt = cardStack.length; i < cnt; ++i) {
|
|
if(cardStack[i].type is spyType) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!found && (deck.length == 0 || deck.last.type !is spyType)) {
|
|
StackInfluenceCard card;
|
|
card.id = nextStackId++;
|
|
spyType.generate(card);
|
|
@card.targets.fill("target").emp = enemyEmp;
|
|
|
|
deck.insertLast(card);
|
|
}
|
|
}
|
|
}
|
|
|
|
void save(SaveFile& file) {
|
|
file << enemyEmp;
|
|
file << spacewood;
|
|
file << ownsSpacewood;
|
|
saveDialoguePosition(file);
|
|
}
|
|
|
|
void load(SaveFile& file) {
|
|
file >> enemyEmp;
|
|
file >> spacewood;
|
|
file >> ownsSpacewood;
|
|
@enemyEmp = getEmpire(1);
|
|
@lihls = getSystem(1);
|
|
@yingmow = getSystem(3);
|
|
|
|
initDialogue();
|
|
loadDialoguePosition(file);
|
|
}
|
|
#section all
|
|
};
|
|
|
|
#section server
|
|
from orders import OrderType;
|
|
import planets.PlanetSurface;
|
|
import research;
|
|
import constructible;
|
|
import statuses;
|
|
import influence;
|
|
import influence_global;
|
|
|
|
class GainSpacewood : DialogueAction {
|
|
Tutorial@ tut;
|
|
GainSpacewood(Tutorial@ tut) { @this.tut = tut; }
|
|
void call() {
|
|
@tut.spacewood.owner = playerEmpire;
|
|
tut.spacewood.addPopulation(3.0);
|
|
tut.ownsSpacewood = true;
|
|
@playerEmpire.Homeworld = tut.spacewood;
|
|
}
|
|
}
|
|
|
|
class GainDefenseGen : DialogueAction {
|
|
Tutorial@ tut;
|
|
GainDefenseGen(Tutorial@ tut) { @this.tut = tut; }
|
|
void call() {
|
|
tut.spacewood.modResource(TR_Defense, +10);
|
|
}
|
|
}
|
|
|
|
class SpawnAttackFleets : DialogueAction {
|
|
Tutorial@ tut;
|
|
SpawnAttackFleets(Tutorial@ tut) { @this.tut = tut; }
|
|
void call() {
|
|
for(uint i = 0; i < 3; ++i) {
|
|
vec3d pos = tut.yingmow.position;
|
|
vec2d offset = random2d(tut.yingmow.radius - 150.0);
|
|
pos.x += offset.x;
|
|
pos.z += offset.y;
|
|
|
|
tut.spawnEnemyFleet(pos, "Dreadnaught", 5, aggro=true);
|
|
}
|
|
}
|
|
};
|
|
|
|
class GainResearchRate : DialogueAction {
|
|
void call() {
|
|
playerEmpire.generatePoints(900);
|
|
playerEmpire.modResearchRate(+2.0);
|
|
}
|
|
};
|
|
|
|
class GainEnergy : DialogueAction {
|
|
void call() {
|
|
playerEmpire.modEnergyStored(+500);
|
|
}
|
|
};
|
|
|
|
class ShowSpySystem : DialogueAction {
|
|
void call() {
|
|
getSystem(3).object.grantVision(playerEmpire);
|
|
}
|
|
};
|
|
|
|
class EnemyPlayRhetoric : DialogueAction {
|
|
void call() {
|
|
Empire@ enemy = getEmpire(1);
|
|
auto@ votes = getActiveInfluenceVotes();
|
|
InfluenceVoteStub@ stub;
|
|
for(uint i = 0, cnt = votes.length; i < cnt; ++i) {
|
|
if(votes[i].type.ident == "AnnexSystem")
|
|
@stub = votes[i];
|
|
}
|
|
if(stub is null)
|
|
return;
|
|
Lock lock(influenceLock);
|
|
auto@ type = getInfluenceCardType("Rhetoric");
|
|
InfluenceCard@ card = type.create();
|
|
int id = cast<InfluenceStore>(enemy.InfluenceManager).addCard(enemy, card);
|
|
Targets targets = card.targets;
|
|
targets.fill("VoteSide").side = false;
|
|
enemy.modInfluence(+100);
|
|
playInfluenceCard_server(enemy, id, targets, stub.id);
|
|
}
|
|
};
|
|
|
|
class CheckFleetSelect : ObjectiveCheck {
|
|
bool check() {
|
|
return playerEmpire.fleets[0].selected;
|
|
}
|
|
};
|
|
|
|
class CheckFleetAttack : ObjectiveCheck {
|
|
bool check() {
|
|
//Either the player issued the attack order, or has already destroyed everything in the system
|
|
return playerEmpire.fleets[0].hasOrder(OT_Attack) || (getSystem(0).object.BasicVisionMask & getEmpire(1).mask == 0);
|
|
}
|
|
};
|
|
|
|
class CheckDestroyGate : ObjectiveCheck {
|
|
bool check() {
|
|
return !getEmpire(1).hasStargates() || getSystem(0).object.BasicVisionMask & getEmpire(1).mask == 0;
|
|
}
|
|
};
|
|
|
|
class CheckSystemArrive : ObjectiveCheck {
|
|
bool check() {
|
|
return getSystem(1).object.BasicVisionMask & playerEmpire.mask != 0;
|
|
}
|
|
};
|
|
|
|
class CheckColonizeNeeds : ObjectiveCheck {
|
|
bool check() {
|
|
bool hasLevel1 = false, hasFood = false;
|
|
|
|
for(uint i = 0, cnt = systemCount; i < cnt; ++i) {
|
|
Region@ reg = getSystem(i).object;
|
|
if(reg.BasicVisionMask & playerEmpire.mask == 0)
|
|
continue;
|
|
for(uint j = 0, jcnt = reg.planetCount; j < jcnt; ++j) {
|
|
auto@ pl = reg.planets[j];
|
|
if(pl.owner is playerEmpire && pl.population >= 1.0) {
|
|
auto@ r = getResource(pl.primaryResourceType);
|
|
if(r.level == 1)
|
|
hasLevel1 = true;
|
|
else if(r.cls !is null && r.cls is getResourceClass("Food"))
|
|
hasFood = true;
|
|
}
|
|
}
|
|
|
|
if(hasLevel1 && hasFood)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckColonizeFood : ObjectiveCheck {
|
|
bool check() {
|
|
bool hasFood = false;
|
|
|
|
for(uint i = 0, cnt = systemCount; i < cnt; ++i) {
|
|
Region@ reg = getSystem(i).object;
|
|
if(reg.BasicVisionMask & playerEmpire.mask == 0)
|
|
continue;
|
|
for(uint j = 0, jcnt = reg.planetCount; j < jcnt; ++j) {
|
|
auto@ pl = reg.planets[j];
|
|
if(pl is playerEmpire.Homeworld)
|
|
continue;
|
|
if(pl.owner is playerEmpire && pl.population >= 1.0) {
|
|
auto@ r = getResource(pl.primaryResourceType);
|
|
if(r.cls !is null && r.cls is getResourceClass("Food"))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckColonizeTier1 : ObjectiveCheck {
|
|
bool check() {
|
|
bool hasFood = false;
|
|
|
|
for(uint i = 0, cnt = systemCount; i < cnt; ++i) {
|
|
Region@ reg = getSystem(i).object;
|
|
if(reg.BasicVisionMask & playerEmpire.mask == 0)
|
|
continue;
|
|
for(uint j = 0, jcnt = reg.planetCount; j < jcnt; ++j) {
|
|
auto@ pl = reg.planets[j];
|
|
if(pl.owner is playerEmpire && pl.population >= 1.0) {
|
|
auto@ r = getResource(pl.primaryResourceType);
|
|
if(r.level == 1)
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckExportFood : ObjectiveCheck {
|
|
bool check() {
|
|
bool hasFood = false;
|
|
|
|
for(uint i = 0, cnt = systemCount; i < cnt; ++i) {
|
|
Region@ reg = getSystem(i).object;
|
|
if(reg.BasicVisionMask & playerEmpire.mask == 0)
|
|
continue;
|
|
for(uint j = 0, jcnt = reg.planetCount; j < jcnt; ++j) {
|
|
auto@ pl = reg.planets[j];
|
|
if(pl is playerEmpire.Homeworld)
|
|
continue;
|
|
if(pl.owner is playerEmpire && pl.population >= 1.0) {
|
|
auto@ r = getResource(pl.primaryResourceType);
|
|
if(r.cls !is null && r.cls is getResourceClass("Food")) {
|
|
if(pl.nativeResourceDestination[0] is playerEmpire.Homeworld)
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckExportTier1 : ObjectiveCheck {
|
|
bool check() {
|
|
bool hasFood = false;
|
|
|
|
for(uint i = 0, cnt = systemCount; i < cnt; ++i) {
|
|
Region@ reg = getSystem(i).object;
|
|
if(reg.BasicVisionMask & playerEmpire.mask == 0)
|
|
continue;
|
|
for(uint j = 0, jcnt = reg.planetCount; j < jcnt; ++j) {
|
|
auto@ pl = reg.planets[j];
|
|
if(pl.owner is playerEmpire && pl.population >= 1.0) {
|
|
auto@ r = getResource(pl.primaryResourceType);
|
|
if(r.level == 1) {
|
|
if(pl.nativeResourceDestination[0] is playerEmpire.Homeworld)
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckLevel1 : ObjectiveCheck {
|
|
bool check() {
|
|
Region@ reg = getSystem(1).object;
|
|
Planet@ pl = reg.planets[1];
|
|
if(pl.owner is playerEmpire && pl.resourceLevel == 1)
|
|
return true;
|
|
@reg = getSystem(3).object;
|
|
@pl = reg.planets[3];
|
|
if(pl.owner is playerEmpire && pl.resourceLevel == 1)
|
|
return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckLevel2 : ObjectiveCheck {
|
|
bool check() {
|
|
Region@ reg = getSystem(1).object;
|
|
Planet@ pl = reg.planets[0];
|
|
if(pl.owner is playerEmpire && pl.resourceLevel == 2)
|
|
return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckBuildScout : ObjectiveCheck {
|
|
bool check() {
|
|
Planet@ hw = playerEmpire.Homeworld;
|
|
if(hw.constructionCount != 0 && hw.constructionName[0] == "Scout")
|
|
return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckReinforceFleet : ObjectiveCheck {
|
|
bool check() {
|
|
return playerEmpire.fleets[0].hasOrderedSupports;
|
|
}
|
|
};
|
|
|
|
class CheckScoutFinished : ObjectiveCheck {
|
|
bool check() {
|
|
for(uint i = 0, cnt = playerEmpire.fleetCount; i < cnt; ++i) {
|
|
Ship@ ship = cast<Ship>(playerEmpire.fleets[i]);
|
|
if(ship !is null && ship.blueprint.design.name == "Scout")
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckScouted : ObjectiveCheck {
|
|
bool check() {
|
|
return getSystem(2).object.BasicVisionMask & playerEmpire.mask != 0;
|
|
}
|
|
};
|
|
|
|
class CheckFleetMoved : ObjectiveCheck {
|
|
bool check() {
|
|
return playerEmpire.fleets[0].region is getSystem(2).object;
|
|
}
|
|
};
|
|
|
|
class CheckDefenseKilled : ObjectiveCheck {
|
|
bool check() {
|
|
auto@ pl = getSystem(2).object.planets[3];
|
|
return pl.supportCount == 0 || pl.owner is playerEmpire;
|
|
}
|
|
};
|
|
|
|
class CheckCaptured : ObjectiveCheck {
|
|
bool check() {
|
|
return getSystem(2).object.planets[3].owner is playerEmpire;
|
|
}
|
|
};
|
|
|
|
class CheckPhasiteImport : ObjectiveCheck {
|
|
bool check() {
|
|
return getSystem(2).object.planets[3].nativeResourceDestination[0] is playerEmpire.Homeworld;
|
|
}
|
|
};
|
|
|
|
class CheckResearchComplex : ObjectiveCheck {
|
|
bool check() {
|
|
Planet@ hw = playerEmpire.Homeworld;
|
|
|
|
PlanetSurface surface;
|
|
receive(hw.getPlanetSurface(), surface);
|
|
for(uint i = 0, cnt = surface.buildings.length; i < cnt; ++i) {
|
|
if(surface.buildings[i].type.ident == "ResearchComplex")
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckResearchArmoring : ObjectiveCheck {
|
|
TechnologyNode node;
|
|
bool check() {
|
|
receive(playerEmpire.getTechnologyNode(vec2i(-1,1)), node);
|
|
return node.unlocked;
|
|
}
|
|
};
|
|
|
|
class CheckResearchBulkhead : ObjectiveCheck {
|
|
TechnologyNode node;
|
|
bool check() {
|
|
receive(playerEmpire.getTechnologyNode(vec2i(0,2)), node);
|
|
return node.unlocked;
|
|
}
|
|
};
|
|
|
|
class CheckBuildCarrier : ObjectiveCheck {
|
|
bool check() {
|
|
Planet@ hw = playerEmpire.Homeworld;
|
|
if(hw.constructionCount != 0 && hw.constructionName[0] == "Heavy Carrier")
|
|
return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckAddBeamships : ObjectiveCheck {
|
|
bool check() {
|
|
Planet@ hw = playerEmpire.Homeworld;
|
|
if(hw.constructionCount == 0 || hw.constructionName[0] != "Heavy Carrier")
|
|
return true;
|
|
Constructible cons;
|
|
receive(hw.getConstructionQueue(1), cons);
|
|
for(uint i = 0, cnt = cons.groups.length; i < cnt; ++i) {
|
|
if(cons.groups[i].dsg.name == "Beamship")
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckAddSupports : ObjectiveCheck {
|
|
bool check() {
|
|
Planet@ hw = playerEmpire.Homeworld;
|
|
if(hw.constructionCount == 0 || hw.constructionName[0] != "Heavy Carrier")
|
|
return true;
|
|
Constructible cons;
|
|
receive(hw.getConstructionQueue(1), cons);
|
|
for(uint i = 0, cnt = cons.groups.length; i < cnt; ++i) {
|
|
if(cons.groups[i].dsg.name != "Beamship")
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckFinishCarrier : ObjectiveCheck {
|
|
bool check() {
|
|
for(uint i = 1, cnt = playerEmpire.fleetCount; i < cnt; ++i) {
|
|
Ship@ ship = cast<Ship>(playerEmpire.fleets[i]);
|
|
if(ship !is null && ship.blueprint.design.name == "Heavy Carrier")
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckArtifactEquip : ObjectiveCheck {
|
|
bool check() {
|
|
auto@ status = getStatusType("PowerCell");
|
|
for(uint i = 0, cnt = playerEmpire.fleetCount; i < cnt; ++i) {
|
|
Ship@ ship = cast<Ship>(playerEmpire.fleets[i]);
|
|
if(ship is null)
|
|
continue;
|
|
if(ship.hasStatuses && ship.hasStatusEffect(status.id))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckBuySpy : ObjectiveCheck {
|
|
bool check() {
|
|
array<InfluenceCard> cards;
|
|
cards.syncFrom(playerEmpire.getInfluenceCards());
|
|
for(uint i = 0, cnt = cards.length; i < cnt; ++i) {
|
|
if(cards[i].type.ident == "Spy")
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckActivateSpy : ObjectiveCheck {
|
|
bool check() {
|
|
auto@ effects = getActiveInfluenceEffects();
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
if(effects[i].type.ident == "Spy")
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckStartVote : ObjectiveCheck {
|
|
bool check() {
|
|
if(getEmpire(1).TotalPlanets.value == 0)
|
|
return true;
|
|
|
|
auto@ votes = getActiveInfluenceVotes();
|
|
for(uint i = 0, cnt = votes.length; i < cnt; ++i) {
|
|
if(votes[i].type.ident == "AnnexSystem")
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckPlayNegotiate : ObjectiveCheck {
|
|
bool check() {
|
|
auto@ votes = getActiveInfluenceVotes();
|
|
InfluenceVoteStub@ stub;
|
|
for(uint i = 0, cnt = votes.length; i < cnt; ++i) {
|
|
if(votes[i].type.ident == "AnnexSystem")
|
|
@stub = votes[i];
|
|
}
|
|
if(stub is null)
|
|
return true;
|
|
Lock lock(influenceLock);
|
|
auto@ vote = getInfluenceVoteByID(stub.id);
|
|
if(vote.currentTime < -120.0)
|
|
vote.currentTime = -120.0;
|
|
for(uint i = 0, cnt = vote.events.length; i < cnt; ++i) {
|
|
auto@ evt = vote.events[i];
|
|
if(evt.cardEvent !is null && evt.cardEvent.card.type.ident == "Negotiate")
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckWinVote : ObjectiveCheck {
|
|
double startTime = 0.0;
|
|
|
|
bool start() {
|
|
startTime = gameTime;
|
|
return true;
|
|
}
|
|
|
|
bool check() {
|
|
auto@ votes = getActiveInfluenceVotes();
|
|
InfluenceVoteStub@ stub;
|
|
for(uint i = 0, cnt = votes.length; i < cnt; ++i) {
|
|
if(votes[i].type.ident == "AnnexSystem")
|
|
@stub = votes[i];
|
|
}
|
|
if(stub is null)
|
|
return true;
|
|
Lock lock(influenceLock);
|
|
auto@ vote = getInfluenceVoteByID(stub.id);
|
|
if(vote.currentTime < -120.0)
|
|
vote.currentTime = -120.0;
|
|
if(gameTime > startTime + 30.0) {
|
|
startTime = INFINITY;
|
|
Empire@ enemy = getEmpire(1);
|
|
auto@ type = getInfluenceCardType("Negotiate");
|
|
InfluenceCard@ card = type.create();
|
|
int id = cast<InfluenceStore>(enemy.InfluenceManager).addCard(enemy, card);
|
|
Targets targets = card.targets;
|
|
targets.fill("VoteSide").side = false;
|
|
playInfluenceCard_server(enemy, id, targets, stub.id);
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckOrbitalPlaced : ObjectiveCheck {
|
|
bool check() {
|
|
Planet@ hw = playerEmpire.Homeworld;
|
|
if(hw.constructionCount != 0 && hw.constructionName[0] == "Defense Platform")
|
|
return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckDefenseProject : ObjectiveCheck {
|
|
bool check() {
|
|
return playerEmpire.isDefending(getSystem(3).object);
|
|
}
|
|
};
|
|
|
|
class CheckMoveFleet : ObjectiveCheck {
|
|
bool check() {
|
|
bool moved = false, created = false;
|
|
for(uint i = 1, cnt = playerEmpire.fleetCount; i < cnt; ++i) {
|
|
Ship@ ship = cast<Ship>(playerEmpire.fleets[i]);
|
|
if(ship is null)
|
|
continue;
|
|
if(ship.blueprint.design.name == "Defense Platform") {
|
|
created = true;
|
|
}
|
|
else if(ship.region is getSystem(3).object)
|
|
moved = true;
|
|
}
|
|
return moved && created;
|
|
}
|
|
};
|
|
|
|
class CheckDefeatEnemies : ObjectiveCheck {
|
|
double startTime = 0.0;
|
|
|
|
bool start() {
|
|
startTime = gameTime;
|
|
return true;
|
|
}
|
|
|
|
bool check() {
|
|
if(gameTime < startTime + 5.0)
|
|
return false;
|
|
return getEmpire(1).fleetCount == 0;
|
|
}
|
|
};
|
|
|
|
#section gui
|
|
from tabs.tabbar import tabBar, globalBar, closeTab, tabs, newTab, ActiveTab;
|
|
from tabs.GlobalBar import GlobalBar;
|
|
from tabs.GalaxyTab import GalaxyTab;
|
|
from tabs.PlanetsTab import createPlanetsTab;
|
|
from tabs.ResearchTab import createResearchTab, ResearchTab;
|
|
from tabs.DiplomacyTab import createDiplomacyTab;
|
|
from community.Home import createCommunityHome;
|
|
from tabs.DesignOverviewTab import createDesignOverviewTab;
|
|
from tabs.DesignEditorTab import DesignEditor;
|
|
from navigation.SmartCamera import CAM_PANNED, CAM_ZOOMED, CAM_ROTATED;
|
|
from overlays.PlanetInfoBar import PlanetInfoBar;
|
|
from overlays.Supports import SupportOverlay;
|
|
from overlays.Construction import OrbitalTarget;
|
|
from targeting.targeting import mode;
|
|
from targeting.ObjectTarget import AbilityTargetObject, ObjectMode;
|
|
from targeting.PointTarget import PointTargetMode;
|
|
from overlays.TimeDisplay import ShowTimeDisplay;
|
|
|
|
class HideGUI : DialogueAction {
|
|
void call() {
|
|
//Global bar
|
|
auto@ gbar = cast<GlobalBar>(globalBar);
|
|
gbar.budget.visible = false;
|
|
gbar.energy.visible = false;
|
|
gbar.defense.visible = false;
|
|
gbar.ftl.visible = false;
|
|
gbar.influence.visible = false;
|
|
gbar.research.visible = false;
|
|
|
|
//Tab bar
|
|
tabBar.goButton.visible = false;
|
|
tabBar.newButton.visible = false;
|
|
tabBar.homeButton.visible = false;
|
|
|
|
for(uint i = 1, cnt = tabs.length; i < cnt; ++i)
|
|
closeTab(tabs[1]);
|
|
tabs[0].locked = true;
|
|
|
|
//Quickbar
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
gtab.quickbar.visible = false;
|
|
|
|
//Hide the timer
|
|
ShowTimeDisplay = false;
|
|
}
|
|
};
|
|
|
|
class ZoomFleet : DialogueAction {
|
|
void call() {
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
gtab.zoomTo(playerEmpire.fleets[0]);
|
|
}
|
|
};
|
|
|
|
class ShowTime : DialogueAction {
|
|
void call() {
|
|
ShowTimeDisplay = true;
|
|
}
|
|
};
|
|
|
|
class ShowFTL : DialogueAction {
|
|
void call() {
|
|
auto@ gbar = cast<GlobalBar>(globalBar);
|
|
gbar.ftl.visible = true;
|
|
}
|
|
};
|
|
|
|
class ShowPlanets : DialogueAction {
|
|
void call() {
|
|
//Show planets tab
|
|
newTab(createPlanetsTab());
|
|
tabs[1].locked = true;
|
|
}
|
|
};
|
|
|
|
class ShowMoney : DialogueAction {
|
|
void call() {
|
|
auto@ gbar = cast<GlobalBar>(globalBar);
|
|
gbar.budget.visible = true;
|
|
}
|
|
};
|
|
|
|
class ShowQuickbars : DialogueAction {
|
|
void call() {
|
|
//Show planets quickbars
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
gtab.quickbar.visible = true;
|
|
gtab.quickbar.modes[0].closed = true;
|
|
gtab.quickbar.modes[11].closed = true;
|
|
gtab.quickbar.quickButton.visible = false;
|
|
}
|
|
};
|
|
|
|
class ShowResearch : DialogueAction {
|
|
void call() {
|
|
auto@ gbar = cast<GlobalBar>(globalBar);
|
|
gbar.research.visible = true;
|
|
|
|
newTab(createResearchTab());
|
|
tabs[2].locked = true;
|
|
}
|
|
};
|
|
|
|
class ShowDesigns : DialogueAction {
|
|
void call() {
|
|
newTab(createDesignOverviewTab());
|
|
tabs[3].locked = true;
|
|
}
|
|
};
|
|
|
|
class ShowEnergy : DialogueAction {
|
|
void call() {
|
|
auto@ gbar = cast<GlobalBar>(globalBar);
|
|
gbar.energy.visible = true;
|
|
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
gtab.quickbar.modes[11].closed = false;
|
|
}
|
|
};
|
|
|
|
class ShowDefense : DialogueAction {
|
|
void call() {
|
|
auto@ gbar = cast<GlobalBar>(globalBar);
|
|
gbar.defense.visible = true;
|
|
}
|
|
};
|
|
|
|
class ShowInfluence : DialogueAction {
|
|
void call() {
|
|
auto@ gbar = cast<GlobalBar>(globalBar);
|
|
gbar.influence.visible = true;
|
|
}
|
|
};
|
|
|
|
class ShowInfluenceTab : DialogueAction {
|
|
void call() {
|
|
newTab(createDiplomacyTab());
|
|
tabs[4].locked = true;
|
|
}
|
|
};
|
|
|
|
class ShowTabStuff : DialogueAction {
|
|
void call() {
|
|
tabBar.goButton.visible = true;
|
|
tabBar.newButton.visible = true;
|
|
tabBar.homeButton.visible = true;
|
|
for(uint i = 0; i < 5; ++i)
|
|
tabs[i].locked = false;
|
|
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
gtab.quickbar.modes[0].closed = false;
|
|
gtab.quickbar.quickButton.visible = true;
|
|
}
|
|
};
|
|
|
|
class ShowWiki : DialogueAction {
|
|
void call() {
|
|
newTab(createCommunityHome());
|
|
}
|
|
};
|
|
|
|
class CheckPan : GuiObjectiveCheck {
|
|
bool start() {
|
|
CAM_PANNED = false;
|
|
return true;
|
|
}
|
|
|
|
bool check() {
|
|
return CAM_PANNED;
|
|
}
|
|
};
|
|
|
|
class CheckZoom : GuiObjectiveCheck {
|
|
bool start() {
|
|
CAM_ZOOMED = false;
|
|
return true;
|
|
}
|
|
|
|
bool check() {
|
|
return CAM_ZOOMED;
|
|
}
|
|
};
|
|
|
|
class CheckRotate : GuiObjectiveCheck {
|
|
bool start() {
|
|
CAM_ROTATED = false;
|
|
return true;
|
|
}
|
|
|
|
bool check() {
|
|
return CAM_ROTATED;
|
|
}
|
|
};
|
|
|
|
class CheckPlanetOverlay : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
if(gtab !is ActiveTab)
|
|
return false;
|
|
auto@ ibar = cast<PlanetInfoBar>(gtab.infoBar);
|
|
if(ibar is null)
|
|
return false;
|
|
if(ibar.overlay is null || !ibar.overlay.visible)
|
|
return false;
|
|
return ibar.overlay.obj is obj;
|
|
}
|
|
};
|
|
|
|
class CheckBuildingsList : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
if(gtab !is ActiveTab)
|
|
return false;
|
|
auto@ ibar = cast<PlanetInfoBar>(gtab.infoBar);
|
|
if(ibar is null)
|
|
return false;
|
|
if(ibar.overlay is null || !ibar.overlay.visible)
|
|
return false;
|
|
return ibar.overlay.construction.buildingsList.visible;
|
|
}
|
|
};
|
|
|
|
class CheckOrbitalsList : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
if(gtab !is ActiveTab)
|
|
return false;
|
|
auto@ ibar = cast<PlanetInfoBar>(gtab.infoBar);
|
|
if(ibar is null)
|
|
return false;
|
|
if(ibar.overlay is null || !ibar.overlay.visible)
|
|
return false;
|
|
return ibar.overlay.construction.orbitalsList.visible;
|
|
}
|
|
};
|
|
|
|
class CheckNoOverlay : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
if(gtab !is ActiveTab)
|
|
return false;
|
|
return gtab.infoBar is null || !gtab.infoBar.showingManage;
|
|
}
|
|
};
|
|
|
|
class CheckFleetOverlay : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
if(gtab !is ActiveTab)
|
|
return false;
|
|
auto@ overlay = cast<SupportOverlay>(gtab.overlay);
|
|
if(overlay is null || !overlay.visible)
|
|
return false;
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class CheckResearchTab : GuiObjectiveCheck {
|
|
bool check() {
|
|
return cast<ResearchTab>(ActiveTab) !is null;
|
|
}
|
|
};
|
|
|
|
class CheckDesignEdit : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ tab = cast<DesignEditor>(ActiveTab);
|
|
if(tab is null)
|
|
return false;
|
|
if(tab.originalDesign is null)
|
|
return false;
|
|
return tab.originalDesign.name == "Heavy Carrier";
|
|
}
|
|
};
|
|
|
|
class CheckDesignArmor : GuiObjectiveCheck {
|
|
uint armor = 0;
|
|
|
|
bool start() {
|
|
armor = 0;
|
|
auto@ dsg = playerEmpire.getDesign("Heavy Carrier");
|
|
for(uint i = 0, cnt = dsg.subsystemCount; i < cnt; ++i) {
|
|
auto@ sys = dsg.subsystems[i];
|
|
if(sys.type is subsystem::PlateArmor)
|
|
armor += sys.hexCount;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool check() {
|
|
auto@ tab = cast<DesignEditor>(ActiveTab);
|
|
if(tab is null)
|
|
return false;
|
|
if(tab.originalDesign is null)
|
|
return false;
|
|
if(tab.originalDesign.name != "Heavy Carrier")
|
|
return false;
|
|
|
|
uint curArmor = 0;
|
|
auto@ dsg = tab.design;
|
|
for(uint i = 0, cnt = dsg.subsystemCount; i < cnt; ++i) {
|
|
auto@ sys = dsg.subsystems[i];
|
|
if(sys.type is subsystem::PlateArmor)
|
|
curArmor += sys.hexCount;
|
|
}
|
|
|
|
return curArmor >= armor+3;
|
|
}
|
|
};
|
|
|
|
class CheckDesignBulkhead : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ tab = cast<DesignEditor>(ActiveTab);
|
|
if(tab is null)
|
|
return false;
|
|
if(tab.originalDesign is null)
|
|
return false;
|
|
if(tab.originalDesign.name != "Heavy Carrier")
|
|
return false;
|
|
|
|
auto@ dsg = tab.design;
|
|
for(uint i = 0, cnt = dsg.subsystemCount; i < cnt; ++i) {
|
|
auto@ sys = dsg.subsystems[i];
|
|
for(uint n = 0, ncnt = sys.hexCount; n < ncnt; ++n) {
|
|
if(sys.module(n).id == "Bulkhead")
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class CheckDesignSaved : GuiObjectiveCheck {
|
|
bool check() {
|
|
return playerEmpire.getDesign("Heavy Carrier").revision > 1;
|
|
}
|
|
};
|
|
|
|
class CheckArtifactTarget : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ tg = cast<ObjectMode>(mode);
|
|
if(tg is null)
|
|
return false;
|
|
auto@ to = cast<AbilityTargetObject>(tg.targ);
|
|
if(to is null)
|
|
return false;
|
|
if(!to.abl.obj.isArtifact)
|
|
return false;
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class CheckTargetDefPlat : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ tg = cast<PointTargetMode>(mode);
|
|
if(tg is null)
|
|
return false;
|
|
auto@ to = cast<OrbitalTarget>(tg.targ);
|
|
if(to is null)
|
|
return false;
|
|
if(to.dsg is null)
|
|
return false;
|
|
return to.dsg.name == "Defense Platform";
|
|
}
|
|
};
|
|
|
|
class CheckViewSpy : GuiObjectiveCheck {
|
|
bool check() {
|
|
auto@ gtab = cast<GalaxyTab>(tabs[0]);
|
|
return gtab.title == "Yingmow";
|
|
}
|
|
};
|
|
|
|
#section all
|