/* * Method: ExportToLua * * Export of generated system for personal interest, customisation, etc * * Availability: * * alpha 33 * * Status: * * experimental */ static int l_starsystem_export_to_lua(lua_State *l) { PROFILE_SCOPED() LUA_DEBUG_START(l); StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); static const std::string EXPORTED_SYSTEMS_DIR_NAME("exported_systems"); if (!FileSystem::userFiles.MakeDirectory(EXPORTED_SYSTEMS_DIR_NAME)) { throw CouldNotOpenFileException(); } // construct the filename with folder and extension try { const std::string filename(EXPORTED_SYSTEMS_DIR_NAME + "/" + FileSystem::SanitiseFileName(s->GetName()) + ".lua"); const std::string finalPath = FileSystem::NormalisePath( FileSystem::JoinPathBelow(FileSystem::GetUserDir(), filename)); s->ExportToLua(finalPath.c_str()); } catch (std::invalid_argument &) { return luaL_error(l, "could not export system -- name forms an invalid path"); } LUA_DEBUG_END(l, 0); return 0; }
/* * Attribute: name * * The name of the system. This is usually the same as the name of the primary * star. * * Availability: * * alpha 10 * * Status: * * stable */ static int l_starsystem_attr_name(lua_State *l) { PROFILE_SCOPED() StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); lua_pushstring(l, s->GetName().c_str()); return 1; }
//Sends a fleet back to it's home planet void TaeTurn::sendHome(uint32_t fleet) { Game* game = Game::getGame(); ObjectManager* obm = game->getObjectManager(); ObjectTypeManager* obtm = game->getObjectTypeManager(); PlayerManager::Ptr pm = game->getPlayerManager(); IGObject::Ptr fleetobj = obm->getObject(fleet); //Check to make sure it is really a fleet if(fleetobj->getType() != obtm->getObjectTypeByName("Fleet")) { return; } //Get all the required objects Fleet* f = (Fleet*) fleetobj->getObjectBehaviour(); Player::Ptr p = pm->getPlayer(f->getOwner()); IGObject::Ptr sys = obm->getObject(fleetobj->getParent()); StarSystem* sysData = (StarSystem*) sys->getObjectBehaviour(); //Remove fleet from system sysData->setRegion(0); fleetobj->removeFromParent(); //Find it's home planet std::set<uint32_t> objects = obm->getAllIds(); std::set<uint32_t>::iterator itcurr; for(itcurr = objects.begin(); itcurr != objects.end(); ++itcurr) { IGObject::Ptr ob = obm->getObject(*itcurr); if(ob->getName().compare(string(p->getName() + "'s Home Planet")) == 0) { Planet* p = (Planet*) ob->getObjectBehaviour(); f->setPosition(p->getPosition()); fleetobj->addToParent(ob->getID()); } } }
/* * Attribute: path * * The <SystemPath> to the system * * Availability: * * alpha 10 * * Status: * * stable */ static int l_starsystem_attr_path(lua_State *l) { StarSystem *s = LuaStarSystem::CheckFromLua(1); SystemPath path = s->GetPath(); LuaSystemPath::PushToLua(&path); return 1; }
/* * Attribute: lawlessness * * The lawlessness value for the system, 0 for peaceful, 1 for raging * hordes of pirates * * Availability: * * alpha 10 * * Status: * * experimental */ static int l_starsystem_attr_lawlessness(lua_State *l) { PROFILE_SCOPED() StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); lua_pushnumber(l, s->GetSysPolit().lawlessness.ToDouble()); return 1; }
/* * Attribute: population * * The population of this system, in billions of people * * Availability: * * alpha 10 * * Status: * * experimental */ static int l_starsystem_attr_population(lua_State *l) { PROFILE_SCOPED() StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); lua_pushnumber(l, s->GetTotalPop().ToDouble()); return 1; }
static int l_starsystem_attr_explored(lua_State *l) { PROFILE_SCOPED() StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); lua_pushboolean(l, !s->GetUnexplored()); return 1; }
/* * Attribute: path * * The <SystemPath> to the system * * Availability: * * alpha 10 * * Status: * * stable */ static int l_starsystem_attr_path(lua_State *l) { PROFILE_SCOPED() StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); SystemPath path = s->GetPath(); LuaObject<SystemPath>::PushToLua(&path); return 1; }
/* * Method: GetStarSystem * * Get a <StarSystem> object for the system that this path points to * * > system = path:GetStarSystem() * * Return: * * system - the <StarSystem> * * Availability: * * alpha 10 * * Status: * * stable */ static int l_sbodypath_get_star_system(lua_State *l) { SystemPath *path = LuaSystemPath::GetFromLua(1); StarSystem *s = StarSystem::GetCached(path); LuaStarSystem::PushToLua(s); s->Release(); return 1; }
/* * Method: GetSystemBody * * Get a <SystemBody> object for the body that this path points to * * > body = path:GetSystemBody() * * Return: * * body - the <SystemBody> * * Availability: * * alpha 10 * * Status: * * stable */ static int l_sbodypath_get_system_body(lua_State *l) { SystemPath *path = LuaSystemPath::GetFromLua(1); StarSystem *s = StarSystem::GetCached(path); SBody *sbody = s->GetBodyByPath(path); LuaSBody::PushToLua(sbody); s->Release(); return 1; }
StarSystem* Universe::getStarSystem( string name ) { vector< StarSystem* >::iterator iter; for (iter = star_system.begin(); iter != star_system.end(); iter++) { StarSystem *ss = *iter; if (ss->getName() == name) return ss; } return NULL; }
/* * Attribute: faction * * The faction that controls this system * * Availability: * * alpha 28 * * Status: * * experimental */ static int l_starsystem_attr_faction(lua_State *l) { StarSystem *s = LuaStarSystem::CheckFromLua(1); if (s->GetFaction()->IsValid()) { LuaFaction::PushToLua(s->GetFaction()); return 1; } else { return 0; } }
/* * Attribute: faction * * The <Faction> that controls this system * * Availability: * * alpha 28 * * Status: * * experimental */ static int l_starsystem_attr_faction(lua_State *l) { PROFILE_SCOPED() StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); if (s->GetFaction()->IsValid()) { LuaObject<Faction>::PushToLua(s->GetFaction()); return 1; } else { return 0; } }
/* * Attribute: faction * * The <Faction> that controls this system * * Availability: * * alpha 28 * * Status: * * experimental */ static int l_starsystem_attr_faction(lua_State *l) { PROFILE_SCOPED() StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); if (s->GetFaction()->IsValid()) { LuaObject<Faction>::PushToLua(const_cast<Faction*>(s->GetFaction())); // XXX const-correctness violation return 1; } else { return 0; } }
/* * Method: IsCommodityLegal * * Determine if a given cargo item is legal for trade in this system * * > is_legal = system:IsCommodityLegal(cargo) * * Parameters: * * cargo - the wanted commodity (for instance, Equipment.cargo.hydrogen) * * Return: * * is_legal - true if the commodity is legal, otherwise false * * Availability: * * alpha 10 * * Status: * * experimental */ static int l_starsystem_is_commodity_legal(lua_State *l) { PROFILE_SCOPED() StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); // XXX: Don't use the l10n_key hack, this is just UGLY!! luaL_checktype(l, 2, LUA_TTABLE); LuaTable(l, 2).PushValueToStack("l10n_key"); GalacticEconomy::Commodity e = static_cast<GalacticEconomy::Commodity>( LuaConstants::GetConstantFromArg(l, "CommodityType", -1)); lua_pushboolean(l, s->IsCommodityLegal(e)); return 1; }
StarSystem* Galaxy::FindSystemByRegion(const char* rgn_name) { ListIter<StarSystem> iter = systems; while (++iter) { StarSystem* sys = iter.value(); if (sys->FindRegion(rgn_name)) return sys; } return 0; }
void Mission::findNextEnemyTarget( Unit *my_unit ) { StarSystem *ssystem = _Universe->scriptStarSystem(); un_iter uiter( ssystem->getUnitList().createIterator() ); Unit *unit; Unit *target_unit = NULL; for (; (unit = *uiter); ++uiter) if (my_unit->getRelation( unit ) < 0.0) { target_unit = *uiter; break; } if (target_unit) my_unit->Target( target_unit ); }
Ship::HyperjumpStatus Ship::InitiateHyperjumpTo(const SystemPath &dest, int warmup_time, double duration, LuaRef checks) { if (!dest.HasValidSystem() || GetFlightState() != FLYING || warmup_time < 1) return HYPERJUMP_SAFETY_LOCKOUT; StarSystem *s = Pi::game->GetSpace()->GetStarSystem().Get(); if (s && s->GetPath().IsSameSystem(dest)) return HYPERJUMP_CURRENT_SYSTEM; m_hyperspace.dest = dest; m_hyperspace.countdown = warmup_time; m_hyperspace.now = false; m_hyperspace.duration = duration; m_hyperspace.checks = checks; return Ship::HYPERJUMP_OK; }
/* * Method: Explore * * Set the star system to be explored by the Player. * * > system:Explore(time) * * Parameters: * * time - optional, the game time at which the system was explored. * Defaults to current game time. * * Availability: * * October 2014 * * Status: * * experimental */ static int l_starsystem_explore(lua_State *l) { LUA_DEBUG_START(l); StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); double time; if (lua_isnumber(l, 2)) time = luaL_checknumber(l, 2); else time = Pi::game->GetTime(); s->ExploreSystem(time); LUA_DEBUG_END(l,0); return 0; }
void Colonize::inputFrame(InputFrame::Ptr f, uint32_t playerid) { FleetOrder::inputFrame(f, playerid); Game *game = Game::getGame(); ObjectManager *obm = game->getObjectManager(); ObjectTypeManager *obtm = game->getObjectTypeManager(); IGObject::Ptr starSysObj = obm->getObject(starSys->getObjectId()); StarSystem* starSysData = (StarSystem*) starSysObj->getObjectBehaviour(); // Check to see if it is a legal system to colonize if(starSysObj->getType() == obtm->getObjectTypeByName("Star System") && !starSysData->canBeColonized(isMining)) { starSys->setObjectId(0); Logger::getLogger()->debug("Player tried to colonize a system which cannot be colonized."); } }
void Galaxy::randomize(size_t numSystems) { for (size_t i = 0; i < numSystems; i++) { StarSystem *starSystem = new StarSystem(); if (starSystem == NULL) { printf("Galaxy::Galaxy(): out of memory\n"); return; } starSystem->mHandle = mNextHandle++; starSystem->mPosition.x = r_num(0.0, GALACTIC_WIDTH); starSystem->mPosition.y = r_num(0.0, GALACTIC_HEIGHT); starSystem->randomize(); mNextHandle += starSystem->mPlanets.size(); mStarSystems.push_back(starSystem); } }
/* * Method: GetCommodityBasePriceAlterations * * Get the price alterations for cargo items bought and sold in this system * * > alterations = system:GetCommodityBasePriceAlterations() * * Return: * * alterations - a table. The keys are <Constants.EquipType> strings for * each cargo. The values are numbers that indicate the * percentage change to each cargo base price. Loosely, * positive values make the commodity more expensive, * indicating it is in demand, while negative values make the * commodity cheaper, indicating a surplus. * * Availability: * * alpha 10 * * Status: * * experimental */ static int l_starsystem_get_commodity_base_price_alterations(lua_State *l) { LUA_DEBUG_START(l); StarSystem *s = LuaStarSystem::CheckFromLua(1); lua_newtable(l); for (int e = Equip::FIRST_COMMODITY; e <= Equip::LAST_COMMODITY; e++) { lua_pushstring(l, EnumStrings::GetString("EquipType", e)); lua_pushnumber(l, s->GetCommodityBasePriceModPercent(e)); lua_rawset(l, -3); } LUA_DEBUG_END(l, 1); return 1; }
Ship::HyperjumpStatus Ship::GetHyperspaceDetails(const SystemPath &dest, int &outFuelRequired, double &outDurationSecs) { assert(dest.HasValidSystem()); outFuelRequired = 0; outDurationSecs = 0.0; UpdateStats(); if (GetFlightState() == HYPERSPACE) return HYPERJUMP_DRIVE_ACTIVE; Equip::Type t = m_equipment.Get(Equip::SLOT_ENGINE); Equip::Type fuelType = GetHyperdriveFuelType(); int hyperclass = Equip::types[t].pval; int fuel = m_equipment.Count(Equip::SLOT_CARGO, fuelType); if (hyperclass == 0) return HYPERJUMP_NO_DRIVE; StarSystem *s = Pi::game->GetSpace()->GetStarSystem().Get(); if (s && s->GetPath().IsSameSystem(dest)) return HYPERJUMP_CURRENT_SYSTEM; float dist = distance_to_system(dest); outFuelRequired = Pi::CalcHyperspaceFuelOut(hyperclass, dist, m_stats.hyperspace_range_max); double m_totalmass = GetMass()/1000; if (dist > m_stats.hyperspace_range_max) { outFuelRequired = 0; return HYPERJUMP_OUT_OF_RANGE; } else if (fuel < outFuelRequired) { return HYPERJUMP_INSUFFICIENT_FUEL; } else { outDurationSecs = Pi::CalcHyperspaceDuration(hyperclass, m_totalmass, dist); if (outFuelRequired <= fuel) { return HYPERJUMP_OK; } else { return HYPERJUMP_INSUFFICIENT_FUEL; } } }
/* * Method: GetBodyPaths * * Get the <SystemPaths> to bodies (planets, stations, starports) in this system * * > paths = system:GetBodyPaths() * * Return: * * paths - an array of <SystemPath> objects, one for each <SystemBody> * * Availability: * * alpha 13 * * Status: * * experimental */ static int l_starsystem_get_body_paths(lua_State *l) { PROFILE_SCOPED() LUA_DEBUG_START(l); StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); lua_newtable(l); for (RefCountedPtr<const SystemBody> sb : s->GetBodies()) { lua_pushinteger(l, lua_rawlen(l, -1)+1); LuaObject<SystemPath>::PushToLua(&sb->GetPath()); lua_rawset(l, -3); } LUA_DEBUG_END(l, 1); return 1; }
/* * Method: GetStationPaths * * Get the <SystemPaths> to stations in this system * * > paths = system:GetStationPaths() * * Return: * * paths - an array of <SystemPath> objects, one for each space station * * Availability: * * alpha 10 * * Status: * * experimental */ static int l_starsystem_get_station_paths(lua_State *l) { PROFILE_SCOPED() LUA_DEBUG_START(l); StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); lua_newtable(l); for (const SystemBody *station : s->GetSpaceStations()) { lua_pushinteger(l, lua_rawlen(l, -1)+1); LuaObject<SystemPath>::PushToLua(&station->GetPath()); lua_rawset(l, -3); } LUA_DEBUG_END(l, 1); return 1; }
void Galaxy::load(FILE* file) { // clear out anything that might be in memory clear(); // load the members fread(&mNextHandle, sizeof mNextHandle, 1, file); // load from the file size_t numSystems; fread(&numSystems, sizeof numSystems, 1, file); for (size_t i = 0; i < numSystems; i++) { StarSystem* starSystem = new StarSystem(); if (starSystem == NULL) { printf("Galaxy::load(): error: out of memory\n"); return; } starSystem->load(file); mStarSystems.push_back(starSystem); } }
/* * Method: GetCommodityBasePriceAlterations * * Get the price alterations for cargo items bought and sold in this system * * > alteration = system:GetCommodityBasePriceAlterations(cargo_item) * * Parameters: * * cargo_item - The cargo item for which one wants to know the alteration * Return: * * percentage - percentage change to the cargo base price. Loosely, * positive values make the commodity more expensive, * indicating it is in demand, while negative values make the * commodity cheaper, indicating a surplus. * * Availability: * * June 2014 * * Status: * * experimental */ static int l_starsystem_get_commodity_base_price_alterations(lua_State *l) { PROFILE_SCOPED() LUA_DEBUG_START(l); StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); LuaTable equip(l, 2); if (!equip.CallMethod<bool>("IsValidSlot", "cargo")) { luaL_error(l, "GetCommodityBasePriceAlterations takes a valid cargo item as argument."); return 0; } equip.PushValueToStack("l10n_key"); // For now let's just use this poor man's hack. GalacticEconomy::Commodity e = static_cast<GalacticEconomy::Commodity>( LuaConstants::GetConstantFromArg(l, "CommodityType", -1)); lua_pop(l, 1); lua_pushnumber(l, s->GetCommodityBasePriceModPercent(e)); LUA_DEBUG_END(l, 1); return 1; }
void MsnEditNavDlg::ScrapeForm() { if (mission) { if (txt_name) { mission->SetName(txt_name->GetText()); } if (cmb_type) { mission->SetType(cmb_type->GetSelectedIndex()); if (mission_info) mission_info->type = cmb_type->GetSelectedIndex(); } Galaxy* galaxy = Galaxy::GetInstance(); StarSystem* system = 0; if (galaxy) system = galaxy->GetSystem(cmb_system->GetSelectedItem()); if (cmb_system && system) { mission->ClearSystemList(); mission->SetStarSystem(system); if (mission_info) mission_info->system = system->Name(); } if (cmb_region) { mission->SetRegion(cmb_region->GetSelectedItem()); if (mission_info) mission_info->region = cmb_region->GetSelectedItem(); } SetSystem(system); } }
/* * Method: DistanceTo * * Calculate the distance between this and another system * * > dist = system:DistanceTo(system) * * Parameters: * * system - a <SystemPath> or <StarSystem> to calculate the distance to * * Return: * * dist - the distance, in light years * * Availability: * * alpha 10 * * Status: * * stable */ static int l_starsystem_distance_to(lua_State *l) { LUA_DEBUG_START(l); StarSystem *s = LuaStarSystem::CheckFromLua(1); const SystemPath *loc1 = &(s->GetPath()); const SystemPath *loc2 = LuaSystemPath::GetFromLua(2); if (!loc2) { StarSystem *s2 = LuaStarSystem::CheckFromLua(2); loc2 = &(s2->GetPath()); } Sector sec1(loc1->sectorX, loc1->sectorY, loc1->sectorZ); Sector sec2(loc2->sectorX, loc2->sectorY, loc2->sectorZ); double dist = Sector::DistanceBetween(&sec1, loc1->systemIndex, &sec2, loc2->systemIndex); lua_pushnumber(l, dist); LUA_DEBUG_END(l, 1); return 1; }
/* * Method: DistanceTo * * Calculate the distance between this and another system * * > dist = system:DistanceTo(system) * * Parameters: * * system - a <SystemPath> or <StarSystem> to calculate the distance to * * Return: * * dist - the distance, in light years * * Availability: * * alpha 10 * * Status: * * stable */ static int l_starsystem_distance_to(lua_State *l) { PROFILE_SCOPED() LUA_DEBUG_START(l); StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1); const SystemPath *loc1 = &(s->GetPath()); const SystemPath *loc2 = LuaObject<SystemPath>::GetFromLua(2); if (!loc2) { StarSystem *s2 = LuaObject<StarSystem>::CheckFromLua(2); loc2 = &(s2->GetPath()); } RefCountedPtr<const Sector> sec1 = Pi::GetGalaxy()->GetSector(*loc1); RefCountedPtr<const Sector> sec2 = Pi::GetGalaxy()->GetSector(*loc2); double dist = Sector::DistanceBetween(sec1, loc1->systemIndex, sec2, loc2->systemIndex); lua_pushnumber(l, dist); LUA_DEBUG_END(l, 1); return 1; }