/*
* 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);
if (!lua_istable(l, 2)) {
return luaL_error(l, "GetCommodityBasePriceAlterations takes a cargo object as and argument.");
}
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 Space::ToJson(Json::Value &jsonObj)
{
PROFILE_SCOPED()
RebuildFrameIndex();
RebuildBodyIndex();
RebuildSystemBodyIndex();
Json::Value spaceObj(Json::objectValue); // Create JSON object to contain space data (all the bodies and things).
StarSystem::ToJson(spaceObj, m_starSystem.Get());
Frame::ToJson(spaceObj, m_rootFrame.get(), this);
Json::Value bodyArray(Json::arrayValue); // Create JSON array to contain body data.
for (Body* b : m_bodies)
{
Json::Value bodyArrayEl(Json::objectValue); // Create JSON object to contain body.
b->ToJson(bodyArrayEl, this);
bodyArray.append(bodyArrayEl); // Append body object to array.
}
spaceObj["bodies"] = bodyArray; // Add body array to space object.
jsonObj["space"] = spaceObj; // Add space object to supplied object.
}
void SpeedLines::Render(Graphics::Renderer *r)
{
PROFILE_SCOPED();
if (!m_visible || m_points.empty()) return;
const vector3f dir = m_dir * m_lineLength;
Uint16 vtx = 0;
//distance fade
Color col(Color::GRAY);
for (auto it = m_points.begin(); it != m_points.end(); ++it) {
col.a = Clamp((1.f - it->Length() / BOUNDS),0.f,1.f) * 255;
m_varray->Set(vtx, *it - dir, col);
m_varray->Set(vtx+1,*it + dir, col);
vtx += 2;
}
m_vbuffer->Populate( *m_varray );
r->SetTransform(m_transform);
r->DrawBuffer(m_vbuffer.get(), m_renderState, m_material.Get(), Graphics::LINE_SINGLE);
}
float Animation::Update(float time)
{
PROFILE_SCOPED();
if (m_completed)
return 0.0f;
const float remaining = m_continuous ? m_duration : (m_duration - time);
m_completed = remaining < 0.0f;
float pos;
if (m_continuous)
pos = m_completed ? m_duration : fmodf(time, m_duration);
else
pos = m_completed ? m_duration : Clamp(time, 0.0f, m_duration);
m_targetFunc(m_wrapFunc(m_easingFunc, pos, m_duration));
m_running = !m_completed;
if (m_completed && m_callback)
m_callback();
return remaining;
}
/*
* 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 = s->m_galaxy->GetSector(*loc1);
RefCountedPtr<const Sector> sec2 = s->m_galaxy->GetSector(*loc2);
double dist = Sector::DistanceBetween(sec1, loc1->systemIndex, sec2, loc2->systemIndex);
lua_pushnumber(l, dist);
LUA_DEBUG_END(l, 1);
return 1;
}
void ShipCockpit::Render(Graphics::Renderer *renderer, const Camera *camera, const vector3d &viewCoords, const matrix4x4d &viewTransform)
{
PROFILE_SCOPED()
RenderModel(renderer, camera, viewCoords, viewTransform);
}
void ShipCpanel::TimeStepUpdate(float step)
{
PROFILE_SCOPED()
m_scanner->TimeStepUpdate(step);
}
void Pi::MainLoop()
{
double time_player_died = 0;
#ifdef MAKING_VIDEO
Uint32 last_screendump = SDL_GetTicks();
int dumpnum = 0;
#endif /* MAKING_VIDEO */
#if WITH_DEVKEYS
Uint32 last_stats = SDL_GetTicks();
int frame_stat = 0;
int phys_stat = 0;
char fps_readout[256];
memset(fps_readout, 0, sizeof(fps_readout));
#endif
int MAX_PHYSICS_TICKS = Pi::config->Int("MaxPhysicsCyclesPerRender");
if (MAX_PHYSICS_TICKS <= 0)
MAX_PHYSICS_TICKS = 4;
double currentTime = 0.001 * double(SDL_GetTicks());
double accumulator = Pi::game->GetTimeStep();
Pi::gameTickAlpha = 0;
while (Pi::game) {
PROFILE_SCOPED()
#ifdef PIONEER_PROFILER
Profiler::reset();
#endif
const Uint32 newTicks = SDL_GetTicks();
double newTime = 0.001 * double(newTicks);
Pi::frameTime = newTime - currentTime;
if (Pi::frameTime > 0.25) Pi::frameTime = 0.25;
currentTime = newTime;
accumulator += Pi::frameTime * Pi::game->GetTimeAccelRate();
const float step = Pi::game->GetTimeStep();
if (step > 0.0f) {
PROFILE_SCOPED_RAW("unpaused")
int phys_ticks = 0;
while (accumulator >= step) {
if (++phys_ticks >= MAX_PHYSICS_TICKS) {
accumulator = 0.0;
break;
}
game->TimeStep(step);
BaseSphere::UpdateAllBaseSphereDerivatives();
accumulator -= step;
}
// rendering interpolation between frames: don't use when docked
int pstate = Pi::game->GetPlayer()->GetFlightState();
if (pstate == Ship::DOCKED || pstate == Ship::DOCKING) Pi::gameTickAlpha = 1.0;
else Pi::gameTickAlpha = accumulator / step;
#if WITH_DEVKEYS
phys_stat += phys_ticks;
#endif
} else {
GeomTree::GeomTree(Serializer::Reader &rd)
{
PROFILE_SCOPED()
m_numVertices = rd.Int32();
m_numEdges = rd.Int32();
m_numTris = rd.Int32();
m_radius = rd.Double();
m_aabb.max = rd.Vector3d();
m_aabb.min = rd.Vector3d();
m_aabb.radius = rd.Double();
const Uint32 numAabbs = rd.Int32();
m_aabbs.resize(numAabbs);
for (Uint32 iAabb = 0; iAabb < numAabbs; ++iAabb) {
m_aabbs[iAabb].max = rd.Vector3d();
m_aabbs[iAabb].min = rd.Vector3d();
m_aabbs[iAabb].radius = rd.Double();
}
m_edges.resize(m_numEdges);
for (Sint32 iEdge = 0; iEdge < m_numEdges; ++iEdge) {
m_edges[iEdge].Load(rd);
}
m_vertices.resize(m_numVertices);
for (Sint32 iVert = 0; iVert < m_numVertices; ++iVert) {
m_vertices[iVert] = rd.Vector3f();
}
const int numIndicies(m_numTris * 3);
m_indices.resize(numIndicies);
for (Sint32 iIndi = 0; iIndi < numIndicies; ++iIndi) {
m_indices[iIndi] = rd.Int32();
}
m_triFlags.resize(m_numTris);
for (Sint32 iTri = 0; iTri < m_numTris; ++iTri) {
m_triFlags[iTri] = rd.Int32();
}
// activeTris = tris we are still trying to put into leaves
std::vector<int> activeTris;
activeTris.reserve(m_numTris);
for (int i = 0; i < m_numTris; i++) {
activeTris.push_back(i * 3);
}
// regenerate the aabb data
Aabb *aabbs = new Aabb[activeTris.size()];
for (Uint32 i = 0; i < activeTris.size(); i++) {
const vector3d v1 = vector3d(m_vertices[m_indices[activeTris[i] + 0]]);
const vector3d v2 = vector3d(m_vertices[m_indices[activeTris[i] + 1]]);
const vector3d v3 = vector3d(m_vertices[m_indices[activeTris[i] + 2]]);
aabbs[i].min = aabbs[i].max = v1;
aabbs[i].Update(v2);
aabbs[i].Update(v3);
}
m_triTree.reset(new BVHTree(activeTris.size(), &activeTris[0], aabbs));
delete[] aabbs;
//
int *edgeIdxs = new int[m_numEdges];
memset(edgeIdxs, 0, sizeof(int) * m_numEdges);
for (int i = 0; i < m_numEdges; i++) {
edgeIdxs[i] = i;
}
m_edgeTree.reset(new BVHTree(m_numEdges, edgeIdxs, &m_aabbs[0]));
}
GeomTree::GeomTree(const int numVerts, const int numTris, const std::vector<vector3f> &vertices, const Uint32 *indices, const Uint32 *triflags) :
m_numVertices(numVerts),
m_numTris(numTris),
m_vertices(vertices)
{
PROFILE_SCOPED()
assert(static_cast<int>(vertices.size()) == m_numVertices);
Profiler::Timer timer;
timer.Start();
const int numIndices = numTris * 3;
m_indices.reserve(numIndices);
for (int i = 0; i < numIndices; ++i) {
m_indices.push_back(indices[i]);
}
m_triFlags.reserve(numTris);
for (int i = 0; i < numTris; ++i) {
m_triFlags.push_back(triflags[i]);
}
m_aabb.min = vector3d(FLT_MAX, FLT_MAX, FLT_MAX);
m_aabb.max = vector3d(-FLT_MAX, -FLT_MAX, -FLT_MAX);
// activeTris = tris we are still trying to put into leaves
std::vector<int> activeTris;
activeTris.reserve(numTris);
for (int i = 0; i < numTris; i++) {
activeTris.push_back(i * 3);
}
typedef std::map<std::pair<int, int>, int> EdgeType;
EdgeType edges;
#define ADD_EDGE(_i1, _i2, _triflag) \
if ((_i1) < (_i2)) \
edges[std::pair<int, int>(_i1, _i2)] = _triflag; \
else if ((_i1) > (_i2)) \
edges[std::pair<int, int>(_i2, _i1)] = _triflag;
// eliminate duplicate vertices
{
std::vector<Uint32> xrefs;
nv::Weld<vector3f> weld;
weld(m_vertices, xrefs);
m_numVertices = m_vertices.size();
//Output("--- %d vertices welded\n", count - newCount);
// Remap faces.
const Uint32 faceCount = numTris;
for (Uint32 f = 0; f < faceCount; f++) {
const Uint32 idx = (f * 3);
m_indices[idx + 0] = xrefs.at(m_indices[idx + 0]);
m_indices[idx + 1] = xrefs.at(m_indices[idx + 1]);
m_indices[idx + 2] = xrefs.at(m_indices[idx + 2]);
}
}
// Get radius, m_aabb, and merge duplicate edges
m_radius = 0;
for (int i = 0; i < numTris; i++) {
const Uint32 triflag = m_triFlags[i];
const int vi1 = m_indices[3 * i + 0];
const int vi2 = m_indices[3 * i + 1];
const int vi3 = m_indices[3 * i + 2];
ADD_EDGE(vi1, vi2, triflag);
ADD_EDGE(vi1, vi3, triflag);
ADD_EDGE(vi2, vi3, triflag);
vector3d v[3];
v[0] = vector3d(m_vertices[vi1]);
v[1] = vector3d(m_vertices[vi2]);
v[2] = vector3d(m_vertices[vi3]);
m_aabb.Update(v[0]);
m_aabb.Update(v[1]);
m_aabb.Update(v[2]);
for (int j = 0; j < 3; j++) {
const double rad = v[j].x * v[j].x + v[j].y * v[j].y + v[j].z * v[j].z;
if (rad > m_radius) m_radius = rad;
}
}
m_radius = sqrt(m_radius);
{
Aabb *aabbs = new Aabb[activeTris.size()];
for (Uint32 i = 0; i < activeTris.size(); i++) {
const vector3d v1 = vector3d(m_vertices[m_indices[activeTris[i] + 0]]);
const vector3d v2 = vector3d(m_vertices[m_indices[activeTris[i] + 1]]);
const vector3d v3 = vector3d(m_vertices[m_indices[activeTris[i] + 2]]);
aabbs[i].min = aabbs[i].max = v1;
aabbs[i].Update(v2);
aabbs[i].Update(v3);
}
//int t = SDL_GetTicks();
m_triTree.reset(new BVHTree(activeTris.size(), &activeTris[0], aabbs));
delete[] aabbs;
}
//Output("Tri tree of %d tris build in %dms\n", activeTris.size(), SDL_GetTicks() - t);
m_numEdges = edges.size();
m_edges.resize(m_numEdges);
// to build Edge bvh tree with.
m_aabbs.resize(m_numEdges);
int *edgeIdxs = new int[m_numEdges];
int pos = 0;
typedef EdgeType::iterator MapPairIter;
for (MapPairIter i = edges.begin(), iEnd = edges.end(); i != iEnd; ++i, pos++) {
// precalc some j**z
const std::pair<int, int> &vtx = (*i).first;
const int triflag = (*i).second;
const vector3f &v1 = m_vertices[vtx.first];
const vector3f &v2 = m_vertices[vtx.second];
vector3f dir = (v2 - v1);
const float len = dir.Length();
dir *= 1.0f / len;
m_edges[pos].v1i = vtx.first;
m_edges[pos].v2i = vtx.second;
m_edges[pos].triFlag = triflag;
m_edges[pos].len = len;
m_edges[pos].dir = dir;
edgeIdxs[pos] = pos;
m_aabbs[pos].min = m_aabbs[pos].max = vector3d(v1);
m_aabbs[pos].Update(vector3d(v2));
}
//t = SDL_GetTicks();
m_edgeTree.reset(new BVHTree(m_numEdges, edgeIdxs, &m_aabbs[0]));
delete[] edgeIdxs;
//Output("Edge tree of %d edges build in %dms\n", m_numEdges, SDL_GetTicks() - t);
timer.Stop();
//Output(" - - GeomTree::GeomTree took: %lf milliseconds\n", timer.millicycles());
}
void Pi::Init(const std::map<std::string, std::string> &options, bool no_gui)
{
#ifdef PIONEER_PROFILER
Profiler::reset();
#endif
Profiler::Timer timer;
timer.Start();
OS::EnableBreakpad();
OS::NotifyLoadBegin();
FileSystem::Init();
FileSystem::userFiles.MakeDirectory(""); // ensure the config directory exists
#ifdef PIONEER_PROFILER
FileSystem::userFiles.MakeDirectory("profiler");
profilerPath = FileSystem::JoinPathBelow(FileSystem::userFiles.GetRoot(), "profiler");
#endif
PROFILE_SCOPED()
Pi::config = new GameConfig(options);
if (config->Int("RedirectStdio"))
OS::RedirectStdio();
std::string version(PIONEER_VERSION);
if (strlen(PIONEER_EXTRAVERSION)) version += " (" PIONEER_EXTRAVERSION ")";
const char *platformName = SDL_GetPlatform();
if (platformName)
Output("ver %s on: %s\n\n", version.c_str(), platformName);
else
Output("ver %s but could not detect platform name.\n\n", version.c_str());
Output("%s\n", OS::GetOSInfoString().c_str());
ModManager::Init();
Lang::Resource res(Lang::GetResource("core", config->String("Lang")));
Lang::MakeCore(res);
Pi::SetAmountBackgroundStars(config->Float("AmountOfBackgroundStars"));
Pi::detail.planets = config->Int("DetailPlanets");
Pi::detail.cities = config->Int("DetailCities");
// Initialize SDL
Uint32 sdlInitFlags = SDL_INIT_VIDEO | SDL_INIT_JOYSTICK;
#if defined(DEBUG) || defined(_DEBUG)
sdlInitFlags |= SDL_INIT_NOPARACHUTE;
#endif
if (SDL_Init(sdlInitFlags) < 0) {
Error("SDL initialization failed: %s\n", SDL_GetError());
}
OutputVersioningInfo();
Graphics::RendererOGL::RegisterRenderer();
// determine what renderer we should use, default to Opengl 3.x
const std::string rendererName = config->String("RendererName", Graphics::RendererNameFromType(Graphics::RENDERER_OPENGL_3x));
Graphics::RendererType rType = Graphics::RENDERER_OPENGL_3x;
//if(rendererName == Graphics::RendererNameFromType(Graphics::RENDERER_OPENGL_3x))
//{
// rType = Graphics::RENDERER_OPENGL_3x;
//}
// Do rest of SDL video initialization and create Renderer
Graphics::Settings videoSettings = {};
videoSettings.rendererType = rType;
videoSettings.width = config->Int("ScrWidth");
videoSettings.height = config->Int("ScrHeight");
videoSettings.fullscreen = (config->Int("StartFullscreen") != 0);
videoSettings.hidden = no_gui;
videoSettings.requestedSamples = config->Int("AntiAliasingMode");
videoSettings.vsync = (config->Int("VSync") != 0);
videoSettings.useTextureCompression = (config->Int("UseTextureCompression") != 0);
videoSettings.useAnisotropicFiltering = (config->Int("UseAnisotropicFiltering") != 0);
videoSettings.enableDebugMessages = (config->Int("EnableGLDebug") != 0);
videoSettings.gl3ForwardCompatible = (config->Int("GL3ForwardCompatible") != 0);
videoSettings.iconFile = OS::GetIconFilename();
videoSettings.title = "Pioneer";
Pi::renderer = Graphics::Init(videoSettings);
Pi::CreateRenderTarget(videoSettings.width, videoSettings.height);
Pi::rng.IncRefCount(); // so nothing tries to free it
Pi::rng.seed(time(0));
input.Init();
input.onKeyPress.connect(sigc::ptr_fun(&Pi::HandleKeyDown));
// we can only do bindings once joysticks are initialised.
if (!no_gui) // This re-saves the config file. With no GUI we want to allow multiple instances in parallel.
KeyBindings::InitBindings();
RegisterInputBindings();
navTunnelDisplayed = (config->Int("DisplayNavTunnel")) ? true : false;
speedLinesDisplayed = (config->Int("SpeedLines")) ? true : false;
hudTrailsDisplayed = (config->Int("HudTrails")) ? true : false;
TestGPUJobsSupport();
EnumStrings::Init();
// get threads up
Uint32 numThreads = config->Int("WorkerThreads");
const int numCores = OS::GetNumCores();
assert(numCores > 0);
if (numThreads == 0) numThreads = std::max(Uint32(numCores) - 1, 1U);
asyncJobQueue.reset(new AsyncJobQueue(numThreads));
Output("started %d worker threads\n", numThreads);
syncJobQueue.reset(new SyncJobQueue);
Output("ShipType::Init()\n");
// XXX early, Lua init needs it
ShipType::Init();
// XXX UI requires Lua but Pi::ui must exist before we start loading
// templates. so now we have crap everywhere :/
Output("Lua::Init()\n");
Lua::Init();
Pi::pigui.Reset(new PiGui);
Pi::pigui->Init(Pi::renderer->GetSDLWindow());
float ui_scale = config->Float("UIScaleFactor", 1.0f);
if (Graphics::GetScreenHeight() < 768) {
ui_scale = float(Graphics::GetScreenHeight()) / 768.0f;
}
Pi::ui.Reset(new UI::Context(
Lua::manager,
Pi::renderer,
Graphics::GetScreenWidth(),
Graphics::GetScreenHeight(),
ui_scale));
#ifdef ENABLE_SERVER_AGENT
Pi::serverAgent = 0;
if (config->Int("EnableServerAgent")) {
const std::string endpoint(config->String("ServerEndpoint"));
if (endpoint.size() > 0) {
Output("Server agent enabled, endpoint: %s\n", endpoint.c_str());
Pi::serverAgent = new HTTPServerAgent(endpoint);
}
}
if (!Pi::serverAgent) {
Output("Server agent disabled\n");
Pi::serverAgent = new NullServerAgent();
}
#endif
LuaInit();
Gui::Init(renderer, Graphics::GetScreenWidth(), Graphics::GetScreenHeight(), 800, 600);
// twice, to initialize the font correctly
draw_progress(0.01f);
draw_progress(0.01f);
Output("GalaxyGenerator::Init()\n");
if (config->HasEntry("GalaxyGenerator"))
GalaxyGenerator::Init(config->String("GalaxyGenerator"),
config->Int("GalaxyGeneratorVersion", GalaxyGenerator::LAST_VERSION));
else
GalaxyGenerator::Init();
draw_progress(0.1f);
Output("FaceParts::Init()\n");
FaceParts::Init();
draw_progress(0.2f);
Output("new ModelCache\n");
modelCache = new ModelCache(Pi::renderer);
draw_progress(0.3f);
Output("Shields::Init\n");
Shields::Init(Pi::renderer);
draw_progress(0.4f);
//unsigned int control_word;
//_clearfp();
//_controlfp_s(&control_word, _EM_INEXACT | _EM_UNDERFLOW | _EM_ZERODIVIDE, _MCW_EM);
//double fpexcept = Pi::timeAccelRates[1] / Pi::timeAccelRates[0];
Output("BaseSphere::Init\n");
BaseSphere::Init();
draw_progress(0.5f);
Output("CityOnPlanet::Init\n");
CityOnPlanet::Init();
draw_progress(0.6f);
Output("SpaceStation::Init\n");
SpaceStation::Init();
draw_progress(0.7f);
Output("NavLights::Init\n");
NavLights::Init(Pi::renderer);
draw_progress(0.75f);
Output("Sfx::Init\n");
SfxManager::Init(Pi::renderer);
draw_progress(0.8f);
if (!no_gui && !config->Int("DisableSound")) {
Output("Sound::Init\n");
Sound::Init();
Sound::SetMasterVolume(config->Float("MasterVolume"));
Sound::SetSfxVolume(config->Float("SfxVolume"));
GetMusicPlayer().SetVolume(config->Float("MusicVolume"));
Sound::Pause(0);
if (config->Int("MasterMuted")) Sound::Pause(1);
if (config->Int("SfxMuted")) Sound::SetSfxVolume(0.f);
if (config->Int("MusicMuted")) GetMusicPlayer().SetEnabled(false);
}
draw_progress(0.9f);
OS::NotifyLoadEnd();
draw_progress(0.95f);
#if 0
// frame test code
Frame *root = new Frame(0, "root", 0);
Frame *p1 = new Frame(root, "p1", Frame::FLAG_HAS_ROT);
Frame *p1r = new Frame(p1, "p1r", Frame::FLAG_ROTATING);
Frame *m1 = new Frame(p1, "m1", Frame::FLAG_HAS_ROT);
Frame *m1r = new Frame(m1, "m1r", Frame::FLAG_ROTATING);
Frame *p2 = new Frame(root, "p2", Frame::FLAG_HAS_ROT);
Frame *p2r = new Frame(p2, "pr2", Frame::FLAG_ROTATING);
p1->SetPosition(vector3d(1000,0,0));
p1->SetVelocity(vector3d(0,1,0));
p2->SetPosition(vector3d(0,2000,0));
p2->SetVelocity(vector3d(-2,0,0));
p1r->SetAngVelocity(vector3d(0,0,0.0001));
p1r->SetOrient(matrix3x3d::BuildRotate(M_PI/4, vector3d(0,0,1)));
p2r->SetAngVelocity(vector3d(0,0,-0.0004));
p2r->SetOrient(matrix3x3d::BuildRotate(-M_PI/2, vector3d(0,0,1)));
root->UpdateOrbitRails(0, 0);
CargoBody *c1 = new CargoBody(Equip::Type::SLAVES);
c1->SetFrame(p1r);
c1->SetPosition(vector3d(0,180,0));
// c1->SetVelocity(vector3d(1,0,0));
CargoBody *c2 = new CargoBody(Equip::Type::SLAVES);
c2->SetFrame(p1r);
c2->SetPosition(vector3d(0,200,0));
// c2->SetVelocity(vector3d(1,0,0));
vector3d pos = c1->GetPositionRelTo(p1);
vector3d vel = c1->GetVelocityRelTo(p1);
double speed = vel.Length();
vector3d pos2 = c2->GetPositionRelTo(p1);
vector3d vel2 = c2->GetVelocityRelTo(p1);
double speed2 = vel2.Length();
double speed3 = c2->GetVelocityRelTo(c1).Length();
c2->SwitchToFrame(p1);
vector3d vel4 = c2->GetVelocityRelTo(c1);
double speed4 = c2->GetVelocityRelTo(c1).Length();
root->UpdateOrbitRails(0, 1.0);
//buildrotate test
matrix3x3d m = matrix3x3d::BuildRotate(M_PI/2, vector3d(0,0,1));
vector3d v = m * vector3d(1,0,0);
/* vector3d pos = p1r->GetPositionRelTo(p2r);
vector3d vel = p1r->GetVelocityRelTo(p2r);
matrix3x3d o1 = p1r->GetOrientRelTo(p2r);
double speed = vel.Length();
vector3d pos2 = p2r->GetPositionRelTo(p1r);
vector3d vel2 = p2r->GetVelocityRelTo(p1r);
matrix3x3d o2 = p2r->GetOrientRelTo(p1r);
double speed2 = vel2.Length();
*/ root->UpdateOrbitRails(0, 1.0/60);
delete p2r; delete p2; delete m1r; delete m1; delete p1r; delete p1; delete root;
delete c1; delete c2;
#endif
#if 0
// test code to produce list of ship stats
FILE *pStatFile = fopen("shipstat.csv","wt");
if (pStatFile)
{
fprintf(pStatFile, "name,modelname,hullmass,capacity,fakevol,rescale,xsize,ysize,zsize,facc,racc,uacc,sacc,aacc,exvel\n");
for (auto iter : ShipType::types)
{
const ShipType *shipdef = &(iter.second);
SceneGraph::Model *model = Pi::FindModel(shipdef->modelName, false);
double hullmass = shipdef->hullMass;
double capacity = shipdef->capacity;
double xsize = 0.0, ysize = 0.0, zsize = 0.0, fakevol = 0.0, rescale = 0.0, brad = 0.0;
if (model) {
std::unique_ptr<SceneGraph::Model> inst(model->MakeInstance());
model->CreateCollisionMesh();
Aabb aabb = model->GetCollisionMesh()->GetAabb();
xsize = aabb.max.x-aabb.min.x;
ysize = aabb.max.y-aabb.min.y;
zsize = aabb.max.z-aabb.min.z;
fakevol = xsize*ysize*zsize;
brad = aabb.GetRadius();
rescale = pow(fakevol/(100 * (hullmass+capacity)), 0.3333333333);
}
double simass = (hullmass + capacity) * 1000.0;
double angInertia = (2/5.0)*simass*brad*brad;
double acc1 = shipdef->linThrust[Thruster::THRUSTER_FORWARD] / (9.81*simass);
double acc2 = shipdef->linThrust[Thruster::THRUSTER_REVERSE] / (9.81*simass);
double acc3 = shipdef->linThrust[Thruster::THRUSTER_UP] / (9.81*simass);
double acc4 = shipdef->linThrust[Thruster::THRUSTER_RIGHT] / (9.81*simass);
double acca = shipdef->angThrust/angInertia;
double exvel = shipdef->effectiveExhaustVelocity;
fprintf(pStatFile, "%s,%s,%.1f,%.1f,%.1f,%.3f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%.1f,%f,%.1f\n",
shipdef->name.c_str(), shipdef->modelName.c_str(), hullmass, capacity,
fakevol, rescale, xsize, ysize, zsize, acc1, acc2, acc3, acc4, acca, exvel);
}
fclose(pStatFile);
}
#endif
luaConsole = new LuaConsole();
KeyBindings::toggleLuaConsole.onPress.connect(sigc::mem_fun(Pi::luaConsole, &LuaConsole::Toggle));
planner = new TransferPlanner();
draw_progress(1.0f);
timer.Stop();
#ifdef PIONEER_PROFILER
Profiler::dumphtml(profilerPath.c_str());
#endif
Output("\n\nLoading took: %lf milliseconds\n", timer.millicycles());
}
void Pi::HandleEvents()
{
PROFILE_SCOPED()
SDL_Event event;
// XXX for most keypresses SDL will generate KEYUP/KEYDOWN and TEXTINPUT
// events. keybindings run off KEYUP/KEYDOWN. the console is opened/closed
// via keybinding. the console TextInput widget uses TEXTINPUT events. thus
// after switching the console, the stray TEXTINPUT event causes the
// console key (backtick) to appear in the text entry field. we hack around
// this by setting this flag if the console was switched. if its set, we
// swallow the TEXTINPUT event this hack must remain until we have a
// unified input system
bool skipTextInput = false;
Pi::input.mouseMotion[0] = Pi::input.mouseMotion[1] = 0;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
Pi::RequestQuit();
}
Pi::pigui->ProcessEvent(&event);
if (Pi::pigui->WantCaptureMouse()) {
// don't process mouse event any further, imgui already handled it
switch (event.type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEWHEEL:
case SDL_MOUSEMOTION:
continue;
default: break;
}
}
if (Pi::pigui->WantCaptureKeyboard()) {
// don't process keyboard event any further, imgui already handled it
switch (event.type) {
case SDL_KEYDOWN:
case SDL_KEYUP:
case SDL_TEXTINPUT:
continue;
default: break;
}
}
if (skipTextInput && event.type == SDL_TEXTINPUT) {
skipTextInput = false;
continue;
}
if (ui->DispatchSDLEvent(event))
continue;
bool consoleActive = Pi::IsConsoleActive();
if (!consoleActive) {
KeyBindings::DispatchSDLEvent(&event);
if (currentView)
currentView->HandleSDLEvent(event);
} else
KeyBindings::toggleLuaConsole.CheckSDLEventAndDispatch(&event);
if (consoleActive != Pi::IsConsoleActive()) {
skipTextInput = true;
continue;
}
if (Pi::IsConsoleActive())
continue;
Gui::HandleSDLEvent(&event);
input.HandleSDLEvent(event);
}
}
void Disk::Draw(Renderer *r)
{
PROFILE_SCOPED()
r->DrawBuffer(m_vertexBuffer.get(), m_renderState, m_material.Get(), TRIANGLE_FAN);
}
void Geom::MoveTo(const matrix4x4d &m)
{
PROFILE_SCOPED()
m_orient = m;
m_invOrient = m.Inverse();
}
void Container::SetIntensity(float intensity)
{
PROFILE_SCOPED()
m_starField.SetIntensity(intensity);
m_milkyWay.SetIntensity(intensity);
}
const std::string SectorRandomSystemsGenerator::GenName(RefCountedPtr<Galaxy> galaxy, const Sector& sec, Sector::System &sys, int si, Random &rng)
{
PROFILE_SCOPED()
std::string name;
const int sx = sec.sx;
const int sy = sec.sy;
const int sz = sec.sz;
const int dist = std::max(std::max(abs(sx),abs(sy)),abs(sz));
int chance = 100;
switch (sys.m_starType[0]) {
case SystemBody::TYPE_STAR_O:
case SystemBody::TYPE_STAR_B: break;
case SystemBody::TYPE_STAR_A: chance += dist; break;
case SystemBody::TYPE_STAR_F: chance += 2*dist; break;
case SystemBody::TYPE_STAR_G: chance += 4*dist; break;
case SystemBody::TYPE_STAR_K: chance += 8*dist; break;
case SystemBody::TYPE_STAR_O_GIANT:
case SystemBody::TYPE_STAR_B_GIANT: chance = 50; break;
case SystemBody::TYPE_STAR_A_GIANT: chance = int(0.2*dist); break;
case SystemBody::TYPE_STAR_F_GIANT: chance = int(0.4*dist); break;
case SystemBody::TYPE_STAR_G_GIANT: chance = int(0.5*dist); break;
case SystemBody::TYPE_STAR_K_GIANT:
case SystemBody::TYPE_STAR_M_GIANT: chance = dist; break;
case SystemBody::TYPE_STAR_O_SUPER_GIANT:
case SystemBody::TYPE_STAR_B_SUPER_GIANT: chance = 10; break;
case SystemBody::TYPE_STAR_A_SUPER_GIANT:
case SystemBody::TYPE_STAR_F_SUPER_GIANT:
case SystemBody::TYPE_STAR_G_SUPER_GIANT:
case SystemBody::TYPE_STAR_K_SUPER_GIANT: chance = 15; break;
case SystemBody::TYPE_STAR_M_SUPER_GIANT: chance = 20; break;
case SystemBody::TYPE_STAR_O_HYPER_GIANT:
case SystemBody::TYPE_STAR_B_HYPER_GIANT:
case SystemBody::TYPE_STAR_A_HYPER_GIANT:
case SystemBody::TYPE_STAR_F_HYPER_GIANT:
case SystemBody::TYPE_STAR_G_HYPER_GIANT:
case SystemBody::TYPE_STAR_K_HYPER_GIANT:
case SystemBody::TYPE_STAR_M_HYPER_GIANT: chance = 1; break; //Should give a nice name almost all the time
default: chance += 16*dist; break;
}
Uint32 weight = rng.Int32(chance);
if (weight < 500 || galaxy->GetFactions()->IsHomeSystem(SystemPath(sx, sy, sz, si))) {
/* well done. you get a real name */
int len = rng.Int32(2,3);
for (int i=0; i<len; i++) {
name += sys_names[rng.Int32(0,SYS_NAME_FRAGS-1)];
}
name[0] = toupper(name[0]);
return name;
} else if (weight < 800) {
char buf[128];
snprintf(buf, sizeof(buf), "MJBN %d%+d%+d", rng.Int32(10,999),sx,sy); // MJBN -> Morton Jordan Bennett Norris
return buf;
} else if (weight < 1200) {
char buf[128];
snprintf(buf, sizeof(buf), "SC %d%+d%+d", rng.Int32(1000,9999),sx,sy);
return buf;
} else {
char buf[128];
snprintf(buf, sizeof(buf), "DSC %d%+d%+d", rng.Int32(1000,9999),sx,sy);
return buf;
}
}
void Sensors::ResetTrails()
{
PROFILE_SCOPED();
for (auto it = m_radarContacts.begin(); it != m_radarContacts.end(); ++it)
it->trail->Reset(Pi::player->GetFrame());
}
Faction *FactionsDatabase::GetFaction(const Uint32 index)
{
PROFILE_SCOPED()
assert( index < m_factions.size() );
return m_factions[index];
}
void MatrixTransform::Render(const matrix4x4f &trans, const RenderData *rd)
{
PROFILE_SCOPED();
const matrix4x4f t = trans * m_transform;
RenderChildren(t, rd);
}
void DrawOutdent(const float size[2], Graphics::RenderState *state)
{
PROFILE_SCOPED()
// locals
RefCountedPtr<Graphics::VertexBuffer> vb;
RefCountedPtr<Graphics::IndexBuffer> ib[3];
// see if we have this size of indent in the cache already
const vector2f vsize(size[0], size[1]);
MapOutdentBuffers::iterator bufIt = s_outdentBuffers.find(vsize);
if (bufIt != s_outdentBuffers.end())
{
// found it
vb = bufIt->second.vb;
ib[0] = bufIt->second.ib[0];
ib[1] = bufIt->second.ib[1];
ib[2] = bufIt->second.ib[2];
}
else
{
// generate it
const vector3f vertices[] = {
/* 0 */ vector3f(0, 0, 0),
/* 1 */ vector3f(0, size[1], 0),
/* 2 */ vector3f(size[0], size[1], 0),
/* 3 */ vector3f(size[0], 0, 0),
/* 4 */ vector3f(BORDER_WIDTH, BORDER_WIDTH, 0),
/* 5 */ vector3f(BORDER_WIDTH, size[1] - BORDER_WIDTH, 0),
/* 6 */ vector3f(size[0] - BORDER_WIDTH, size[1] - BORDER_WIDTH, 0),
/* 7 */ vector3f(size[0] - BORDER_WIDTH, BORDER_WIDTH, 0)
};
const Uint32 indices[] = {
0, 1, 5, 0, 5, 4, 0, 4, 7, 0, 7, 3,
3, 7, 6, 3, 6, 2, 1, 2, 6, 1, 6, 5,
4, 5, 6, 4, 6, 7 };
// create buffer
Graphics::VertexBufferDesc vbd;
vbd.attrib[0].semantic = Graphics::ATTRIB_POSITION;
vbd.attrib[0].format = Graphics::ATTRIB_FORMAT_FLOAT3;
vbd.numVertices = 8;
vbd.usage = Graphics::BUFFER_USAGE_STATIC;
// Upload data
vb.Reset(Screen::GetRenderer()->CreateVertexBuffer(vbd));
TPos* vtxPtr = vb->Map<TPos>(Graphics::BUFFER_MAP_WRITE);
assert(vb->GetDesc().stride == sizeof(TPos));
for (Uint32 i = 0; i < 8; i++) {
vtxPtr[i].pos = vertices[i];
}
vb->Unmap();
// indices
Uint32 IndexStart = 0;
Uint32 IndexEnd = 12;
Uint32 NumIndices = 12;
ib[0].Reset(CreateIndexBuffer(indices, IndexStart, IndexEnd, NumIndices));
IndexStart += NumIndices;
NumIndices = 12;
IndexEnd += NumIndices;
ib[1].Reset(CreateIndexBuffer(indices, IndexStart, IndexEnd, NumIndices));
IndexStart += NumIndices;
NumIndices = 6;
IndexEnd += NumIndices;
ib[2].Reset(CreateIndexBuffer(indices, IndexStart, IndexEnd, NumIndices));
TOutdentBuffers tib;
tib.vb = vb;
tib.ib[0] = ib[0];
tib.ib[1] = ib[1];
tib.ib[2] = ib[2];
s_outdentBuffers[vsize] = tib;
}
// Draw it!
Screen::flatColorMaterial->diffuse = Color(153,153,153,255);
Screen::GetRenderer()->DrawBufferIndexed(vb.Get(), ib[0].Get(), state, Screen::flatColorMaterial);
Screen::flatColorMaterial->diffuse = Colors::bgShadow;
Screen::GetRenderer()->DrawBufferIndexed(vb.Get(), ib[1].Get(), state, Screen::flatColorMaterial);
Screen::flatColorMaterial->diffuse = Colors::bg;
Screen::GetRenderer()->DrawBufferIndexed(vb.Get(), ib[2].Get(), state, Screen::flatColorMaterial);
}
/*
* Method: GetNearbySystems
*
* Get a list of nearby <StarSystems> that match some criteria
*
* > systems = system:GetNearbySystems(range, filter)
*
* Parameters:
*
* range - distance from this system to search, in light years
*
* filter - an optional function. If specified the function will be called
* once for each candidate system with the <StarSystem> object
* passed as the only parameter. If the filter function returns
* true then the system will be included in the array returned by
* <GetNearbySystems>, otherwise it will be omitted. If no filter
* function is specified then all systems in range are returned.
*
* Return:
*
* systems - an array of systems in range that matched the filter
*
* Availability:
*
* alpha 10
*
* Status:
*
* experimental
*/
static int l_starsystem_get_nearby_systems(lua_State *l)
{
PROFILE_SCOPED()
LUA_DEBUG_START(l);
const StarSystem *s = LuaObject<StarSystem>::CheckFromLua(1);
const double dist_ly = luaL_checknumber(l, 2);
bool filter = false;
if (lua_gettop(l) >= 3) {
luaL_checktype(l, 3, LUA_TFUNCTION); // any type of function
filter = true;
}
lua_newtable(l);
const SystemPath &here = s->GetPath();
const int here_x = here.sectorX;
const int here_y = here.sectorY;
const int here_z = here.sectorZ;
const Uint32 here_idx = here.systemIndex;
RefCountedPtr<const Sector> here_sec = Pi::GetGalaxy()->GetSector(here);
const int diff_sec = int(ceil(dist_ly/Sector::SIZE));
for (int x = here_x-diff_sec; x <= here_x+diff_sec; x++) {
for (int y = here_y-diff_sec; y <= here_y+diff_sec; y++) {
for (int z = here_z-diff_sec; z <= here_z+diff_sec; z++) {
RefCountedPtr<const Sector> sec = Pi::GetGalaxy()->GetSector(SystemPath(x, y, z));
for (unsigned int idx = 0; idx < sec->m_systems.size(); idx++) {
if (x == here_x && y == here_y && z == here_z && idx == here_idx)
continue;
if (Sector::DistanceBetween(here_sec, here_idx, sec, idx) > dist_ly)
continue;
RefCountedPtr<StarSystem> sys = Pi::GetGalaxy()->GetStarSystem(SystemPath(x, y, z, idx));
if (filter) {
lua_pushvalue(l, 3);
LuaObject<StarSystem>::PushToLua(sys.Get());
lua_call(l, 1, 1);
if (!lua_toboolean(l, -1)) {
lua_pop(l, 1);
continue;
}
lua_pop(l, 1);
}
lua_pushinteger(l, lua_rawlen(l, -1)+1);
LuaObject<StarSystem>::PushToLua(sys.Get());
lua_rawset(l, -3);
}
}
}
}
LUA_DEBUG_END(l, 1);
return 1;
}
//////////////////////// Sector
Sector::Sector(const SystemPath& path) : m_factionsAssigned(false)
{
PROFILE_SCOPED()
Uint32 _init[4] = { Uint32(path.sectorX), Uint32(path.sectorY), Uint32(path.sectorZ), UNIVERSE_SEED };
Random rng(_init, 4);
sx = path.sectorX; sy = path.sectorY; sz = path.sectorZ;
GetCustomSystems(rng);
int customCount = m_systems.size();
/* Always place random systems outside the core custom-only region */
if ((path.sectorX < -CUSTOM_ONLY_RADIUS) || (path.sectorX > CUSTOM_ONLY_RADIUS-1) ||
(path.sectorY < -CUSTOM_ONLY_RADIUS) || (path.sectorY > CUSTOM_ONLY_RADIUS-1) ||
(path.sectorZ < -CUSTOM_ONLY_RADIUS) || (path.sectorZ > CUSTOM_ONLY_RADIUS-1)) {
int numSystems = (rng.Int32(4,20) * Galaxy::GetSectorDensity(path.sectorX, path.sectorY, path.sectorZ)) >> 8;
for (int i=0; i<numSystems; i++) {
System s(sx, sy, sz, customCount + i);
switch (rng.Int32(15)) {
case 0:
s.numStars = 4; break;
case 1: case 2:
s.numStars = 3; break;
case 3: case 4: case 5: case 6:
s.numStars = 2; break;
default:
s.numStars = 1; break;
}
s.p.x = rng.Double(SIZE);
s.p.y = rng.Double(SIZE);
s.p.z = rng.Double(SIZE);
s.seed = 0;
s.customSys = 0;
/*
* 0 - ~500ly from sol: explored
* ~500ly - ~700ly (65-90 sectors): gradual
* ~700ly+: unexplored
*/
int dist = isqrt(1 + sx*sx + sy*sy + sz*sz);
s.explored = ((dist <= 90) && ( dist <= 65 || rng.Int32(dist) <= 40)) || Faction::IsHomeSystem(SystemPath(sx, sy, sz, customCount + i));
Uint32 weight = rng.Int32(1000000);
// Frequencies are low enough that we probably don't need this anymore.
if (isqrt(1+sx*sx+sy*sy) > 10)
{
if (weight < 1) {
s.starType[0] = SystemBody::TYPE_STAR_IM_BH; // These frequencies are made up
} else if (weight < 3) {
s.starType[0] = SystemBody::TYPE_STAR_S_BH;
} else if (weight < 5) {
s.starType[0] = SystemBody::TYPE_STAR_O_WF;
} else if (weight < 8) {
s.starType[0] = SystemBody::TYPE_STAR_B_WF;
} else if (weight < 12) {
s.starType[0] = SystemBody::TYPE_STAR_M_WF;
} else if (weight < 15) {
s.starType[0] = SystemBody::TYPE_STAR_K_HYPER_GIANT;
} else if (weight < 18) {
s.starType[0] = SystemBody::TYPE_STAR_G_HYPER_GIANT;
} else if (weight < 23) {
s.starType[0] = SystemBody::TYPE_STAR_O_HYPER_GIANT;
} else if (weight < 28) {
s.starType[0] = SystemBody::TYPE_STAR_A_HYPER_GIANT;
} else if (weight < 33) {
s.starType[0] = SystemBody::TYPE_STAR_F_HYPER_GIANT;
} else if (weight < 41) {
s.starType[0] = SystemBody::TYPE_STAR_B_HYPER_GIANT;
} else if (weight < 48) {
s.starType[0] = SystemBody::TYPE_STAR_M_HYPER_GIANT;
} else if (weight < 58) {
s.starType[0] = SystemBody::TYPE_STAR_K_SUPER_GIANT;
} else if (weight < 68) {
s.starType[0] = SystemBody::TYPE_STAR_G_SUPER_GIANT;
} else if (weight < 78) {
s.starType[0] = SystemBody::TYPE_STAR_O_SUPER_GIANT;
} else if (weight < 88) {
s.starType[0] = SystemBody::TYPE_STAR_A_SUPER_GIANT;
} else if (weight < 98) {
s.starType[0] = SystemBody::TYPE_STAR_F_SUPER_GIANT;
} else if (weight < 108) {
s.starType[0] = SystemBody::TYPE_STAR_B_SUPER_GIANT;
} else if (weight < 158) {
s.starType[0] = SystemBody::TYPE_STAR_M_SUPER_GIANT;
} else if (weight < 208) {
s.starType[0] = SystemBody::TYPE_STAR_K_GIANT;
} else if (weight < 250) {
s.starType[0] = SystemBody::TYPE_STAR_G_GIANT;
} else if (weight < 300) {
s.starType[0] = SystemBody::TYPE_STAR_O_GIANT;
} else if (weight < 350) {
s.starType[0] = SystemBody::TYPE_STAR_A_GIANT;
} else if (weight < 400) {
s.starType[0] = SystemBody::TYPE_STAR_F_GIANT;
} else if (weight < 500) {
s.starType[0] = SystemBody::TYPE_STAR_B_GIANT;
} else if (weight < 700) {
s.starType[0] = SystemBody::TYPE_STAR_M_GIANT;
} else if (weight < 800) {
s.starType[0] = SystemBody::TYPE_STAR_O; // should be 1 but that is boring
} else if (weight < 2000) { // weight < 1300 / 20500
s.starType[0] = SystemBody::TYPE_STAR_B;
} else if (weight < 8000) { // weight < 7300
s.starType[0] = SystemBody::TYPE_STAR_A;
} else if (weight < 37300) { // weight < 37300
s.starType[0] = SystemBody::TYPE_STAR_F;
} else if (weight < 113300) { // weight < 113300
s.starType[0] = SystemBody::TYPE_STAR_G;
} else if (weight < 234300) { // weight < 234300
s.starType[0] = SystemBody::TYPE_STAR_K;
} else if (weight < 250000) { // weight < 250000
s.starType[0] = SystemBody::TYPE_WHITE_DWARF;
} else if (weight < 900000) { //weight < 900000
s.starType[0] = SystemBody::TYPE_STAR_M;
} else {
s.starType[0] = SystemBody::TYPE_BROWN_DWARF;
}
} else {
if (weight < 100) { // should be 1 but that is boring
s.starType[0] = SystemBody::TYPE_STAR_O;
} else if (weight < 1300) {
s.starType[0] = SystemBody::TYPE_STAR_B;
} else if (weight < 7300) {
s.starType[0] = SystemBody::TYPE_STAR_A;
} else if (weight < 37300) {
s.starType[0] = SystemBody::TYPE_STAR_F;
} else if (weight < 113300) {
s.starType[0] = SystemBody::TYPE_STAR_G;
} else if (weight < 234300) {
s.starType[0] = SystemBody::TYPE_STAR_K;
} else if (weight < 250000) {
s.starType[0] = SystemBody::TYPE_WHITE_DWARF;
} else if (weight < 900000) {
s.starType[0] = SystemBody::TYPE_STAR_M;
} else {
s.starType[0] = SystemBody::TYPE_BROWN_DWARF;
}
}
//Output("%d: %d%\n", sx, sy);
if (s.numStars > 1) {
s.starType[1] = SystemBody::BodyType(rng.Int32(SystemBody::TYPE_STAR_MIN, s.starType[0]));
if (s.numStars > 2) {
s.starType[2] = SystemBody::BodyType(rng.Int32(SystemBody::TYPE_STAR_MIN, s.starType[0]));
s.starType[3] = SystemBody::BodyType(rng.Int32(SystemBody::TYPE_STAR_MIN, s.starType[2]));
}
}
if ((s.starType[0] <= SystemBody::TYPE_STAR_A) && (rng.Int32(10)==0)) {
// make primary a giant. never more than one giant in a system
// while
if (isqrt(1+sx*sx+sy*sy) > 10)
{
weight = rng.Int32(1000);
if (weight >= 999) {
s.starType[0] = SystemBody::TYPE_STAR_B_HYPER_GIANT;
} else if (weight >= 998) {
s.starType[0] = SystemBody::TYPE_STAR_O_HYPER_GIANT;
} else if (weight >= 997) {
s.starType[0] = SystemBody::TYPE_STAR_K_HYPER_GIANT;
} else if (weight >= 995) {
s.starType[0] = SystemBody::TYPE_STAR_B_SUPER_GIANT;
} else if (weight >= 993) {
s.starType[0] = SystemBody::TYPE_STAR_O_SUPER_GIANT;
} else if (weight >= 990) {
s.starType[0] = SystemBody::TYPE_STAR_K_SUPER_GIANT;
} else if (weight >= 985) {
s.starType[0] = SystemBody::TYPE_STAR_B_GIANT;
} else if (weight >= 980) {
s.starType[0] = SystemBody::TYPE_STAR_O_GIANT;
} else if (weight >= 975) {
s.starType[0] = SystemBody::TYPE_STAR_K_GIANT;
} else if (weight >= 950) {
s.starType[0] = SystemBody::TYPE_STAR_M_HYPER_GIANT;
} else if (weight >= 875) {
s.starType[0] = SystemBody::TYPE_STAR_M_SUPER_GIANT;
} else {
s.starType[0] = SystemBody::TYPE_STAR_M_GIANT;
}
} else if (isqrt(1+sx*sx+sy*sy) > 5) s.starType[0] = SystemBody::TYPE_STAR_M_GIANT;
else s.starType[0] = SystemBody::TYPE_STAR_M;
//Output("%d: %d%\n", sx, sy);
}
s.name = GenName(s, customCount + i, rng);
//Output("%s: \n", s.name.c_str());
m_systems.push_back(s);
}
}
void Pi::HandleEvents()
{
PROFILE_SCOPED()
SDL_Event event;
// XXX for most keypresses SDL will generate KEYUP/KEYDOWN and TEXTINPUT
// events. keybindings run off KEYUP/KEYDOWN. the console is opened/closed
// via keybinding. the console TextInput widget uses TEXTINPUT events. thus
// after switching the console, the stray TEXTINPUT event causes the
// console key (backtick) to appear in the text entry field. we hack around
// this by setting this flag if the console was switched. if its set, we
// swallow the TEXTINPUT event this hack must remain until we have a
// unified input system
bool skipTextInput = false;
Pi::mouseMotion[0] = Pi::mouseMotion[1] = 0;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
if (Pi::game)
Pi::EndGame();
Pi::Quit();
}
if (skipTextInput && event.type == SDL_TEXTINPUT) {
skipTextInput = false;
continue;
}
if (ui->DispatchSDLEvent(event))
continue;
bool consoleActive = Pi::IsConsoleActive();
if (!consoleActive)
KeyBindings::DispatchSDLEvent(&event);
else
KeyBindings::toggleLuaConsole.CheckSDLEventAndDispatch(&event);
if (consoleActive != Pi::IsConsoleActive()) {
skipTextInput = true;
continue;
}
if (Pi::IsConsoleActive())
continue;
Gui::HandleSDLEvent(&event);
switch (event.type) {
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE) {
if (Pi::game) {
// only accessible once game started
if (currentView != 0) {
if (currentView != Pi::game->GetSettingsView()) {
Pi::game->SetTimeAccel(Game::TIMEACCEL_PAUSED);
SetView(Pi::game->GetSettingsView());
}
else {
Pi::game->RequestTimeAccel(Game::TIMEACCEL_1X);
SetView(Pi::player->IsDead()
? static_cast<View*>(Pi::game->GetDeathView())
: static_cast<View*>(Pi::game->GetWorldView()));
}
}
}
break;
}
// special keys. LCTRL+turd
if ((KeyState(SDLK_LCTRL) || (KeyState(SDLK_RCTRL)))) {
switch (event.key.keysym.sym) {
case SDLK_q: // Quit
if (Pi::game)
Pi::EndGame();
Pi::Quit();
break;
case SDLK_PRINTSCREEN: // print
case SDLK_KP_MULTIPLY: // screen
{
char buf[256];
const time_t t = time(0);
struct tm *_tm = localtime(&t);
strftime(buf, sizeof(buf), "screenshot-%Y%m%d-%H%M%S.png", _tm);
Graphics::ScreendumpState sd;
Pi::renderer->Screendump(sd);
write_screenshot(sd, buf);
break;
}
#if WITH_DEVKEYS
case SDLK_i: // Toggle Debug info
Pi::showDebugInfo = !Pi::showDebugInfo;
break;
#ifdef PIONEER_PROFILER
case SDLK_p: // alert it that we want to profile
if (KeyState(SDLK_LSHIFT) || KeyState(SDLK_RSHIFT))
Pi::doProfileOne = true;
else {
Pi::doProfileSlow = !Pi::doProfileSlow;
Output("slow frame profiling %s\n", Pi::doProfileSlow ? "enabled" : "disabled");
}
break;
#endif
case SDLK_F12:
{
if(Pi::game) {
vector3d dir = -Pi::player->GetOrient().VectorZ();
/* add test object */
if (KeyState(SDLK_RSHIFT)) {
Missile *missile =
new Missile(ShipType::MISSILE_GUIDED, Pi::player);
missile->SetOrient(Pi::player->GetOrient());
missile->SetFrame(Pi::player->GetFrame());
missile->SetPosition(Pi::player->GetPosition()+50.0*dir);
missile->SetVelocity(Pi::player->GetVelocity());
game->GetSpace()->AddBody(missile);
missile->AIKamikaze(Pi::player->GetCombatTarget());
} else if (KeyState(SDLK_LSHIFT)) {
SpaceStation *s = static_cast<SpaceStation*>(Pi::player->GetNavTarget());
if (s) {
Ship *ship = new Ship(ShipType::POLICE);
int port = s->GetFreeDockingPort(ship);
if (port != -1) {
Output("Putting ship into station\n");
// Make police ship intent on killing the player
ship->AIKill(Pi::player);
ship->SetFrame(Pi::player->GetFrame());
ship->SetDockedWith(s, port);
game->GetSpace()->AddBody(ship);
} else {
delete ship;
Output("No docking ports free dude\n");
}
} else {
Output("Select a space station...\n");
}
} else {
Ship *ship = new Ship(ShipType::POLICE);
if( KeyState(SDLK_LCTRL) )
ship->AIFlyTo(Pi::player); // a less lethal option
else
ship->AIKill(Pi::player); // a really lethal option!
lua_State *l = Lua::manager->GetLuaState();
pi_lua_import(l, "Equipment");
LuaTable equip(l, -1);
LuaObject<Ship>::CallMethod<>(ship, "AddEquip", equip.Sub("laser").Sub("pulsecannon_dual_1mw"));
LuaObject<Ship>::CallMethod<>(ship, "AddEquip", equip.Sub("misc").Sub("laser_cooling_booster"));
LuaObject<Ship>::CallMethod<>(ship, "AddEquip", equip.Sub("misc").Sub("atmospheric_shielding"));
lua_pop(l, 5);
ship->SetFrame(Pi::player->GetFrame());
ship->SetPosition(Pi::player->GetPosition()+100.0*dir);
ship->SetVelocity(Pi::player->GetVelocity());
ship->UpdateEquipStats();
game->GetSpace()->AddBody(ship);
}
}
break;
}
#endif /* DEVKEYS */
#if WITH_OBJECTVIEWER
case SDLK_F10:
Pi::SetView(Pi::game->GetObjectViewerView());
break;
#endif
case SDLK_F11:
// XXX only works on X11
//SDL_WM_ToggleFullScreen(Pi::scrSurface);
#if WITH_DEVKEYS
renderer->ReloadShaders();
#endif
break;
case SDLK_F9: // Quicksave
{
if(Pi::game) {
if (Pi::game->IsHyperspace())
Pi::game->log->Add(Lang::CANT_SAVE_IN_HYPERSPACE);
else {
const std::string name = "_quicksave";
const std::string path = FileSystem::JoinPath(GetSaveDir(), name);
try {
Game::SaveGame(name, Pi::game);
Pi::game->log->Add(Lang::GAME_SAVED_TO + path);
} catch (CouldNotOpenFileException) {
Pi::game->log->Add(stringf(Lang::COULD_NOT_OPEN_FILENAME, formatarg("path", path)));
}
catch (CouldNotWriteToFileException) {
Pi::game->log->Add(Lang::GAME_SAVE_CANNOT_WRITE);
}
}
}
break;
}
default:
break; // This does nothing but it stops the compiler warnings
}
}
Pi::keyState[event.key.keysym.sym] = true;
Pi::keyModState = event.key.keysym.mod;
Pi::onKeyPress.emit(&event.key.keysym);
break;
case SDL_KEYUP:
Pi::keyState[event.key.keysym.sym] = false;
Pi::keyModState = event.key.keysym.mod;
Pi::onKeyRelease.emit(&event.key.keysym);
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button < COUNTOF(Pi::mouseButton)) {
Pi::mouseButton[event.button.button] = 1;
Pi::onMouseButtonDown.emit(event.button.button,
event.button.x, event.button.y);
}
break;
case SDL_MOUSEBUTTONUP:
if (event.button.button < COUNTOF(Pi::mouseButton)) {
Pi::mouseButton[event.button.button] = 0;
Pi::onMouseButtonUp.emit(event.button.button,
event.button.x, event.button.y);
}
break;
case SDL_MOUSEWHEEL:
Pi::onMouseWheel.emit(event.wheel.y > 0); // true = up
break;
case SDL_MOUSEMOTION:
Pi::mouseMotion[0] += event.motion.xrel;
Pi::mouseMotion[1] += event.motion.yrel;
// SDL_GetRelativeMouseState(&Pi::mouseMotion[0], &Pi::mouseMotion[1]);
break;
case SDL_JOYAXISMOTION:
if (!joysticks[event.jaxis.which].joystick)
break;
if (event.jaxis.value == -32768)
joysticks[event.jaxis.which].axes[event.jaxis.axis] = 1.f;
else
joysticks[event.jaxis.which].axes[event.jaxis.axis] = -event.jaxis.value / 32767.f;
break;
case SDL_JOYBUTTONUP:
case SDL_JOYBUTTONDOWN:
if (!joysticks[event.jaxis.which].joystick)
break;
joysticks[event.jbutton.which].buttons[event.jbutton.button] = event.jbutton.state != 0;
break;
case SDL_JOYHATMOTION:
if (!joysticks[event.jaxis.which].joystick)
break;
joysticks[event.jhat.which].hats[event.jhat.hat] = event.jhat.value;
break;
}
}
}
void Group::Render(const matrix4x4f &trans, const RenderData *rd)
{
PROFILE_SCOPED()
RenderChildren(trans, rd);
}
